private static DebugColor SpaceDebugDrawColorForShapeCallback(cpShape handleShape, voidptr_t data)
        {
            IDebugDraw debugDraw = NativeInterop.FromIntPtr <IDebugDraw>(data);
            var        shape     = Shape.FromHandle(handleShape);

            return(debugDraw.ColorForShape(shape));
        }
        private static void SpaceDebugDrawPolygonCallback(int count, cpVertPointer verts, double radius, DebugColor outlineColor, DebugColor fillColor, voidptr_t data)
        {
            IDebugDraw debugDraw = NativeInterop.FromIntPtr <IDebugDraw>(data);

            Vect[] vectors = NativeInterop.PtrToStructureArray <Vect>(verts, count);

            debugDraw.DrawPolygon(vectors, radius, outlineColor, fillColor);
        }
Esempio n. 3
0
        /// <summary>
        /// Calculate the moment of inertia for a solid polygon shape assuming its center of gravity
        /// is at its centroid. The offset is added to each vertex.
        /// </summary>
        public static double MomentForPolygon(double mass, IReadOnlyList <Vect> vertices, Vect offset, double radius)
        {
            IntPtr verticesPtr = NativeInterop.StructureArrayToPtr(vertices);
            double moment      = NativeMethods.cpMomentForPoly(mass, vertices.Count, verticesPtr, offset, radius);

            NativeInterop.FreeStructure(verticesPtr);

            return(moment);
        }
Esempio n. 4
0
        /// <summary>
        /// Calculate the natural centroid of a polygon.
        /// </summary>
        public static Vect CentroidForPoly(IReadOnlyList <Vect> vertices)
        {
            IntPtr verticesPtr = NativeInterop.StructureArrayToPtr(vertices);

            Vect centroid = NativeMethods.cpCentroidForPoly(vertices.Count, verticesPtr);

            NativeInterop.FreeStructure(verticesPtr);

            return(centroid);
        }
Esempio n. 5
0
        /// <summary>
        /// Calculate the signed area of this polygon. Vertices specified such that they connect in
        ///  a clockwise fashion (called winding) give a positive area measurement. This is probably
        ///  backwards to what you might expect.
        /// </summary>
        public static double AreaForPoly(IReadOnlyList <Vect> vertices, double radius)
        {
            IntPtr verticesPtr = NativeInterop.StructureArrayToPtr(vertices);

            double area = NativeMethods.cpAreaForPoly(vertices.Count, verticesPtr, radius);

            NativeInterop.FreeStructure(verticesPtr);

            return(area);
        }
        private IntPtr ToPointer()
        {
            IntPtr drawOptionsPtr = NativeInterop.AllocStructure <cpSpaceDebugDrawOptions>();

#if NETFRAMEWORK
            Marshal.StructureToPtr(this, drawOptionsPtr, false);
#else
            Marshal.StructureToPtr <cpSpaceDebugDrawOptions>(this, drawOptionsPtr, false);
#endif
            return(drawOptionsPtr);
        }
Esempio n. 7
0
        private static IntPtr CreatePolygonShape(Body body, Vect[] verts, double radius)
        {
            Debug.Assert(verts.Length > 2);

            IntPtr ptrVectors = NativeInterop.StructureArrayToPtr(verts);

            IntPtr handle = NativeMethods.cpPolyShapeNewRaw(body.Handle, verts.Length, ptrVectors, radius);

            NativeInterop.FreeStructure(ptrVectors);

            return(handle);
        }
Esempio n. 8
0
        private static IntPtr CreatePolygonShape(Body body, IReadOnlyList <Vect> verts, Transform transform, double radius)
        {
            Debug.Assert(verts.Count > 2);

            IntPtr ptrVectors = NativeInterop.StructureArrayToPtr(verts);

            IntPtr handle = NativeMethods.cpPolyShapeNew(body.Handle, verts.Count, ptrVectors, transform, radius);

            NativeInterop.FreeStructure(ptrVectors);

            return(handle);
        }
        private CollisionHandler(cpCollisionHandlerPointer collisionHandle, ref cpCollisionHandler handler)
        {
            handle = collisionHandle;

            IntPtr data = NativeInterop.RegisterHandle(this);

            handler.userData = data;

            TypeA = (int)handler.typeA;
            TypeB = (int)handler.typeB;

            cpCollisionHandler.ToPointer(handler, handle);
        }
        internal static CollisionHandler <T> GetOrCreate(cpCollisionHandlerPointer collisionHandle)
        {
            Debug.Assert(collisionHandle != IntPtr.Zero, "CollisionHandle cannot be zero");

            var handler = cpCollisionHandler.FromHandle(collisionHandle);

            if (handler.userData != IntPtr.Zero)
            {
                return(NativeInterop.FromIntPtr <CollisionHandler <T> >(handler.userData));
            }

            return(new CollisionHandler <T>(collisionHandle, ref handler));
        }
        public IntPtr AcquireDebugDrawOptions(IDebugDraw debugDraw, DebugDrawFlags flags, DebugDrawColors colors)
        {
            this.flags          = (int)flags;
            collisionPointColor = colors.CollisionPoint;
            constraintColor     = colors.Constraint;
            shapeOutlineColor   = colors.ShapeOutline;

            drawCircle     = spaceDebugDrawCircleCallback.ToFunctionPointer();
            drawSegment    = spaceDebugDrawSegmentCallback.ToFunctionPointer();
            drawFatSegment = spaceDebugDrawFatSegmentCallback.ToFunctionPointer();
            drawPolygon    = spaceDebugDrawPolygonCallback.ToFunctionPointer();
            drawDot        = spaceDebugDrawDotCallback.ToFunctionPointer();
            colorForShape  = spaceDebugDrawColorForShapeCallback.ToFunctionPointer();

            data = NativeInterop.RegisterHandle(debugDraw);

            return(ToPointer());
        }
