예제 #1
0
        public override void OnDraw()
        {
            IPixelFormat pixf;

            if (this.bpp() == 32)
            {
                pixf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
                //pixf = new pixfmt_alpha_blend_rgba32(rbuf_window(), new blender_rgba32());
            }
            else
            {
                if (bpp() != 24)
                {
                    throw new System.NotSupportedException();
                }
                pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
            }
            FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);

            clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));

            g_rasterizer.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), width(), height());

            if (m_trans_type.cur_item() == 0)
            {
                Bilinear <T> tr = new Bilinear <T>(g_x1, g_y1, g_x2, g_y2, m_quad.polygon());
                if (tr.IsValid())
                {
                    //--------------------------
                    // Render transformed lion
                    //
                    ConvTransform <T> trans = new ConvTransform <T>(g_path, tr);

                    Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);

                    //--------------------------



                    //--------------------------
                    // Render transformed ellipse
                    //
                    VertexSource.Ellipse <T> ell = new AGG.VertexSource.Ellipse <T>(g_x1.Add(g_x2).Multiply(0.5), g_y1.Add(g_y2).Multiply(0.5),
                                                                                    g_x2.Subtract(g_x1).Multiply(0.5), g_y2.Subtract(g_y1).Multiply(0.5),
                                                                                    200);
                    ConvStroke <T> ell_stroke = new ConvStroke <T>(ell);
                    ell_stroke.Width = M.New <T>(3.0);
                    ConvTransform <T> trans_ell = new ConvTransform <T>(ell, tr);

                    ConvTransform <T> trans_ell_stroke = new ConvTransform <T>(ell_stroke, tr);

                    g_rasterizer.AddPath(trans_ell);
                    Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.5, 0.3, 0.0, 0.3));

                    g_rasterizer.AddPath(trans_ell_stroke);
                    Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.0, 0.3, 0.2, 1.0));
                }
            }
            else
            {
                Perspective <T> tr = new Perspective <T>(g_x1, g_y1, g_x2, g_y2, m_quad.polygon());
                if (tr.IsValid())
                {
                    // Render transformed lion
                    ConvTransform <T> trans = new ConvTransform <T>(g_path, tr);

                    Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);

                    // Render transformed ellipse
                    VertexSource.Ellipse <T> FilledEllipse = new AGG.VertexSource.Ellipse <T>(g_x1.Add(g_x2).Multiply(0.5), g_y1.Add(g_y2).Multiply(0.5),
                                                                                              g_x2.Subtract(g_x1).Multiply(0.5), g_y2.Subtract(g_y1).Multiply(0.5),
                                                                                              200);

                    ConvStroke <T> EllipseOutline = new ConvStroke <T>(FilledEllipse);
                    EllipseOutline.Width = M.New <T>(3.0);
                    ConvTransform <T> TransformedFilledEllipse = new ConvTransform <T>(FilledEllipse, tr);

                    ConvTransform <T> TransformedEllipesOutline = new ConvTransform <T>(EllipseOutline, tr);

                    g_rasterizer.AddPath(TransformedFilledEllipse);
                    Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.5, 0.3, 0.0, 0.3));

                    g_rasterizer.AddPath(TransformedEllipesOutline);
                    Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.0, 0.3, 0.2, 1.0));
                }
            }

            //--------------------------
            // Render the "quad" tool and controls
            g_rasterizer.AddPath(m_quad);
            Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0.3, 0.5, 0.6));

            //m_trans_type.Render(g_rasterizer, g_scanline, clippingProxy);
            base.OnDraw();
        }
        void DrawingPanel_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;


            Matrix4 mtx = Matrix4.CreateTranslation(-m_SVGPathBounds.Center.X, -m_SVGPathBounds.Center.Y);

            mtx.Scale(m_Scale, m_Scale, MatrixOrder.Append);
            mtx.Translate(m_x, m_y, MatrixOrder.Append);


            ITransform transform = null;

            if (rbBilinear.IsChecked)
            {
                Bilinear tr = new Bilinear(
                    m_SVGPathScaledBounds.Left, m_SVGPathScaledBounds.Top,
                    m_SVGPathScaledBounds.Right, m_SVGPathScaledBounds.Bottom, m_PolygonElement.Polygon);

                if (tr.IsValid)
                {
                    transform = tr;
                }
            }
            else
            {
                Perspective tr = new Perspective(
                    m_SVGPathScaledBounds.Left, m_SVGPathScaledBounds.Top,
                    m_SVGPathScaledBounds.Right, m_SVGPathScaledBounds.Bottom, m_PolygonElement.Polygon);

                if (tr.IsValid() &&
                    Perspective.IsConvex(m_PolygonElement.Polygon))
                {
                    transform = tr;
                }
            }


            //
            GeometryTransformer transformer = null;

            if (transform != null)
            {
                transformer = new GeometryTransformer(transform);
            }


            // Render transformed SVG
            m_SVGPath.Render(e.Graphics, mtx, transformer);


            // Render transformed ellipse
            Point           center        = m_SVGPathScaledBounds.Center;
            EllipseGeometry FilledEllipse = new EllipseGeometry(center.X, center.Y, m_SVGPathScaledBounds.Width / 2, m_SVGPathScaledBounds.Height / 2, 200);

            GeometryStroke EllipseOutline = new GeometryStroke(FilledEllipse);

            EllipseOutline.Width = 3.0;


            Geometry TransformedFilledEllipse  = FilledEllipse;
            Geometry TransformedEllipesOutline = EllipseOutline;

            if (transform != null)
            {
                TransformedFilledEllipse  = new GeometryTransformer(FilledEllipse, transform);
                TransformedEllipesOutline = new GeometryTransformer(EllipseOutline, transform);
            }

            SmoothingMode saveSmoothingMode = e.Graphics.SmoothingMode;

            e.Graphics.SmoothingMode = SmoothingMode.None;
            {
                e.Graphics.FillGeometry(m_EllipseBrush, TransformedFilledEllipse);
            }
            e.Graphics.SmoothingMode = saveSmoothingMode;

            e.Graphics.FillGeometry(m_EllipsePen.Color, TransformedEllipesOutline);
        }