Пример #1
0
        protected override void OnTick(double delta)
        {
            if (m_IsAnimated)
            {
                PolygonElement polygon1 = m_PolygonElement1;
                PolygonElement polygon2 = m_PolygonElement2;
                double         x, y;
                for (int i = 0; i < 6; i++)
                {
                    x = polygon1.GetXn(i);
                    y = polygon1.GetYn(i);
                    MovePoint(ref x, ref y, ref m_dx1[i], ref m_dy1[i]);
                    polygon1.SetXn(i, x);
                    polygon1.SetYn(i, y);

                    x = polygon2.GetXn(i);
                    y = polygon2.GetYn(i);
                    MovePoint(ref x, ref y, ref m_dx2[i], ref m_dy2[i]);
                    polygon2.SetXn(i, x);
                    polygon2.SetYn(i, y);

                    NormalizePoint(i);
                }

                Refresh();
            }

            base.OnTick(delta);
        }
Пример #2
0
        void NormalizePoint(int i)
        {
            PolygonElement polygon1 = m_PolygonElement1;
            PolygonElement polygon2 = m_PolygonElement2;

            double d = MathHelper.Distance(polygon1.GetXn(i), polygon1.GetYn(i), polygon2.GetXn(i), polygon2.GetYn(i));
            double k = 20 * System.Math.Sqrt(2) * 3;

            if (d > k)
            {
                polygon2.SetXn(i, polygon1.GetXn(i) + (polygon2.GetXn(i) - polygon1.GetXn(i)) * k / d);
                polygon2.SetYn(i, polygon1.GetYn(i) + (polygon2.GetYn(i) - polygon1.GetYn(i)) * k / d);
            }
        }
        void LoadSVG(string fname)
        {
            SVGParser p = new SVGParser(m_SVGPath);

            p.Parse(fname);
            m_SVGPath.ArrangeOrientations();
            m_SVGPathBounds = m_SVGPath.Bounds;

            m_Scale = System.Math.Min(m_DrawingPanel.ClientWidth / m_SVGPathBounds.Width, m_DrawingPanel.ClientHeight / m_SVGPathBounds.Height) * 0.75;

            m_SVGPathScaledBounds         = m_SVGPathBounds - m_SVGPathBounds.Location;
            m_SVGPathScaledBounds.Width  *= m_Scale;
            m_SVGPathScaledBounds.Height *= m_Scale;
            m_SVGPathScaledBounds        += new Point(m_x, m_y) - m_SVGPathScaledBounds.Center;
            m_PolygonElement.SetXn(0, m_SVGPathScaledBounds.Left);
            m_PolygonElement.SetYn(0, m_SVGPathScaledBounds.Top);
            m_PolygonElement.SetXn(1, m_SVGPathScaledBounds.Right);
            m_PolygonElement.SetYn(1, m_SVGPathScaledBounds.Top);
            m_PolygonElement.SetXn(2, m_SVGPathScaledBounds.Right);
            m_PolygonElement.SetYn(2, m_SVGPathScaledBounds.Bottom);
            m_PolygonElement.SetXn(3, m_SVGPathScaledBounds.Left);
            m_PolygonElement.SetYn(3, m_SVGPathScaledBounds.Bottom);
        }
