public WeldJointDef()
 {
     JointType = JointType.Weld;
     _localAnchorA = Vec2.Empty;
     _localAnchorB = Vec2.Empty;
     _referenceAngle = 0.0f;
 }

        public LineJoint()
        {
            Body ground = null;
            {
                PolygonShape shape = new PolygonShape();
                shape.SetAsEdge(new Vec2(-40.0f, 0.0f), new Vec2(40.0f, 0.0f));

                BodyDef bd = new BodyDef();
                ground = m_world.CreateBody(bd);
                ground.CreateFixture(shape, 0.0f);
            }

            {
                PolygonShape shape = new PolygonShape();
                shape.SetAsBox(0.5f, 2.0f);

                BodyDef bd = new BodyDef();
                bd.BodyType = BodyType.Dynamic;
                bd.Position = new Vec2(0.0f, 7.0f);
                Body body = m_world.CreateBody(bd);
                body.CreateFixture(shape, 1.0f);

                LineJointDef jd = new LineJointDef();
                Vec2 axis = new Vec2(2.0f, 1.0f);
                axis.Normalize();
                jd.Initialize(ground, body, new Vec2(0.0f, 8.5f), axis);
                jd.MotorSpeed = 0.0f;
                jd.MaxMotorForce = 100.0f;
                jd.EnableMotor = true;
                jd.LowerTranslation = -4.0f;
                jd.UpperTranslation = 4.0f;
                jd.EnableLimit = true;
                m_world.CreateJoint(jd);
            }
        }

        public override void DrawSolidCircle(Vec2 center, float radius, Vec2 axis, ColorF color)
        {
            float k_segments = (int)(1024.0f * (radius / 50));
            float k_increment = (float)(2.0f * Math.PI / k_segments);
            float theta = 0.0f;
            Gl.glEnable(Gl.GL_BLEND);
            Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
            Gl.glColor4f(0.5f * color.R, 0.5f * color.G, 0.5f * color.B, 0.5f);
            Gl.glBegin(Gl.GL_TRIANGLE_FAN);
            for (int i = 0; i < k_segments; ++i)
            {
                Vec2 v = center + radius * new Vec2((float)Math.Cos(theta), (float)Math.Sin(theta));
                Gl.glVertex2f(v.X, v.Y);
                theta += k_increment;
            }
            Gl.glEnd();
            Gl.glDisable(Gl.GL_BLEND);

            theta = 0.0f;
            Gl.glColor4f(color.R, color.G, color.B, 1.0f);
            Gl.glBegin(Gl.GL_LINE_LOOP);
            for (int i = 0; i < k_segments; ++i)
            {
                Vec2 v = center + radius * new Vec2((float)Math.Cos(theta), (float)Math.Sin(theta));
                Gl.glVertex2f(v.X, v.Y);
                theta += k_increment;
            }
            Gl.glEnd();

            Vec2 p = center + radius * axis;
            Gl.glBegin(Gl.GL_LINES);
            Gl.glVertex2f(center.X, center.Y);
            Gl.glVertex2f(p.X, p.Y);
            Gl.glEnd();
        }

        void Report(Vec2 point, Vec2 normal)
        {
            _hit++;
            Vec2 sub = _start - point;
            float len = sub.Length();

            if (_hit > 100 || _start == point || len == 0)
                return;

            starts.Add(_start);
            ends.Add(point);

            var reflect = Reflect(_start, point, normal);

            _length -= len;
            _start = point;
            _normal = normal;

            if (_length > 0)
            {
                _world.RayCast(_callback, _start, _start - (reflect * _length));

                if (!_callback.m_hit || (_start == _callback.m_point))
                {
                    starts.Add(_start);
                    ends.Add(_start - (reflect * _length));
                }

                Report(_callback.m_point, _callback.m_normal);
            }
        }

 public FrictionJointDef()
 {
     JointType = JointType.Friction;
     _localAnchorA = Vec2.Empty;
     _localAnchorB = Vec2.Empty;
     _maxForce = 0.0f;
     _maxTorque = 0.0f;
 }

 public override void DrawSegment(Vec2 p1, Vec2 p2, ColorF color)
 {
     Gl.glColor3f(color.R, color.G, color.B);
     Gl.glBegin(Gl.GL_LINES);
     Gl.glVertex2f(p1.X, p1.Y);
     Gl.glVertex2f(p2.X, p2.Y);
     Gl.glEnd();
 }

 public override void MouseMove(Vec2 p)
 {
     if (_moving)
     {
         newPos = p;
     }
     base.MouseMove(p);
 }

 /// Initialize the bodies, anchors, and reference angle using a world
 /// anchor point.
 public void Initialize(Body body1, Body body2, Vec2 anchor)
 {
     BodyA = body1;
     BodyB = body2;
     _localAnchorA = BodyA.GetLocalPoint(anchor);
     _localAnchorB = BodyB.GetLocalPoint(anchor);
     _referenceAngle = BodyB.Angle - BodyA.Angle;
 }

 public void DrawPoint(Vec2 p, float size, ColorF color)
 {
     Gl.glPointSize(size);
     Gl.glBegin(Gl.GL_POINTS);
     Gl.glColor3f(color.R, color.G, color.B);
     Gl.glVertex2f(p.X, p.Y);
     Gl.glEnd();
     Gl.glPointSize(1.0f);
 }

 public DistanceJointDef()
 {
     JointType = JointType.Distance;
     _localAnchorA = Vec2.Empty;
     _localAnchorB = Vec2.Empty;
     _length = 1.0f;
     _frequencyHz = 0.0f;
     _dampingRatio = 0.0f;
 }

 /// Does this aabb contain the provided AABB.
 public bool Contains(Vec2 pt)
 {
     bool result = true;
     result = result && LowerBound.X <= pt.X;
     result = result && LowerBound.Y <= pt.Y;
     result = result && pt.X <= UpperBound.X;
     result = result && pt.Y <= UpperBound.Y;
     return result;
 }

 public override void DrawPolygon(Vec2[] vertices, int vertexCount, ColorF color)
 {
     Gl.glColor3f(color.R, color.G, color.B);
     Gl.glBegin(Gl.GL_LINE_LOOP);
     for (int i = 0; i < vertexCount; ++i)
     {
         Gl.glVertex2f(vertices[i].X, vertices[i].Y);
     }
     Gl.glEnd();
 }

 public void DrawArc(Vec2 pos, float radius, float startAngle, float endAngle)
 {
     Gl.glPushMatrix();
     Gl.glTranslatef(pos.X, pos.Y, 0);
     var xx = Glu.gluNewQuadric();
     Glu.gluQuadricDrawStyle(xx, Glu.GLU_SILHOUETTE);
     Glu.gluPartialDisk(xx, radius, radius, 24, 1, b2Math.Rad2Deg(startAngle), b2Math.Rad2Deg(endAngle - startAngle));
     Glu.gluDeleteQuadric(xx);
     Gl.glPopMatrix();
 }

 public PulleyJointDef()
 {
     JointType = JointType.Pulley;
     _groundAnchorA = new Vec2(-1.0f, 1.0f);
     _groundAnchorB = new Vec2(1.0f, 1.0f);
     _localAnchorA = new Vec2(-1.0f, 0.0f);
     _localAnchorB = new Vec2(1.0f, 0.0f);
     _lengthA = 0.0f;
     _maxLengthA = 0.0f;
     _lengthB = 0.0f;
     _maxLengthB = 0.0f;
     _ratio = 1.0f;
     CollideConnected = true;
 }

 public override void DrawCircle(Vec2 center, float radius, ColorF color)
 {
     float k_segments = (int)(1024.0f * (radius / 50));
     float k_increment = (float)(2.0f * Math.PI / k_segments);
     float theta = 0.0f;
     Gl.glColor3f(color.R, color.G, color.B);
     Gl.glBegin(Gl.GL_LINE_LOOP);
     for (int i = 0; i < k_segments; ++i)
     {
         Vec2 v = center + radius * new Vec2((float)Math.Cos(theta), (float)Math.Sin(theta));
         Gl.glVertex2f(v.X, v.Y);
         theta += k_increment;
     }
     Gl.glEnd();
 }

        public Prismatic()
        {
            Body ground = null;
            {
                BodyDef bd = new BodyDef();
                ground = m_world.CreateBody(bd);

                PolygonShape shape = new PolygonShape();
                shape.SetAsEdge(new Vec2(-40.0f, 0.0f), new Vec2(40.0f, 0.0f));
                ground.CreateFixture(shape, 0.0f);
            }

            {
                PolygonShape shape = new PolygonShape();
                shape.SetAsBox(2.0f, 0.5f);

                BodyDef bd = new BodyDef();
                bd.BodyType = BodyType.Dynamic;
                bd.Position = new Vec2(-10.0f, 10.0f);
                bd.Angle = 0.5f * (float)Math.PI;
                bd.AllowSleep = false;
                Body body = m_world.CreateBody(bd);
                body.CreateFixture(shape, 5.0f);

                PrismaticJointDef pjd = new PrismaticJointDef();

                // Bouncy limit
                Vec2 axis = new Vec2(2.0f, 1.0f);
                axis.Normalize();
                pjd.Initialize(ground, body, new Vec2(0.0f, 0.0f), axis);

                // Non-bouncy limit
                //pjd.Initialize(ground, body, new Vec2(-10.0f, 10.0f), new Vec2(1.0f, 0.0f));

                pjd.MotorSpeed = 10.0f;
                pjd.MaxMotorForce = 10000.0f;
                pjd.EnableMotor = true;
                pjd.LowerTranslation = 0.0f;
                pjd.UpperTranslation = 20.0f;
                pjd.EnableLimit = false;

                m_joint = (PrismaticJoint)m_world.CreateJoint(pjd);
            }
        }

        /// Main...
        public ElasticBody()
        {
            Program.MainForm.ViewZoom = 0.25f;

            /// Bottom static body
            {
                PolygonShape sd = new PolygonShape();
                sd.SetAsBox(50.0f, 2.0f);
                BodyDef bd = new BodyDef();
                bd.Position = new Vec2(-1.0f, -7.5f);

                m_ground = m_world.CreateBody(bd);
                m_ground.CreateFixture(new FixtureDef(sd, 0.0f, 0.1f, 0.1f));
            }

            /// "Elastic body" 64 bodies - something like a lin. elastic compound
            /// connected via dynamic forces (springs)
            {
                PolygonShape sd = new PolygonShape();
                sd.SetAsBox(width, height);

                FixtureDef sdf = new FixtureDef();
                sdf.Density    = 1.5f;
                sdf.Friction   = 0.01f;
                sdf.Filter.GroupIndex = -1;
                sdf.Shape = sd;
                Vec2 startpoint = new Vec2(0, 0);
                BodyDef    bd = new BodyDef();
                bd.BodyType = BodyType.Dynamic;
                bd.Bullet = false;
              	 			//bd.AllowSleep = false;
                for (int i = 0; i < BodyCountY; ++i)
                {
                    for (int j = 0; j < BodyCountX; ++j)
                    {
                        bd.Position = new Vec2(j*(width*2), 2.51f + (height*2) * i);
                        bd.Position  += startpoint;
                        Body body  = m_world.CreateBody(bd);
                        bodies[BodyCountX*i+j] = body;
                        body.CreateFixture(sdf);
                    }
                }
            }
        }

        public void Apply()
        {
            if (!string.IsNullOrEmpty(toolStripStatusLabel1.Text))
            {
                MessageBox.Show("You have errors in your polygon. Please fix these before applying:\n\n"+toolStripStatusLabel1.ToolTipText, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            Vec2[] vertices = new Vec2[PolyData.Vertices.Count];

            for (int i = 0; i < PolyData.Vertices.Count; ++i)
            {
                vertices[i] = (new Vec2((PolyData.Vertices[i].X - (pictureBox1.Width / 2)) / pictureBox1.Width, (PolyData.Vertices[i].Y - (pictureBox1.Height / 2)) / pictureBox1.Height)) * (float)PolyData.Scale;
            }

            SelectedShape.Vertices = vertices;

            if ((Program.MainForm.SelectedNode.Node.Parent as FixtureNode).OwnedBody != null &&
                (Program.MainForm.SelectedNode.Node.Parent as FixtureNode).OwnedBody.AutoMassRecalculate)
                (Program.MainForm.SelectedNode.Node.Parent as FixtureNode).OwnedBody.RecalculateMass();
        }

        public Body[] GenerateBodies(World world, Vec2 basePosition, FixtureDef def)
        {
            if (_vecs.Count <= 1)
                throw new ArgumentOutOfRangeException("Vecs");

            Body[] bodies = new Body[_vecs.Count - 1];

            for (int i = 0; i < _vecs.Count - 1; ++i)
            {
                PolygonShape edge = new PolygonShape(_vecs[i], _vecs[i + 1]);

                BodyDef bd = new BodyDef();
                bd.Position = basePosition;

                bodies[i] = world.CreateBody(bd);
                bodies[i].CreateFixture(new FixtureDef(edge, 0, def.Restitution, def.Friction, false, def.UserData));
            }

            return bodies;
        }

        void CreateCircle()
        {
            float radius = 2.0f;
            CircleShape shape = new CircleShape();
            shape.Position = Vec2.Empty;
            shape.Radius = radius;

            FixtureDef fd = new FixtureDef();
            fd.Shape = shape;
            fd.Density = 1.0f;
            fd.Friction = 0.0f;

            Vec2 p = new Vec2(Rand.RandomFloat(), 3.0f + Rand.RandomFloat());
            BodyDef bd = new BodyDef();
            bd.BodyType = BodyType.Dynamic;
            bd.Position = p;
            //bd.allowSleep = false;
            Body body = m_world.CreateBody(bd);

            body.CreateFixture(fd);
        }