chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/chipmunk_ffi.h

@@ -1,3 +1,5 @@
+#ifdef CHIPMUNK_FFI
+
 // Create non static inlined copies of Chipmunk functions, useful for working with dynamic FFIs
 // This file should only be included in chipmunk.c
 
@@ -11,6 +13,9 @@
  #define MAKE_REF(name) __typeof__(name) *_##name = name
 #endif
 
+#define MAKE_PROPERTIES_REF(struct, property) \
+	MAKE_REF(struct##Get##property); MAKE_REF(struct##Set##property)
+
 MAKE_REF(cpv); // makes a variable named _cpv that contains the function pointer for cpv()
 MAKE_REF(cpveql);
 MAKE_REF(cpvadd);
@@ -22,9 +27,12 @@ MAKE_REF(cpvcross);
 MAKE_REF(cpvperp);
 MAKE_REF(cpvrperp);
 MAKE_REF(cpvproject);
+MAKE_REF(cpvforangle);
+MAKE_REF(cpvtoangle);
 MAKE_REF(cpvrotate);
 MAKE_REF(cpvunrotate);
 MAKE_REF(cpvlengthsq);
+MAKE_REF(cpvlength);
 MAKE_REF(cpvlerp);
 MAKE_REF(cpvnormalize);
 MAKE_REF(cpvnormalize_safe);
@@ -34,26 +42,136 @@ MAKE_REF(cpvdist);
 MAKE_REF(cpvdistsq);
 MAKE_REF(cpvnear);
 
+MAKE_REF(cpfmax);
+MAKE_REF(cpfmin);
+MAKE_REF(cpfabs);
+MAKE_REF(cpfclamp);
+MAKE_REF(cpflerp);
+MAKE_REF(cpflerpconst);
+
 MAKE_REF(cpBBNew);
-MAKE_REF(cpBBintersects);
-MAKE_REF(cpBBcontainsBB);
-MAKE_REF(cpBBcontainsVect);
-MAKE_REF(cpBBmerge);
-MAKE_REF(cpBBexpand);
+MAKE_REF(cpBBNewForCircle);
+MAKE_REF(cpBBIntersects);
+MAKE_REF(cpBBContainsBB);
+MAKE_REF(cpBBContainsVect);
+MAKE_REF(cpBBMerge);
+MAKE_REF(cpBBExpand);
+MAKE_REF(cpBBArea);
+MAKE_REF(cpBBMergedArea);
+MAKE_REF(cpBBSegmentQuery);
+MAKE_REF(cpBBIntersectsSegment);
+MAKE_REF(cpBBClampVect);
 
-MAKE_REF(cpBodyWorld2Local);
-MAKE_REF(cpBodyLocal2World);
-MAKE_REF(cpBodyApplyImpulse);
+MAKE_REF(cpBodyGetMass);
+MAKE_REF(cpBodyGetMoment);
+MAKE_REF(cpBodyGetPos);
+MAKE_REF(cpBodyGetAngle);
+MAKE_REF(cpBodyGetRot);
+MAKE_PROPERTIES_REF(cpBody, Vel);
+MAKE_PROPERTIES_REF(cpBody, Force);
+MAKE_PROPERTIES_REF(cpBody, AngVel);
+MAKE_PROPERTIES_REF(cpBody, Torque);
+MAKE_PROPERTIES_REF(cpBody, VelLimit);
+MAKE_PROPERTIES_REF(cpBody, AngVelLimit);
+MAKE_PROPERTIES_REF(cpBody, UserData);
 MAKE_REF(cpBodyIsSleeping);
+MAKE_REF(cpBodyIsStatic);
 MAKE_REF(cpBodyIsRogue);
+MAKE_REF(cpBodyLocal2World);
+MAKE_REF(cpBodyWorld2Local);
 MAKE_REF(cpBodyKineticEnergy);
 
-MAKE_REF(cpArbiterIsFirstContact);
+MAKE_REF(cpShapeGetBB);
+MAKE_PROPERTIES_REF(cpShape, Body);
+MAKE_PROPERTIES_REF(cpShape, Sensor);
+MAKE_PROPERTIES_REF(cpShape, Elasticity);
+MAKE_PROPERTIES_REF(cpShape, Friction);
+MAKE_PROPERTIES_REF(cpShape, SurfaceVelocity);
+MAKE_PROPERTIES_REF(cpShape, UserData);
+MAKE_PROPERTIES_REF(cpShape, CollisionType);
+MAKE_PROPERTIES_REF(cpShape, Group);
+MAKE_PROPERTIES_REF(cpShape, Layers);
+
 MAKE_REF(cpArbiterGetShapes);
-MAKE_REF(cpArbiterGetNormal);
-MAKE_REF(cpArbiterGetPoint);
+MAKE_REF(cpArbiterGetBodies);
+MAKE_REF(cpArbiterIsFirstContact);
+MAKE_REF(cpArbiterGetCount);
 
+MAKE_REF(cpConstraintGetA);
+MAKE_REF(cpConstraintGetB);
+MAKE_PROPERTIES_REF(cpConstraint, MaxForce);
+MAKE_PROPERTIES_REF(cpConstraint, ErrorBias);
+MAKE_PROPERTIES_REF(cpConstraint, MaxBias);
+MAKE_PROPERTIES_REF(cpConstraint, UserData);
 MAKE_REF(cpConstraintGetImpulse);
 
+MAKE_PROPERTIES_REF(cpDampedRotarySpring, RestAngle);
+MAKE_PROPERTIES_REF(cpDampedRotarySpring, Stiffness);
+MAKE_PROPERTIES_REF(cpDampedRotarySpring, Damping);
+//MAKE_PROPERTIES_REF(cpDampedRotarySpring, SpringTorqueFunc);
+
+MAKE_PROPERTIES_REF(cpDampedSpring, Anchr1);
+MAKE_PROPERTIES_REF(cpDampedSpring, Anchr2);
+MAKE_PROPERTIES_REF(cpDampedSpring, RestLength);
+MAKE_PROPERTIES_REF(cpDampedSpring, Stiffness);
+MAKE_PROPERTIES_REF(cpDampedSpring, Damping);
+//MAKE_PROPERTIES_REF(cpDampedSpring, SpringForceFunc);
+
+MAKE_PROPERTIES_REF(cpGearJoint, Phase);
+MAKE_REF(cpGearJointGetRatio);
+
+MAKE_PROPERTIES_REF(cpGrooveJoint, Anchr2);
+MAKE_REF(cpGrooveJointGetGrooveA);
+MAKE_REF(cpGrooveJointGetGrooveB);
+
+MAKE_PROPERTIES_REF(cpPinJoint, Anchr1);
+MAKE_PROPERTIES_REF(cpPinJoint, Anchr2);
+MAKE_PROPERTIES_REF(cpPinJoint, Dist);
+
+MAKE_PROPERTIES_REF(cpPivotJoint, Anchr1);
+MAKE_PROPERTIES_REF(cpPivotJoint, Anchr2);
+
+MAKE_PROPERTIES_REF(cpRatchetJoint, Angle);
+MAKE_PROPERTIES_REF(cpRatchetJoint, Phase);
+MAKE_PROPERTIES_REF(cpRatchetJoint, Ratchet);
+
+MAKE_PROPERTIES_REF(cpRotaryLimitJoint, Min);
+MAKE_PROPERTIES_REF(cpRotaryLimitJoint, Max);
+
+MAKE_PROPERTIES_REF(cpSimpleMotor, Rate);
+
+MAKE_PROPERTIES_REF(cpSlideJoint, Anchr1);
+MAKE_PROPERTIES_REF(cpSlideJoint, Anchr2);
+MAKE_PROPERTIES_REF(cpSlideJoint, Min);
+MAKE_PROPERTIES_REF(cpSlideJoint, Max);
+
 MAKE_REF(cpSegmentQueryHitPoint);
 MAKE_REF(cpSegmentQueryHitDist);
+
+MAKE_REF(cpSpatialIndexDestroy);
+MAKE_REF(cpSpatialIndexCount);
+MAKE_REF(cpSpatialIndexEach);
+MAKE_REF(cpSpatialIndexContains);
+MAKE_REF(cpSpatialIndexInsert);
+MAKE_REF(cpSpatialIndexRemove);
+MAKE_REF(cpSpatialIndexReindex);
+MAKE_REF(cpSpatialIndexReindexObject);
+MAKE_REF(cpSpatialIndexSegmentQuery);
+MAKE_REF(cpSpatialIndexQuery);
+MAKE_REF(cpSpatialIndexReindexQuery);
+
+MAKE_PROPERTIES_REF(cpSpace, Iterations);
+MAKE_PROPERTIES_REF(cpSpace, Gravity);
+MAKE_PROPERTIES_REF(cpSpace, Damping);
+MAKE_PROPERTIES_REF(cpSpace, IdleSpeedThreshold);
+MAKE_PROPERTIES_REF(cpSpace, SleepTimeThreshold);
+MAKE_PROPERTIES_REF(cpSpace, CollisionSlop);
+MAKE_PROPERTIES_REF(cpSpace, CollisionBias);
+MAKE_PROPERTIES_REF(cpSpace, CollisionPersistence);
+MAKE_PROPERTIES_REF(cpSpace, EnableContactGraph);
+MAKE_PROPERTIES_REF(cpSpace, UserData);
+MAKE_REF(cpSpaceGetStaticBody);
+MAKE_REF(cpSpaceGetCurrentTimeStep);
+MAKE_REF(cpSpaceIsLocked);
+
+#endif

data/ext/chipmunk/chipmunk_private.h

@@ -22,28 +22,244 @@
 #define CP_ALLOW_PRIVATE_ACCESS 1
 #include "chipmunk.h"
 
-void *cpSpaceGetPostStepData(cpSpace *space, void *obj);
+#define CP_HASH_COEF (3344921057ul)
+#define CP_HASH_PAIR(A, B) ((cpHashValue)(A)*CP_HASH_COEF ^ (cpHashValue)(B)*CP_HASH_COEF)
+
+//MARK: cpArray
+
+struct cpArray {
+	int num, max;
+	void **arr;
+};
+
+cpArray *cpArrayNew(int size);
+
+void cpArrayFree(cpArray *arr);
+
+void cpArrayPush(cpArray *arr, void *object);
+void *cpArrayPop(cpArray *arr);
+void cpArrayDeleteObj(cpArray *arr, void *obj);
+cpBool cpArrayContains(cpArray *arr, void *ptr);
+
+void cpArrayFreeEach(cpArray *arr, void (freeFunc)(void*));
+
+//MARK: Foreach loops
+
+static inline cpConstraint *
+cpConstraintNext(cpConstraint *node, cpBody *body)
+{
+	return (node->a == body ? node->next_a : node->next_b);
+}
+
+#define CP_BODY_FOREACH_CONSTRAINT(bdy, var)\
+	for(cpConstraint *var = bdy->constraintList; var; var = cpConstraintNext(var, bdy))
+
+static inline cpArbiter *
+cpArbiterNext(cpArbiter *node, cpBody *body)
+{
+	return (node->body_a == body ? node->thread_a.next : node->thread_b.next);
+}
+
+#define CP_BODY_FOREACH_ARBITER(bdy, var)\
+	for(cpArbiter *var = bdy->arbiterList; var; var = cpArbiterNext(var, bdy))
+
+#define CP_BODY_FOREACH_SHAPE(body, var)\
+	for(cpShape *var = body->shapeList; var; var = var->next)
+
+#define CP_BODY_FOREACH_COMPONENT(root, var)\
+	for(cpBody *var = root; var; var = var->node.next)
+
+//MARK: cpHashSet
+
+typedef cpBool (*cpHashSetEqlFunc)(void *ptr, void *elt);
+typedef void *(*cpHashSetTransFunc)(void *ptr, void *data);
+
+cpHashSet *cpHashSetNew(int size, cpHashSetEqlFunc eqlFunc);
+void cpHashSetSetDefaultValue(cpHashSet *set, void *default_value);
+
+void cpHashSetFree(cpHashSet *set);
+
+int cpHashSetCount(cpHashSet *set);
+void *cpHashSetInsert(cpHashSet *set, cpHashValue hash, void *ptr, void *data, cpHashSetTransFunc trans);
+void *cpHashSetRemove(cpHashSet *set, cpHashValue hash, void *ptr);
+void *cpHashSetFind(cpHashSet *set, cpHashValue hash, void *ptr);
+
+typedef void (*cpHashSetIteratorFunc)(void *elt, void *data);
+void cpHashSetEach(cpHashSet *set, cpHashSetIteratorFunc func, void *data);
+
+typedef cpBool (*cpHashSetFilterFunc)(void *elt, void *data);
+void cpHashSetFilter(cpHashSet *set, cpHashSetFilterFunc func, void *data);
+
+//MARK: Body Functions
+
+void cpBodyAddShape(cpBody *body, cpShape *shape);
+void cpBodyRemoveShape(cpBody *body, cpShape *shape);
+void cpBodyRemoveConstraint(cpBody *body, cpConstraint *constraint);
+
+
+//MARK: Shape/Collision Functions
+
+// TODO should move this to the cpVect API. It's pretty useful.
+static inline cpVect
+cpClosetPointOnSegment(const cpVect p, const cpVect a, const cpVect b)
+{
+	cpVect delta = cpvsub(a, b);
+	cpFloat t = cpfclamp01(cpvdot(delta, cpvsub(p, b))/cpvlengthsq(delta));
+	return cpvadd(b, cpvmult(delta, t));
+}
+
+cpShape* cpShapeInit(cpShape *shape, const cpShapeClass *klass, cpBody *body);
+
+static inline cpBool
+cpShapeActive(cpShape *shape)
+{
+	return shape->prev || (shape->body && shape->body->shapeList == shape);
+}
+
+int cpCollideShapes(const cpShape *a, const cpShape *b, cpContact *arr);
+
+// TODO doesn't really need to be inline, but need a better place to put this function
+static inline cpSplittingPlane
+cpSplittingPlaneNew(cpVect a, cpVect b)
+{
+	cpVect n = cpvnormalize(cpvperp(cpvsub(b, a)));
+	cpSplittingPlane plane = {n, cpvdot(n, a)};
+	return plane;
+}
+
+static inline cpFloat
+cpSplittingPlaneCompare(cpSplittingPlane plane, cpVect v)
+{
+	return cpvdot(plane.n, v) - plane.d;
+}
+
+void cpLoopIndexes(cpVect *verts, int count, int *start, int *end);
+
+static inline cpFloat
+cpPolyShapeValueOnAxis(const cpPolyShape *poly, const cpVect n, const cpFloat d)
+{
+	cpVect *verts = poly->tVerts;
+	cpFloat min = cpvdot(n, verts[0]);
+	
+	for(int i=1; i<poly->numVerts; i++){
+		min = cpfmin(min, cpvdot(n, verts[i]));
+	}
+	
+	return min - d;
+}
+
+static inline cpBool
+cpPolyShapeContainsVert(const cpPolyShape *poly, const cpVect v)
+{
+	cpSplittingPlane *planes = poly->tPlanes;
+	
+	for(int i=0; i<poly->numVerts; i++){
+		cpFloat dist = cpSplittingPlaneCompare(planes[i], v);
+		if(dist > 0.0f) return cpFalse;
+	}
+	
+	return cpTrue;
+}
+
+static inline cpBool
+cpPolyShapeContainsVertPartial(const cpPolyShape *poly, const cpVect v, const cpVect n)
+{
+	cpSplittingPlane *planes = poly->tPlanes;
+	
+	for(int i=0; i<poly->numVerts; i++){
+		if(cpvdot(planes[i].n, n) < 0.0f) continue;
+		cpFloat dist = cpSplittingPlaneCompare(planes[i], v);
+		if(dist > 0.0f) return cpFalse;
+	}
+	
+	return cpTrue;
+}
+
+//MARK: Spatial Index Functions
+
+cpSpatialIndex *cpSpatialIndexInit(cpSpatialIndex *index, cpSpatialIndexClass *klass, cpSpatialIndexBBFunc bbfunc, cpSpatialIndex *staticIndex);
+
+//MARK: Space Functions
+
+extern cpCollisionHandler cpDefaultCollisionHandler;
+void cpSpaceProcessComponents(cpSpace *space, cpFloat dt);
+
+void cpSpacePushFreshContactBuffer(cpSpace *space);
+cpContact *cpContactBufferGetArray(cpSpace *space);
+void cpSpacePushContacts(cpSpace *space, int count);
+
+typedef struct cpPostStepCallback {
+	cpPostStepFunc func;
+	void *key;
+	void *data;
+} cpPostStepCallback;
+
+cpPostStepCallback *cpSpaceGetPostStepCallback(cpSpace *space, void *key);
+
+cpBool cpSpaceArbiterSetFilter(cpArbiter *arb, cpSpace *space);
+void cpSpaceFilterArbiters(cpSpace *space, cpBody *body, cpShape *filter);
 
 void cpSpaceActivateBody(cpSpace *space, cpBody *body);
+void cpSpaceLock(cpSpace *space);
+void cpSpaceUnlock(cpSpace *space, cpBool runPostStep);
+
+static inline cpCollisionHandler *
+cpSpaceLookupHandler(cpSpace *space, cpCollisionType a, cpCollisionType b)
+{
+	cpCollisionType types[] = {a, b};
+	return (cpCollisionHandler *)cpHashSetFind(space->collisionHandlers, CP_HASH_PAIR(a, b), types);
+}
 
 static inline void
-cpSpaceLock(cpSpace *space)
+cpSpaceUncacheArbiter(cpSpace *space, cpArbiter *arb)
 {
-	space->locked++;
+	cpShape *a = arb->a, *b = arb->b;
+	cpShape *shape_pair[] = {a, b};
+	cpHashValue arbHashID = CP_HASH_PAIR((cpHashValue)a, (cpHashValue)b);
+	cpHashSetRemove(space->cachedArbiters, arbHashID, shape_pair);
+	cpArrayDeleteObj(space->arbiters, arb);
 }
 
+void cpShapeUpdateFunc(cpShape *shape, void *unused);
+void cpSpaceCollideShapes(cpShape *a, cpShape *b, cpSpace *space);
+
+
+
+//MARK: Arbiters
+
+struct cpContact {
+	cpVect p, n;
+	cpFloat dist;
+	
+	cpVect r1, r2;
+	cpFloat nMass, tMass, bounce;
+
+	cpFloat jnAcc, jtAcc, jBias;
+	cpFloat bias;
+	
+	cpHashValue hash;
+};
+
+cpContact* cpContactInit(cpContact *con, cpVect p, cpVect n, cpFloat dist, cpHashValue hash);
+cpArbiter* cpArbiterInit(cpArbiter *arb, cpShape *a, cpShape *b);
+
 static inline void
-cpSpaceUnlock(cpSpace *space)
-{
-	space->locked--;
-	cpAssert(space->locked >= 0, "Internal error:Space lock underflow.");
-	
-	if(!space->locked){
-		cpArray *waking = space->rousedBodies;
-		for(int i=0, count=waking->num; i<count; i++){
-			cpSpaceActivateBody(space, (cpBody *)waking->arr[i]);
-		}
-		
-		waking->num = 0;
-	}
+cpArbiterCallSeparate(cpArbiter *arb, cpSpace *space)
+{
+	// The handler needs to be looked up again as the handler cached on the arbiter may have been deleted since the last step.
+	cpCollisionHandler *handler = cpSpaceLookupHandler(space, arb->a->collision_type, arb->b->collision_type);
+	handler->separate(arb, space, handler->data);
 }
+
+static inline struct cpArbiterThread *
+cpArbiterThreadForBody(cpArbiter *arb, cpBody *body)
+{
+	return (arb->body_a == body ? &arb->thread_a : &arb->thread_b);
+}
+
+void cpArbiterUnthread(cpArbiter *arb);
+
+void cpArbiterUpdate(cpArbiter *arb, cpContact *contacts, int numContacts, struct cpCollisionHandler *handler, cpShape *a, cpShape *b);
+void cpArbiterPreStep(cpArbiter *arb, cpFloat dt, cpFloat bias, cpFloat slop);
+void cpArbiterApplyCachedImpulse(cpArbiter *arb, cpFloat dt_coef);
+void cpArbiterApplyImpulse(cpArbiter *arb);

data/ext/chipmunk/chipmunk_types.h

@@ -1,16 +1,18 @@
+#include <stdint.h>
+
 #ifdef __APPLE__
-   #import "TargetConditionals.h"
+   #include "TargetConditionals.h"
 #endif
 
-#if (defined TARGET_OS_IPHONE) && (!defined CP_USE_CGPOINTS)
-	#define CP_USE_CGPOINTS
+#if (TARGET_OS_IPHONE == 1) || (TARGET_OS_MAC == 1) && (!defined CP_USE_CGPOINTS)
+	#define CP_USE_CGPOINTS 1
 #endif
 
-#ifdef CP_USE_CGPOINTS
+#if CP_USE_CGPOINTS == 1
 	#if TARGET_OS_IPHONE
 		#import <CoreGraphics/CGGeometry.h>
 	#elif TARGET_OS_MAC
-		#import <ApplicationServices/ApplicationServices.h>
+		#include <ApplicationServices/ApplicationServices.h>
 	#endif
 	
 	#if defined(__LP64__) && __LP64__
@@ -25,7 +27,13 @@
 	#define CP_USE_DOUBLES 1
 #endif
 
+/// @defgroup basicTypes Basic Types
+/// Most of these types can be configured at compile time.
+/// @{
+
 #if CP_USE_DOUBLES
+/// Chipmunk's floating point type.
+/// Can be reconfigured at compile time.
 	typedef double cpFloat;
 	#define cpfsqrt sqrt
 	#define cpfsin sin
@@ -51,53 +59,84 @@
 	#define cpfceil ceilf
 #endif
 
-static inline cpFloat
-cpfmax(cpFloat a, cpFloat b)
+#ifndef INFINITY
+	#ifdef _MSC_VER
+		union MSVC_EVIL_FLOAT_HACK
+		{
+			unsigned __int8 Bytes[4];
+			float Value;
+		};
+		static union MSVC_EVIL_FLOAT_HACK INFINITY_HACK = {{0x00, 0x00, 0x80, 0x7F}};
+		#define INFINITY (INFINITY_HACK.Value)
+	#endif
+	
+	#ifdef __GNUC__
+		#define INFINITY (__builtin_inf())
+	#endif
+	
+	#ifndef INFINITY
+		#define INFINITY (1e1000)
+	#endif
+#endif
+
+#ifndef M_PI
+	#define M_PI 3.14159265358979323846264338327950288
+#endif
+
+#ifndef M_E
+	#define M_E 2.71828182845904523536028747135266250
+#endif
+
+
+/// Return the max of two cpFloats.
+static inline cpFloat cpfmax(cpFloat a, cpFloat b)
 {
 	return (a > b) ? a : b;
 }
 
-static inline cpFloat
-cpfmin(cpFloat a, cpFloat b)
+/// Return the min of two cpFloats.
+static inline cpFloat cpfmin(cpFloat a, cpFloat b)
 {
 	return (a < b) ? a : b;
 }
 
-static inline cpFloat
-cpfabs(cpFloat n)
+/// Return the absolute value of a cpFloat.
+static inline cpFloat cpfabs(cpFloat f)
 {
-	return (n < 0) ? -n : n;
+	return (f < 0) ? -f : f;
 }
 
-static inline cpFloat
-cpfclamp(cpFloat f, cpFloat min, cpFloat max)
+/// Clamp @c f to be between @c min and @c max.
+static inline cpFloat cpfclamp(cpFloat f, cpFloat min, cpFloat max)
 {
 	return cpfmin(cpfmax(f, min), max);
 }
 
-static inline cpFloat
-cpflerp(cpFloat f1, cpFloat f2, cpFloat t)
+/// Clamp @c f to be between 0 and 1.
+static inline cpFloat cpfclamp01(cpFloat f)
+{
+	return cpfmax(0.0f, cpfmin(f, 1.0f));
+}
+
+
+
+/// Linearly interpolate (or extrapolate) between @c f1 and @c f2 by @c t percent.
+static inline cpFloat cpflerp(cpFloat f1, cpFloat f2, cpFloat t)
 {
 	return f1*(1.0f - t) + f2*t;
 }
 
-static inline cpFloat
-cpflerpconst(cpFloat f1, cpFloat f2, cpFloat d)
+/// Linearly interpolate from @c f1 to @c f2 by no more than @c d.
+static inline cpFloat cpflerpconst(cpFloat f1, cpFloat f2, cpFloat d)
 {
 	return f1 + cpfclamp(f2 - f1, -d, d);
 }
 
-// CGPoints are structurally the same, and allow
-// easy interoperability with other Cocoa libraries
-#ifdef CP_USE_CGPOINTS
-	typedef CGPoint cpVect;
-#else
-	typedef struct cpVect{cpFloat x,y;} cpVect;
-#endif
-
-typedef unsigned int cpHashValue;
+/// Hash value type.
+typedef uintptr_t cpHashValue;
 
 // Oh C, how we love to define our own boolean types to get compiler compatibility
+/// Chipmunk's boolean type.
 #ifdef CP_BOOL_TYPE
 	typedef CP_BOOL_TYPE cpBool;
 #else
@@ -105,47 +144,72 @@ typedef unsigned int cpHashValue;
 #endif
 
 #ifndef cpTrue
+/// true value.
 	#define cpTrue 1
 #endif
 
 #ifndef cpFalse
+/// false value.
 	#define cpFalse 0
 #endif
 
 #ifdef CP_DATA_POINTER_TYPE
 	typedef CP_DATA_POINTER_TYPE cpDataPointer;
 #else
+/// Type used for user data pointers.
 	typedef void * cpDataPointer;
 #endif
 
 #ifdef CP_COLLISION_TYPE_TYPE
 	typedef CP_COLLISION_TYPE_TYPE cpCollisionType;
 #else
-	typedef unsigned int cpCollisionType;
+/// Type used for cpSpace.collision_type.
+	typedef uintptr_t cpCollisionType;
 #endif
 
 #ifdef CP_GROUP_TYPE
 	typedef CP_GROUP_TYPE cpGroup;
 #else
-	typedef unsigned int cpGroup;
+/// Type used for cpShape.group.
+	typedef uintptr_t cpGroup;
 #endif
 
 #ifdef CP_LAYERS_TYPE
-	typedef CP_GROUP_TYPE cpLayers;
+	typedef CP_LAYERS_TYPE cpLayers;
 #else
+/// Type used for cpShape.layers.
 	typedef unsigned int cpLayers;
 #endif
 
 #ifdef CP_TIMESTAMP_TYPE
 	typedef CP_TIMESTAMP_TYPE cpTimestamp;
 #else
+/// Type used for various timestamps in Chipmunk.
 	typedef unsigned int cpTimestamp;
 #endif
 
 #ifndef CP_NO_GROUP
+/// Value for cpShape.group signifying that a shape is in no group.
 	#define CP_NO_GROUP ((cpGroup)0)
 #endif
 
 #ifndef CP_ALL_LAYERS
+/// Value for cpShape.layers signifying that a shape is in every layer.
 	#define CP_ALL_LAYERS (~(cpLayers)0)
 #endif
+/// @}
+
+// CGPoints are structurally the same, and allow
+// easy interoperability with other Cocoa libraries
+#if CP_USE_CGPOINTS
+	typedef CGPoint cpVect;
+#else
+/// Chipmunk's 2D vector type.
+/// @addtogroup cpVect
+	typedef struct cpVect{cpFloat x,y;} cpVect;
+#endif
+
+typedef struct cpMat2x2 {
+	// Row major [[a, b][c d]]
+	cpFloat a, b, c, d;
+} cpMat2x2;