Пример #1
0
        public virtual void BeforeRender()
        {
            if (!this.lerpCacheIsValid)
            {
                byte startAlpha;
                byte endAlpha;

                if (this.alphaOnly)
                {
                    ComputeAlphaOnlyValuesFromColors(this.startColor, this.endColor, out startAlpha, out endAlpha);
                }
                else
                {
                    startAlpha = this.startColor.A;
                    endAlpha   = this.endColor.A;
                }

                this.lerpAlphas = new byte[256];
                this.lerpColors = new ColorBgra[256];

                for (int i = 0; i < 256; ++i)
                {
                    byte a = (byte)i;
                    this.lerpColors[a] = ColorBgra.Blend(this.startColor, this.endColor, a);
                    this.lerpAlphas[a] = (byte)(startAlpha + ((endAlpha - startAlpha) * a) / 255);
                }

                this.lerpCacheIsValid = true;
            }
        }
Пример #2
0
        private void DrawToGraphics(Graphics g)
        {
            ColorBgra colorSolid = ColorBgra.FromColor(this.ForeColor);
            ColorBgra colorGuide = ColorBgra.FromColor(this.ForeColor);
            ColorBgra colorGrid  = ColorBgra.FromColor(this.ForeColor);

            colorGrid.A  = 128;
            colorGuide.A = 96;

            Pen penSolid = new Pen(colorSolid.ToColor(), 1);
            Pen penGrid  = new Pen(colorGrid.ToColor(), 1);
            Pen penGuide = new Pen(colorGuide.ToColor(), 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);
            }

            for (float f = 0.25f; f <= 0.75f; f += 0.25f)
            {
                float x = Utility.Lerp(ourRect.Left, ourRect.Right, f);
                float y = Utility.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)));
            }

            g.DrawLine(penGrid, ourRect.Left, ourRect.Bottom, ourRect.Right, ourRect.Top);

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

            for (int c = 0; c < channels; ++c)
            {
                SortedList <int, int> channelControlPoints = controlPoints[c];
                int points = channelControlPoints.Count;

                ColorBgra color         = GetVisualColor(c);
                ColorBgra colorSelected = ColorBgra.Blend(color, ColorBgra.White, 128);

                const float penWidthNonSelected = 1;
                const float penWidthSelected    = 2;
                float       penWidth            = mask[c] ? penWidthSelected : penWidthNonSelected;
                Pen         penSelected         = new Pen(color.ToColor(), penWidth);

                color.A = 128;

                Pen        pen           = new Pen(color.ToColor(), penWidth);
                Brush      brush         = new SolidBrush(color.ToColor());
                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)(Utility.Clamp(entries - 1 - interpolator.Interpolate(i), 0, entries - 1)) *
                                (height - 1) / (entries - 1);
                }

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

                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);

                    const float radiusSelected    = 4;
                    const float radiusNotSelected = 3;
                    const float radiusUnMasked    = 2;

                    bool       selected = (mask[c] && pointsNearMousePerChannel[c] == i);
                    float      size     = selected ? radiusSelected : (mask[c] ? radiusNotSelected : radiusUnMasked);
                    RectangleF rect     = Utility.RectangleFromCenter(new PointF(x, y), 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();
        }