public cpPivotJoint(cpBody a, cpBody b, cpVect anchorA, cpVect anchorB)
     : base(a, b)
 {
     this.anchorA = anchorA;
     this.anchorB = anchorB;
     this.jAcc = cpVect.Zero;
 }

 public cpShapeMassInfo(float m, float i, cpVect cog, float area)
 {
     this.m = m;
     this.i = i;
     this.cog = cog;
     this.area = area;
 }

 public PointQueryContext(cpVect point1, float maxDistance1, cpShapeFilter filter1, Action<cpShape, cpVect, float, cpVect, object> func1)
 {
     // TODO: Complete member initialization
     this.point = point1;
     this.maxDistance = maxDistance1;
     this.filter = filter1;
     this.func = func1;
 }

 public static cpTransform BoneScale(cpVect v0, cpVect v1)
 {
     cpVect d = cpVect.cpvsub(v1, v0);
     return NewTranspose(
       d.x, -d.y, v0.x,
       d.y, d.x, v0.y
     );
 }

		public CCRayCastCallbackInfo(CCPhysicsWorld world, Func<CCPhysicsWorld, CCPhysicsRayCastInfo, object, bool> func, cpVect p1, cpVect p2, object data)
		{
			this.world = world;
			this.func = func;
			this.p1 = p1;
			this.p2 = p2;
			this.data = data;

		}

 public static cpShapeMassInfo cpCircleShapeMassInfo(float mass, float radius, cpVect center)
 {
     var info = new cpShapeMassInfo(
             mass, cp.MomentForCircle(1.0f, 0.0f, radius, cpVect.Zero),
     center,
     cp.AreaForCircle(0.0f, radius)
         );
     return info;
 }

 public cpPointQueryExtendedInfo(cpShape tShape)
 {
     /// The nearest shape, NULL if no shape was within range.
     this.shape = tShape;
     /// The closest point on the shape's surface. (in world space coordinates)
     this.d = cp.Infinity;
     /// The distance to the point. The distance is negative if the point is inside the shape.
     this.n = cpVect.Zero;
 }

        public cpSlideJoint(cpBody a, cpBody b, cpVect anchorA, cpVect anchorB, float min, float max)
            : base(a, b)
        {
            this.anchorA = anchorA;
            this.anchorB = anchorB;
            this.min = min;
            this.max = max;

            this.jnAcc = 0.0f;
        }

        public static cpTransform AxialScale(cpVect axis, cpVect pivot, float scale)
        {
            float A = axis.x * axis.y * (scale - 1.0f);
            float B = cpVect.cpvdot(axis, pivot) * (1.0f - scale);

            return NewTranspose(
              scale * axis.x * axis.x + axis.y * axis.y, A, axis.x * B,
              A, axis.x * axis.x + scale * axis.y * axis.y, axis.y * B
            );
        }

        public cpSegmentQueryInfo(cpShape shape, cpVect point, cpVect normal, float alpha)
        {
            /// The shape that was hit, NULL if no collision occured.
            this.shape = shape;
            /// The normalized distance along the query segment in the range [0, 1].
            this.alpha = alpha;
            /// The normal of the surface hit.
            this.normal = normal;

            this.point = point;
        }

        public cpPointQueryInfo(cpShape shape, cpVect point, float distance, cpVect gradient)
        {
            /// The nearest shape, NULL if no shape was within range.
            this.shape = shape;
            /// The closest point on the shape's surface. (in world space coordinates)
            this.point = point;
            /// The distance to the point. The distance is negative if the point is inside the shape.
            this.distance = distance;

            this.gradient = gradient;
        }

        public static cpShapeMassInfo cpPolyShapeMassInfo(float mass, int count, cpVect[] verts, float radius)
        {
            cpVect centroid = cp.CentroidForPoly(count, verts);

            var info = new cpShapeMassInfo(
                mass,
                cp.MomentForPoly(1.0f, count, verts, cpVect.cpvneg(centroid), radius),
                centroid,
                cp.AreaForCircle(0.0f, radius)
            );
            return info;
        }

        public b2dJsonImage()
        {
            Body = null;
            Center = cpVect.Zero;

            Angle = 0; Scale = 1;
            Flip = false;

            Filter = _b2dJsonImagefilterType.FT_LINEAR;

            ColorTint = new int[4];
            m_corners = new cpVect[4];
        }

        public cpPolyShape ToShape(cpBody body, float radius, cpVect size, int shapeIdx = 0)
        {
            var source = Shapes[shapeIdx];
            var vertices = new cpVect[source.Length];

            for (int i = 0, count = source.Length; i < count; i++)
            {
                var sourceVect = source[i];
                var vect = cpVect.cpv(sourceVect.x * size.x, sourceVect.y * size.y);
                vertices[i] = vect;
            }

            return new cpPolyShape(body, vertices.Length, vertices, radius);
        }

        public cpPolyShape(cpBody body, int count, cpVect[] verts,
			cpTransform transform, float radius)
            : base(body, new cpShapeMassInfo())
        {
            cpVect[] hullVerts = new cpVect[count];

            // Transform the verts before building the hull in case of a negative scale.
            for (int i = 0; i < count; i++)
                hullVerts[i] = cpTransform.Point(transform, verts[i]);

            int hullCount = cp.ConvexHull(count, hullVerts, ref hullVerts, null, 0.0f);

            InitRaw(hullCount, hullVerts, radius);
        }

        internal static cpVect[] CCPointsTocpVects (CCPoint[] points)
        {
            var len = points.Length;
            cpVect[] pointscp = new cpVect[len];
            var wrkPoint = CCPoint.Zero;

            for (int i = 0; i< len; i++)
            {
                wrkPoint = points[i];
                pointscp[i] = new cpVect(wrkPoint.X, wrkPoint.Y);

            }
            return pointscp;
        }

		static CCPoint[] cpVertArray2ccpArrayN(cpVect[] cpVertArray, int count)
		{
			if (count == 0)
				return null;

			CCPoint[] pPoints = new CCPoint[count];

			for (int i = 0; i < count; ++i)
			{
				pPoints[i].X = cpVertArray[i].x;
				pPoints[i].Y = cpVertArray[i].y;
			}
			return pPoints;
		}

        internal static CCPoint[] cpVectsTpCCPoints (cpVect[] points)
        {
            var len = points.Length;
            var pointscp = new CCPoint[len];
            var wrkPoint = cpVect.Zero;

            for (int i = 0; i< len; i++)
            {
                wrkPoint = points[i];
                pointscp[i] = new CCPoint(wrkPoint.x, wrkPoint.y);

            }
            return pointscp;
        }

        public cpGrooveJoint(cpBody a, cpBody b, cpVect groove_a, cpVect groove_b, cpVect anchorB)
            : base(a, b)
        {
            this.grv_a = groove_a;
            this.grv_b = groove_b;
            this.grv_n = cpVect.cpvperp(cpVect.cpvnormalize(cpVect.cpvsub(groove_b, groove_a)));
            this.anchorB = anchorB;

            this.grv_tn = null;
            this.clamp = 0.0f;
            this.r1 = this.r2 = null;

            this.jAcc = cpVect.Zero;
            this.bias = null;
        }

		public CCPhysicsRayCastInfo(CCPhysicsShape shape,
								  cpVect start,
								  cpVect end,
								  cpVect contact,
								  cpVect normal,
								  float fraction,
								  object data)
		{
			this.shape = shape;
			this.start = start;
			this.end = end;          //< in lua, it's name is "ended"
			this.contact = contact;
			this.normal = normal;
			this.fraction = fraction;
			this.data = data;
		}