chipmunk 4.1.0 → 5.2.0

data/ext/chipmunk/cpArray.c

@@ -32,7 +32,7 @@
 cpArray*
 cpArrayAlloc(void)
 {
-	return (cpArray *)calloc(1, sizeof(cpArray));
+	return (cpArray *)cpcalloc(1, sizeof(cpArray));
 }
 
 cpArray*
@@ -42,7 +42,7 @@ cpArrayInit(cpArray *arr, int size)
 	
 	size = (size ? size : 4);
 	arr->max = size;
-	arr->arr = (void **)malloc(size*sizeof(void**));
+	arr->arr = (void **)cpmalloc(size*sizeof(void**));
 	
 	return arr;
 }
@@ -56,15 +56,16 @@ cpArrayNew(int size)
 void
 cpArrayDestroy(cpArray *arr)
 {
-	free(arr->arr);
+	cpfree(arr->arr);
 }
 
 void
 cpArrayFree(cpArray *arr)
 {
-	if(!arr) return;
-	cpArrayDestroy(arr);
-	free(arr);
+	if(arr){
+		cpArrayDestroy(arr);
+		cpfree(arr);
+	}
 }
 
 void
@@ -72,18 +73,31 @@ cpArrayPush(cpArray *arr, void *object)
 {
 	if(arr->num == arr->max){
 		arr->max *= 2;
-		arr->arr = (void **)realloc(arr->arr, arr->max*sizeof(void**));
+		arr->arr = (void **)cprealloc(arr->arr, arr->max*sizeof(void**));
 	}
 	
 	arr->arr[arr->num] = object;
 	arr->num++;
 }
 
+void *
+cpArrayPop(cpArray *arr)
+{
+	arr->num--;
+	
+	void *value = arr->arr[arr->num];
+	arr->arr[arr->num] = NULL;
+	
+	return value;
+}
+
 void
-cpArrayDeleteIndex(cpArray *arr, int index)
+cpArrayDeleteIndex(cpArray *arr, int idx)
 {
-	int last = --arr->num;
-	arr->arr[index] = arr->arr[last];
+	arr->num--;
+	
+	arr->arr[idx] = arr->arr[arr->num];
+	arr->arr[arr->num] = NULL;
 }
 
 void

data/ext/chipmunk/cpBB.c

@@ -20,6 +20,7 @@
  */
  
 #include <math.h>
+#include <stdlib.h>
 
 #include "chipmunk.h"
 
