Esempio n. 1
0
        override public bool computeOutput(ConnectionPoint connPoint, OutputGenerationParams parms)
        {
            if (!verifyInputConnections())
            {
                return(false);
            }

            if (!gatherInputAndParameters(parms))
            {
                return(false);
            }

            MaskParam mp = ((MaskParam)(connPoint.ParamType));

            mp.Value = InputMask.Clone();
            mp.Value.mConstraintMask = ConstraintMask;

            SplineInterpolator interpolator = new SplineInterpolator();

            for (int i = 0; i < ControlPointsKeys.Count; ++i)
            {
                interpolator.Add(ControlPointsKeys[i], ControlPointsValues[i]);
            }


            for (int x = 0; x < parms.Width; x++)
            {
                for (int y = 0; y < parms.Height; y++)
                {
                    float v = mp.Value[x, y];

                    mp.Value[x, y] = (float)interpolator.Interpolate(v);
                }
            }


            interpolator.Clear();
            interpolator = null;
            return(true);
        }
Esempio n. 2
0
        private void DrawToGraphics(Graphics g)
        {
            Color colorSolid = Color.FromArgb(this.ForeColor.A, this.ForeColor.R, this.ForeColor.G, this.ForeColor.B);
            Color colorGuide = Color.FromArgb(96, this.ForeColor.R, this.ForeColor.G, this.ForeColor.B);
            Color colorGrid  = Color.FromArgb(128, this.ForeColor.R, this.ForeColor.G, this.ForeColor.B);

            Pen penSolid = new Pen(colorSolid, 1);
            Pen penGrid  = new Pen(colorGrid, 1);
            Pen penGuide = new Pen(colorGuide, 1);

            penGrid.DashStyle = DashStyle.Dash;

            g.Clear(this.BackColor);
            g.SmoothingMode = SmoothingMode.AntiAlias;

            Rectangle ourRect = ClientRectangle;

            ourRect.Inflate(-1, -1);

            if (lastMouseXY.Y >= 0)
            {
                g.DrawLine(penGuide, 0, lastMouseXY.Y, Width, lastMouseXY.Y);
            }

            if (lastMouseXY.X >= 0)
            {
                g.DrawLine(penGuide, lastMouseXY.X, 0, lastMouseXY.X, Height);
            }

            //draw grid lines
            for (float f = 0.25f; f <= 0.75f; f += 0.25f)
            {
                float x = BMathLib.LERP(ourRect.Left, ourRect.Right, f);
                float y = BMathLib.LERP(ourRect.Top, ourRect.Bottom, f);

                g.DrawLine(penGrid,
                           Point.Round(new PointF(x, ourRect.Top)),
                           Point.Round(new PointF(x, ourRect.Bottom)));

                g.DrawLine(penGrid,
                           Point.Round(new PointF(ourRect.Left, y)),
                           Point.Round(new PointF(ourRect.Right, y)));
            }

            //draw 'perfect' line
            g.DrawLine(penGrid, ourRect.Left, ourRect.Bottom, ourRect.Right, ourRect.Top);



            float width  = this.ClientRectangle.Width;
            float height = this.ClientRectangle.Height;

            {
                SortedList <int, int> channelControlPoints = controlPoints;
                int points = channelControlPoints.Count;

                Color color = Color.FromArgb(128, 0, 0, 0);


                float penWidthSelected = 2;
                float penWidth         = penWidthSelected;
                Pen   penSelected      = new Pen(color, penWidth);



                Pen        pen           = new Pen(color, penWidth);
                Brush      brush         = new SolidBrush(color);
                SolidBrush brushSelected = new SolidBrush(Color.White);

                SplineInterpolator interpolator = new SplineInterpolator();
                IList <int>        xa           = channelControlPoints.Keys;
                IList <int>        ya           = channelControlPoints.Values;
                PointF[]           line         = new PointF[Entries];

                for (int i = 0; i < points; ++i)
                {
                    interpolator.Add(xa[i], ya[i]);
                }

                for (int i = 0; i < line.Length; ++i)
                {
                    line[i].X = (float)i * (width - 1) / (entries - 1);
                    line[i].Y = (float)(BMathLib.Clamp((float)(entries - 1 - interpolator.Interpolate(i)), 0, entries - 1)) *
                                (height - 1) / (entries - 1);
                }

                pen.LineJoin = LineJoin.Round;
                g.DrawLines(pen, line);

                //draw our control points
                for (int i = 0; i < points; ++i)
                {
                    int   k = channelControlPoints.Keys[i];
                    float x = k * (width - 1) / (entries - 1);
                    float y = (entries - 1 - channelControlPoints.Values[i]) * (height - 1) / (entries - 1);

                    float radiusSelected    = 8;
                    float radiusNotSelected = 6;

                    bool       selected = (pointsNearMousePerChannel == i);
                    float      size     = selected ? radiusSelected : (radiusNotSelected);
                    RectangleF rect     = new RectangleF(x - (size * 0.5f), y - (size * 0.5f), size, size);

                    g.FillEllipse(selected ? brushSelected : brush, rect.X, rect.Y, rect.Width, rect.Height);
                    g.DrawEllipse(selected ? penSelected : pen, rect.X, rect.Y, rect.Width, rect.Height);
                }

                pen.Dispose();
            }

            penSolid.Dispose();
            penGrid.Dispose();
            penGuide.Dispose();
        }