Пример #4
0
            void InitPoly()
            {
                PolygonElement polygon = m_PolygonElement;
                int            offset  = 100;
                int            quad    = System.Math.Min(ClientRectangle.Width, ClientRectangle.Height);
                int            x       = ClientRectangle.X + (ClientRectangle.Width - quad) / 2;
                int            y       = ClientRectangle.Y + (ClientRectangle.Height - quad) / 2;

                if (m_PolygonFlip)
                {
                    polygon.SetXn(0, x + offset);
                    polygon.SetYn(0, y + quad - offset);
                    polygon.SetXn(1, x + quad - offset);
                    polygon.SetYn(1, y + quad - offset);
                    polygon.SetXn(2, x + quad - offset);
                    polygon.SetYn(2, y + offset);
                    polygon.SetXn(3, x + offset);
                    polygon.SetYn(3, y + offset);
                }
                else
                {
                    polygon.SetXn(0, x + offset);
                    polygon.SetYn(0, y + offset);
                    polygon.SetXn(1, x + quad - offset);
                    polygon.SetYn(1, y + offset);
                    polygon.SetXn(2, x + quad - offset);
                    polygon.SetYn(2, y + quad - offset);
                    polygon.SetXn(3, x + offset);
                    polygon.SetYn(3, y + quad - offset);
                }

                polygon.SetXn(4, x + quad / 2);
                polygon.SetYn(4, y + quad / 2);
                polygon.SetXn(5, x + quad / 2);
                polygon.SetYn(5, y + quad / 1.5);
            }
        protected override void OnTick(double delta)
        {
            if (m_IsAnimated)
            {
                PolygonElement polygon = m_PolygonElement;
                double         x, y;
                for (int i = 0; i < 6; i++)
                {
                    x = polygon.GetXn(i);
                    y = polygon.GetYn(i);
                    MovePoint(ref x, ref y, ref m_dx[i], ref m_dy[i]);
                    polygon.SetXn(i, x);
                    polygon.SetYn(i, y);
                }

                Refresh();
            }

            base.OnTick(delta);
        }
        void InitPoly()
        {
            int dx = (ClientRectangle.Width - 2 * InternalOffset) / 5;
            int dy = (ClientRectangle.Height - 2 * InternalOffset) / 5;

            PolygonElement polygon = m_PolygonElement;
            int            x       = ClientRectangle.Left + InternalOffset;
            int            y       = ClientRectangle.Top + InternalOffset;

            polygon.SetXn(0, x);
            polygon.SetYn(0, y);
            polygon.SetXn(1, (x += dx) + 20);
            polygon.SetYn(1, (y += dy) - 20);
            polygon.SetXn(2, (x += dx) - 20);
            polygon.SetYn(2, (y += dy) + 20);
            polygon.SetXn(3, (x += dx) + 20);
            polygon.SetYn(3, (y += dy) - 20);
            polygon.SetXn(4, (x += dx) - 20);
            polygon.SetYn(4, (y += dy) + 20);
            polygon.SetXn(5, (x += dx));
            polygon.SetYn(5, (y += dy));
        }
Пример #7
0
        void InitPoly()
        {
            int dx = (ClientRectangle.Width - 2 * InternalOffset) / 5;
            int dy = (ClientRectangle.Height - 2 * InternalOffset) / 5;

            PolygonElement polygon = m_PolygonElement1;
            int            x       = ClientRectangle.Left + InternalOffset;
            int            y       = ClientRectangle.Top + InternalOffset;

            int k1 = 30;
            int k2 = 20;

            polygon.SetXn(0, x + k1);
            polygon.SetYn(0, y - k1);
            polygon.SetXn(1, (x += dx) + k1 + k2);
            polygon.SetYn(1, (y += dy) - k1 - k2);
            polygon.SetXn(2, (x += dx) + k1 - k2);
            polygon.SetYn(2, (y += dy) - k1 + k2);
            polygon.SetXn(3, (x += dx) + k1 + k2);
            polygon.SetYn(3, (y += dy) - k1 - k2);
            polygon.SetXn(4, (x += dx) + k1 - k2);
            polygon.SetYn(4, (y += dy) - k1 + k2);
            polygon.SetXn(5, (x += dx) + k1);
            polygon.SetYn(5, (y += dy) - k1);

            polygon = m_PolygonElement2;
            x       = ClientRectangle.Left + InternalOffset;
            y       = ClientRectangle.Top + InternalOffset;

            polygon.SetXn(0, x - k1);
            polygon.SetYn(0, y + k1);
            polygon.SetXn(1, (x += dx) - k1 + k2);
            polygon.SetYn(1, (y += dy) + k1 - k2);
            polygon.SetXn(2, (x += dx) - k1 - k2);
            polygon.SetYn(2, (y += dy) + k1 + k2);
            polygon.SetXn(3, (x += dx) - k1 + k2);
            polygon.SetYn(3, (y += dy) + k1 - k2);
            polygon.SetXn(4, (x += dx) - k1 - k2);
            polygon.SetYn(4, (y += dy) + k1 + k2);
            polygon.SetXn(5, (x += dx) - k1);
            polygon.SetYn(5, (y += dy) + k1);
        }