@@ -34,12 +35,12 @@ cpBBClampVect(const cpBB bb, const cpVect v)
 cpVect
 cpBBWrapVect(const cpBB bb, const cpVect v)
 {
-	cpFloat ix = fabsf(bb.r - bb.l);
-	cpFloat modx = fmodf(v.x - bb.l, ix);
+	cpFloat ix = cpfabs(bb.r - bb.l);
+	cpFloat modx = cpfmod(v.x - bb.l, ix);
 	cpFloat x = (modx > 0.0f) ? modx : modx + ix;
 	
-	cpFloat iy = fabsf(bb.t - bb.b);
-	cpFloat mody = fmodf(v.y - bb.b, iy);
+	cpFloat iy = cpfabs(bb.t - bb.b);
+	cpFloat mody = cpfmod(v.y - bb.b, iy);
 	cpFloat y = (mody > 0.0f) ? mody : mody + iy;
 	
 	return cpv(x + bb.l, y + bb.b);

data/ext/chipmunk/cpBody.c

@@ -20,7 +20,6 @@
  */
  
 #include <stdlib.h>
-#include <math.h>
 #include <float.h>
 
 #include "chipmunk.h"
@@ -28,14 +27,17 @@
 cpBody*
 cpBodyAlloc(void)
 {
-	return (cpBody *)malloc(sizeof(cpBody));
+	return (cpBody *)cpmalloc(sizeof(cpBody));
 }
 
+cpBodyVelocityFunc cpBodyUpdateVelocityDefault = cpBodyUpdateVelocity;
+cpBodyPositionFunc cpBodyUpdatePositionDefault = cpBodyUpdatePosition;
+
 cpBody*
 cpBodyInit(cpBody *body, cpFloat m, cpFloat i)
 {
-	body->velocity_func = cpBodyUpdateVelocity;
-	body->position_func = cpBodyUpdatePosition;
+	body->velocity_func = cpBodyUpdateVelocityDefault;
+	body->position_func = cpBodyUpdatePositionDefault;
 	
 	cpBodySetMass(body, m);
 	cpBodySetMoment(body, i);
@@ -52,6 +54,8 @@ cpBodyInit(cpBody *body, cpFloat m, cpFloat i)
 	body->w_bias = 0.0f;
 	
 	body->data = NULL;
+	body->v_limit = (cpFloat)INFINITY;
+	body->w_limit = (cpFloat)INFINITY;
 //	body->active = 1;
 
 	return body;
@@ -68,43 +72,47 @@ void cpBodyDestroy(cpBody *body){}
 void
 cpBodyFree(cpBody *body)
 {
-	if(body) cpBodyDestroy(body);
-	free(body);
+	if(body){
+		cpBodyDestroy(body);
+		cpfree(body);
+	}
 }
 
 void
-cpBodySetMass(cpBody *body, cpFloat m)
+cpBodySetMass(cpBody *body, cpFloat mass)
 {
-	body->m = m;
-	body->m_inv = 1.0f/m;
+	body->m = mass;
+	body->m_inv = 1.0f/mass;
 }
 
 void
-cpBodySetMoment(cpBody *body, cpFloat i)
+cpBodySetMoment(cpBody *body, cpFloat moment)
 {
-	body->i = i;
-	body->i_inv = 1.0f/i;
+	body->i = moment;
+	body->i_inv = 1.0f/moment;
 }
 
 void
-cpBodySetAngle(cpBody *body, cpFloat a)
+cpBodySetAngle(cpBody *body, cpFloat angle)
 {
-	body->a = fmod(a, (cpFloat)M_PI*2.0f);
-	body->rot = cpvforangle(a);
+	body->a = angle;//fmod(a, (cpFloat)M_PI*2.0f);
+	body->rot = cpvforangle(angle);
 }
 
 void
 cpBodySlew(cpBody *body, cpVect pos, cpFloat dt)
 {
 	cpVect delta = cpvsub(pos, body->p);
-	body->v = cpvmult(delta, 1.0/dt);
+	body->v = cpvmult(delta, 1.0f/dt);
 }
 
 void
 cpBodyUpdateVelocity(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt)
 {
-	body->v = cpvadd(cpvmult(body->v, damping), cpvmult(cpvadd(gravity, cpvmult(body->f, body->m_inv)), dt));
-	body->w = body->w*damping + body->t*body->i_inv*dt;
+	body->v = cpvclamp(cpvadd(cpvmult(body->v, damping), cpvmult(cpvadd(gravity, cpvmult(body->f, body->m_inv)), dt)), body->v_limit);
+	
+	cpFloat w_limit = body->w_limit;
+	body->w = cpfclamp(body->w*damping + body->t*body->i_inv*dt, -w_limit, w_limit);
 }
 
 void
@@ -125,14 +133,14 @@ cpBodyResetForces(cpBody *body)
 }
 
 void
-cpBodyApplyForce(cpBody *body, cpVect f, cpVect r)
+cpBodyApplyForce(cpBody *body, cpVect force, cpVect r)
 {
-	body->f = cpvadd(body->f, f);
-	body->t += cpvcross(r, f);
+	body->f = cpvadd(body->f, force);
+	body->t += cpvcross(r, force);
 }
 
 void
-cpDampedSpring(cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2, cpFloat rlen, cpFloat k, cpFloat dmp, cpFloat dt)
+cpApplyDampedSpring(cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2, cpFloat rlen, cpFloat k, cpFloat dmp, cpFloat dt)
 {
 	// Calculate the world space anchor coordinates.
 	cpVect r1 = cpvrotate(anchr1, a->rot);

data/ext/chipmunk/cpCollision.c

@@ -22,34 +22,30 @@
 #include <stdlib.h>
 #include <math.h>
 #include <stdio.h>
-#include <assert.h>
 
 #include "chipmunk.h"
 
-typedef int (*collisionFunc)(cpShape*, cpShape*, cpContact**);
-
-static collisionFunc *colfuncs = NULL;
+typedef int (*collisionFunc)(cpShape *, cpShape *, cpContact *);
 
 // Add contact points for circle to circle collisions.
 // Used by several collision tests.
 static int
-circle2circleQuery(cpVect p1, cpVect p2, cpFloat r1, cpFloat r2, cpContact **con)
+circle2circleQuery(cpVect p1, cpVect p2, cpFloat r1, cpFloat r2, cpContact *con)
 {
 	cpFloat mindist = r1 + r2;
 	cpVect delta = cpvsub(p2, p1);
 	cpFloat distsq = cpvlengthsq(delta);
 	if(distsq >= mindist*mindist) return 0;
 	
-	cpFloat dist = sqrtf(distsq);
+	cpFloat dist = cpfsqrt(distsq);
 	// To avoid singularities, do nothing in the case of dist = 0.
 	cpFloat non_zero_dist = (dist ? dist : INFINITY);
 
 	// Allocate and initialize the contact.
-	(*con) = (cpContact *)malloc(sizeof(cpContact));
 	cpContactInit(
-		(*con),
-		cpvadd(p1, cpvmult(delta, 0.5 + (r1 - 0.5*mindist)/non_zero_dist)),
-		cpvmult(delta, 1.0/non_zero_dist),
+		con,
+		cpvadd(p1, cpvmult(delta, 0.5f + (r1 - 0.5f*mindist)/non_zero_dist)),
+		cpvmult(delta, 1.0f/non_zero_dist),
 		dist - mindist,
 		0
 	);
@@ -59,7 +55,7 @@ circle2circleQuery(cpVect p1, cpVect p2, cpFloat r1, cpFloat r2, cpContact **con
 
 // Collide circle shapes.
 static int
-circle2circle(cpShape *shape1, cpShape *shape2, cpContact **arr)
+circle2circle(cpShape *shape1, cpShape *shape2, cpContact *arr)
 {
 	cpCircleShape *circ1 = (cpCircleShape *)shape1;
 	cpCircleShape *circ2 = (cpCircleShape *)shape2;
@@ -69,7 +65,7 @@ circle2circle(cpShape *shape1, cpShape *shape2, cpContact **arr)
 
 // Collide circles to segment shapes.
 static int
-circle2segment(cpShape *circleShape, cpShape *segmentShape, cpContact **con)
+circle2segment(cpShape *circleShape, cpShape *segmentShape, cpContact *con)
 {
 	cpCircleShape *circ = (cpCircleShape *)circleShape;
 	cpSegmentShape *seg = (cpSegmentShape *)segmentShape;
@@ -79,7 +75,7 @@ circle2segment(cpShape *circleShape, cpShape *segmentShape, cpContact **con)
 	
 	// Calculate normal distance from segment.
 	cpFloat dn = cpvdot(seg->tn, circ->tc) - cpvdot(seg->ta, seg->tn);
-	cpFloat dist = fabs(dn) - rsum;
+	cpFloat dist = cpfabs(dn) - rsum;
 	if(dist > 0.0f) return 0;
 	
 	// Calculate tangential distance along segment.
@@ -97,9 +93,8 @@ circle2segment(cpShape *circleShape, cpShape *segmentShape, cpContact **con)
 	} else {
 		if(dt < dtMax){
 			cpVect n = (dn < 0.0f) ? seg->tn : cpvneg(seg->tn);
-			(*con) = (cpContact *)malloc(sizeof(cpContact));
 			cpContactInit(
-				(*con),
+				con,
 				cpvadd(circ->tc, cpvmult(n, circ->r + dist*0.5f)),
 				n,
 				dist,
@@ -118,25 +113,17 @@ circle2segment(cpShape *circleShape, cpShape *segmentShape, cpContact **con)
 	return 1;
 }
 
-// Helper function for allocating contact point lists.
+// Helper function for working with contact buffers
+// This used to malloc/realloc memory on the fly but was repurposed.
 static cpContact *
-addContactPoint(cpContact **arr, int *max, int *num)
+nextContactPoint(cpContact *arr, int *numPtr)
 {
-	if(*arr == NULL){
-		// Allocate the array if it hasn't been done.
-		(*max) = 2;
-		(*num) = 0;
-		(*arr) = (cpContact *)malloc((*max)*sizeof(cpContact));
-	} else if(*num == *max){
-		// Extend it if necessary.
-		(*max) *= 2;
-		(*arr) = (cpContact *)realloc(*arr, (*max)*sizeof(cpContact));
-	}
+	int num = *numPtr;
 	
-	cpContact *con = &(*arr)[*num];
-	(*num)++;
+	if(num <= CP_MAX_CONTACTS_PER_ARBITER)
+		(*numPtr) = num + 1;
 	
-	return con;
+	return &arr[num];
 }
 
 // Find the minimum separating axis for the give poly and axis list.
@@ -145,11 +132,11 @@ findMSA(cpPolyShape *poly, cpPolyShapeAxis *axes, int num, cpFloat *min_out)
 {
 	int min_index = 0;
 	cpFloat min = cpPolyShapeValueOnAxis(poly, axes->n, axes->d);
-	if(min > 0.0) return -1;
+	if(min > 0.0f) return -1;
 	
 	for(int i=1; i<num; i++){
 		cpFloat dist = cpPolyShapeValueOnAxis(poly, axes[i].n, axes[i].d);
-		if(dist > 0.0) {
+		if(dist > 0.0f) {
 			return -1;
 		} else if(dist > min){
 			min = dist;
@@ -163,21 +150,20 @@ findMSA(cpPolyShape *poly, cpPolyShapeAxis *axes, int num, cpFloat *min_out)
 
 // Add contacts for penetrating vertexes.
 static inline int
-findVerts(cpContact **arr, cpPolyShape *poly1, cpPolyShape *poly2, cpVect n, cpFloat dist)
+findVerts(cpContact *arr, cpPolyShape *poly1, cpPolyShape *poly2, cpVect n, cpFloat dist)
 {
-	int max = 0;
 	int num = 0;
 	
 	for(int i=0; i<poly1->numVerts; i++){
 		cpVect v = poly1->tVerts[i];
 		if(cpPolyShapeContainsVertPartial(poly2, v, cpvneg(n)))
-			cpContactInit(addContactPoint(arr, &max, &num), v, n, dist, CP_HASH_PAIR(poly1, i));
+			cpContactInit(nextContactPoint(arr, &num), v, n, dist, CP_HASH_PAIR(poly1->shape.hashid, i));
 	}
 	
 	for(int i=0; i<poly2->numVerts; i++){
 		cpVect v = poly2->tVerts[i];
 		if(cpPolyShapeContainsVertPartial(poly1, v, n))
-			cpContactInit(addContactPoint(arr, &max, &num), v, n, dist, CP_HASH_PAIR(poly2, i));
+			cpContactInit(nextContactPoint(arr, &num), v, n, dist, CP_HASH_PAIR(poly2->shape.hashid, i));
 	}
 	
 	//	if(!num)
@@ -188,7 +174,7 @@ findVerts(cpContact **arr, cpPolyShape *poly1, cpPolyShape *poly2, cpVect n, cpF
 
 // Collide poly shapes together.
 static int
-poly2poly(cpShape *shape1, cpShape *shape2, cpContact **arr)
+poly2poly(cpShape *shape1, cpShape *shape2, cpContact *arr)
 {
 	cpPolyShape *poly1 = (cpPolyShape *)shape1;
 	cpPolyShape *poly2 = (cpPolyShape *)shape2;
@@ -209,7 +195,7 @@ poly2poly(cpShape *shape1, cpShape *shape2, cpContact **arr)
 }
 
 // Like cpPolyValueOnAxis(), but for segments.
-static inline float
+static inline cpFloat
 segValueOnAxis(cpSegmentShape *seg, cpVect n, cpFloat d)
 {
 	cpFloat a = cpvdot(n, seg->ta) - seg->r;
@@ -219,7 +205,7 @@ segValueOnAxis(cpSegmentShape *seg, cpVect n, cpFloat d)
 
 // Identify vertexes that have penetrated the segment.
 static inline void
-findPointsBehindSeg(cpContact **arr, int *max, int *num, cpSegmentShape *seg, cpPolyShape *poly, cpFloat pDist, cpFloat coef) 
+findPointsBehindSeg(cpContact *arr, int *num, cpSegmentShape *seg, cpPolyShape *poly, cpFloat pDist, cpFloat coef) 
 {
 	cpFloat dta = cpvcross(seg->tn, seg->ta);
 	cpFloat dtb = cpvcross(seg->tn, seg->tb);
@@ -230,7 +216,7 @@ findPointsBehindSeg(cpContact **arr, int *max, int *num, cpSegmentShape *seg, cp
 		if(cpvdot(v, n) < cpvdot(seg->tn, seg->ta)*coef + seg->r){
 			cpFloat dt = cpvcross(seg->tn, v);
 			if(dta >= dt && dt >= dtb){
-				cpContactInit(addContactPoint(arr, max, num), v, n, pDist, CP_HASH_PAIR(poly, i));
+				cpContactInit(nextContactPoint(arr, num), v, n, pDist, CP_HASH_PAIR(poly->shape.hashid, i));
 			}
 		}
 	}
@@ -239,7 +225,7 @@ findPointsBehindSeg(cpContact **arr, int *max, int *num, cpSegmentShape *seg, cp
 // This one is complicated and gross. Just don't go there...
 // TODO: Comment me!
 static int
-seg2poly(cpShape *shape1, cpShape *shape2, cpContact **arr)
+seg2poly(cpShape *shape1, cpShape *shape2, cpContact *arr)
 {
 	cpSegmentShape *seg = (cpSegmentShape *)shape1;
 	cpPolyShape *poly = (cpPolyShape *)shape2;
@@ -263,7 +249,6 @@ seg2poly(cpShape *shape1, cpShape *shape2, cpContact **arr)
 		}
 	}
 	
-	int max = 0;
 	int num = 0;
 	
 	cpVect poly_n = cpvneg(axes[mini].n);
@@ -271,18 +256,18 @@ seg2poly(cpShape *shape1, cpShape *shape2, cpContact **arr)
 	cpVect va = cpvadd(seg->ta, cpvmult(poly_n, seg->r));
 	cpVect vb = cpvadd(seg->tb, cpvmult(poly_n, seg->r));
 	if(cpPolyShapeContainsVert(poly, va))
-		cpContactInit(addContactPoint(arr, &max, &num), va, poly_n, poly_min, CP_HASH_PAIR(seg, 0));
+		cpContactInit(nextContactPoint(arr, &num), va, poly_n, poly_min, CP_HASH_PAIR(seg->shape.hashid, 0));
 	if(cpPolyShapeContainsVert(poly, vb))
-		cpContactInit(addContactPoint(arr, &max, &num), vb, poly_n, poly_min, CP_HASH_PAIR(seg, 1));
+		cpContactInit(nextContactPoint(arr, &num), vb, poly_n, poly_min, CP_HASH_PAIR(seg->shape.hashid, 1));
 
 	// Floating point precision problems here.
 	// This will have to do for now.
 	poly_min -= cp_collision_slop;
 	if(minNorm >= poly_min || minNeg >= poly_min) {
 		if(minNorm > minNeg)
-			findPointsBehindSeg(arr, &max, &num, seg, poly, minNorm, 1.0f);
+			findPointsBehindSeg(arr, &num, seg, poly, minNorm, 1.0f);
 		else
-			findPointsBehindSeg(arr, &max, &num, seg, poly, minNeg, -1.0f);
+			findPointsBehindSeg(arr, &num, seg, poly, minNeg, -1.0f);
 	}
 	
 	// If no other collision points are found, try colliding endpoints.
@@ -309,7 +294,7 @@ seg2poly(cpShape *shape1, cpShape *shape2, cpContact **arr)
 // This one is less gross, but still gross.
 // TODO: Comment me!
 static int
-circle2poly(cpShape *shape1, cpShape *shape2, cpContact **con)
+circle2poly(cpShape *shape1, cpShape *shape2, cpContact *con)
 {
 	cpCircleShape *circ = (cpCircleShape *)shape1;
 	cpPolyShape *poly = (cpPolyShape *)shape2;
@@ -319,7 +304,7 @@ circle2poly(cpShape *shape1, cpShape *shape2, cpContact **con)
 	cpFloat min = cpvdot(axes->n, circ->tc) - axes->d - circ->r;
 	for(int i=0; i<poly->numVerts; i++){
 		cpFloat dist = cpvdot(axes[i].n, circ->tc) - axes[i].d - circ->r;
-		if(dist > 0.0){
+		if(dist > 0.0f){
 			return 0;
 		} else if(dist > min) {
 			min = dist;
@@ -337,9 +322,8 @@ circle2poly(cpShape *shape1, cpShape *shape2, cpContact **con)
 	if(dt < dtb){
 		return circle2circleQuery(circ->tc, b, circ->r, 0.0f, con);
 	} else if(dt < dta) {
-		(*con) = (cpContact *)malloc(sizeof(cpContact));
 		cpContactInit(
-			(*con),
+			con,
 			cpvsub(circ->tc, cpvmult(n, circ->r + min/2.0f)),
 			cpvneg(n),
 			min,
@@ -352,6 +336,21 @@ circle2poly(cpShape *shape1, cpShape *shape2, cpContact **con)
 	}
 }
 
+//static const collisionFunc builtinCollisionFuncs[9] = {
+//	circle2circle,
+//	NULL,
+//	NULL,
+//	circle2segment,
+//	NULL,
+//	NULL,
+//	circle2poly,
+//	seg2poly,
+//	poly2poly,
+//};
+//static const collisionFunc *colfuncs = builtinCollisionFuncs;
+
+static collisionFunc *colfuncs = NULL;
+
 static void
 addColFunc(cpShapeType a, cpShapeType b, collisionFunc func)
 {
@@ -361,13 +360,15 @@ addColFunc(cpShapeType a, cpShapeType b, collisionFunc func)
 #ifdef __cplusplus
 extern "C" {
 #endif
+	void cpInitCollisionFuncs(void);
+	
 	// Initializes the array of collision functions.
 	// Called by cpInitChipmunk().
 	void
 	cpInitCollisionFuncs(void)
 	{
 		if(!colfuncs)
-			colfuncs = (collisionFunc *)calloc(CP_NUM_SHAPES*CP_NUM_SHAPES, sizeof(collisionFunc));
+			colfuncs = (collisionFunc *)cpcalloc(CP_NUM_SHAPES*CP_NUM_SHAPES, sizeof(collisionFunc));
 		
 		addColFunc(CP_CIRCLE_SHAPE,  CP_CIRCLE_SHAPE,  circle2circle);
 		addColFunc(CP_CIRCLE_SHAPE,  CP_SEGMENT_SHAPE, circle2segment);
@@ -380,10 +381,10 @@ extern "C" {
 #endif
 
 int
-cpCollideShapes(cpShape *a, cpShape *b, cpContact **arr)
+cpCollideShapes(cpShape *a, cpShape *b, cpContact *arr)
 {
 	// Their shape types must be in order.
-	assert(a->klass->type <= b->klass->type);
+	cpAssert(a->klass->type <= b->klass->type, "Collision shapes passed to cpCollideShapes() are not sorted.");
 	
 	collisionFunc cfunc = colfuncs[a->klass->type + b->klass->type*CP_NUM_SHAPES];
 	return (cfunc) ? cfunc(a, b, arr) : 0;