Esempio n. 12
0
        /// <summary>
        /// Get a Constraint object from a native handle.
        /// </summary>
        public static Constraint FromHandle(cpConstraint constraint)
        {
            cpDataPointer handle = NativeMethods.cpConstraintGetUserData(constraint);

            return(NativeInterop.FromIntPtr <Constraint>(handle));
        }
Esempio n. 13
0
        void ReleaseUserData()
        {
            cpDataPointer pointer = NativeMethods.cpConstraintGetUserData(constraint);

            NativeInterop.ReleaseHandle(pointer);
        }
Esempio n. 14
0
        void RegisterUserData()
        {
            cpDataPointer pointer = NativeInterop.RegisterHandle(this);

            NativeMethods.cpSpaceSetUserData(space, pointer);
        }
Esempio n. 15
0
        void ReleaseUserData()
        {
            cpDataPointer pointer = NativeMethods.cpBodyGetUserData(body);

            NativeInterop.ReleaseHandle(pointer);
        }
        private static void SpaceDebugDrawFatSegmentCallback(Vect a, Vect b, double radius, DebugColor outlineColor, DebugColor fillColor, voidptr_t data)
        {
            IDebugDraw debugDraw = NativeInterop.FromIntPtr <IDebugDraw>(data);

            debugDraw.DrawFatSegment(a, b, radius, outlineColor, fillColor);
        }
Esempio n. 17
0
        /// <summary>
        /// Get a <see cref="Body"/> object from a native cpBody handle.
        /// </summary>
        public static Body FromHandle(cpBody body)
        {
            cpDataPointer handle = NativeMethods.cpBodyGetUserData(body);

            return(NativeInterop.FromIntPtr <Body>(handle));
        }
        private static void SpaceDebugDrawSegmentCallback(Vect a, Vect b, DebugColor color, voidptr_t data)
        {
            IDebugDraw debugDraw = NativeInterop.FromIntPtr <IDebugDraw>(data);

            debugDraw.DrawSegment(a, b, color);
        }
        private static void SpaceDebugDrawDotCallback(double size, Vect pos, DebugColor color, voidptr_t data)
        {
            IDebugDraw debugDraw = NativeInterop.FromIntPtr <IDebugDraw>(data);

            debugDraw.DrawDot(size, pos, color);
        }
Esempio n. 20
0
        /// <summary>
        /// Register managed object in the native user data.
        /// </summary>
        protected void RegisterUserData()
        {
            cpDataPointer pointer = NativeInterop.RegisterHandle(this);

            NativeMethods.cpShapeSetUserData(shape, pointer);
        }
Esempio n. 21
0
        void RegisterUserData()
        {
            cpDataPointer pointer = NativeInterop.RegisterHandle(this);

            NativeMethods.cpBodySetUserData(body, pointer);
        }
Esempio n. 22
0
        void ReleaseUserData()
        {
            cpDataPointer pointer = NativeMethods.cpShapeGetUserData(shape);

            NativeInterop.ReleaseHandle(pointer);
        }
Esempio n. 23
0
        /// <summary>
        /// Get a managed Shape from a native handle.
        /// </summary>
        public static Shape FromHandle(cpShape shape)
        {
            cpDataPointer handle = NativeMethods.cpShapeGetUserData(shape);

            return(NativeInterop.FromIntPtr <Shape>(handle));
        }
 public void ReleaseDebugDrawOptions(IntPtr debugDrawOptionsPointer)
 {
     NativeInterop.ReleaseHandle(data);
     NativeInterop.FreeStructure(debugDrawOptionsPointer);
 }
Esempio n. 25
0
        /// <summary>
        /// Register managed object to native user data.
        /// </summary>
        internal protected void RegisterUserData()
        {
            cpDataPointer pointer = NativeInterop.RegisterHandle(this);

            NativeMethods.cpConstraintSetUserData(constraint, pointer);
        }
        private static void SpaceDebugDrawCircleCallback(Vect pos, double angle, double radius, DebugColor outlineColor, DebugColor fillColor, voidptr_t data)
        {
            IDebugDraw debugDraw = NativeInterop.FromIntPtr <IDebugDraw>(data);

            debugDraw.DrawCircle(pos, angle, radius, outlineColor, fillColor);
        }
Esempio n. 27
0
        /// <summary>
        /// Get a Space object from native cpSpace handle.
        /// </summary>
        public static Space FromHandle(cpSpace space)
        {
            cpDataPointer handle = NativeMethods.cpSpaceGetUserData(space);

            return(NativeInterop.FromIntPtr <Space>(handle));
        }