chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/cpDampedSpring.c

@@ -19,9 +19,6 @@
  * SOFTWARE.
  */
 
-#include <stdlib.h>
-#include <math.h>
-
 #include "chipmunk_private.h"
 #include "constraints/util.h"
 
@@ -31,9 +28,10 @@ defaultSpringForce(cpDampedSpring *spring, cpFloat dist){
 }
 
 static void
-preStep(cpDampedSpring *spring, cpFloat dt, cpFloat dt_inv)
+preStep(cpDampedSpring *spring, cpFloat dt)
 {
-	CONSTRAINT_BEGIN(spring, a, b);
+	cpBody *a = spring->constraint.a;
+	cpBody *b = spring->constraint.b;
 	
 	spring->r1 = cpvrotate(spring->anchr1, a->rot);
 	spring->r2 = cpvrotate(spring->anchr2, b->rot);
@@ -43,6 +41,7 @@ preStep(cpDampedSpring *spring, cpFloat dt, cpFloat dt_inv)
 	spring->n = cpvmult(delta, 1.0f/(dist ? dist : INFINITY));
 	
 	cpFloat k = k_scalar(a, b, spring->r1, spring->r2, spring->n);
+	cpAssertSoft(k != 0.0, "Unsolvable spring.");
 	spring->nMass = 1.0f/k;
 	
 	spring->target_vrn = 0.0f;
@@ -50,46 +49,52 @@ preStep(cpDampedSpring *spring, cpFloat dt, cpFloat dt_inv)
 
 	// apply spring force
 	cpFloat f_spring = spring->springForceFunc((cpConstraint *)spring, dist);
-	apply_impulses(a, b, spring->r1, spring->r2, cpvmult(spring->n, f_spring*dt));
+	cpFloat j_spring = spring->jAcc = f_spring*dt;
+	apply_impulses(a, b, spring->r1, spring->r2, cpvmult(spring->n, j_spring));
 }
 
+static void applyCachedImpulse(cpDampedSpring *spring, cpFloat dt_coef){}
+
 static void
-applyImpulse(cpDampedSpring *spring)
+applyImpulse(cpDampedSpring *spring, cpFloat dt)
 {
-	CONSTRAINT_BEGIN(spring, a, b);
+	cpBody *a = spring->constraint.a;
+	cpBody *b = spring->constraint.b;
 	
 	cpVect n = spring->n;
 	cpVect r1 = spring->r1;
 	cpVect r2 = spring->r2;
 
 	// compute relative velocity
-	cpFloat vrn = normal_relative_velocity(a, b, r1, r2, n) - spring->target_vrn;
+	cpFloat vrn = normal_relative_velocity(a, b, r1, r2, n);
 	
 	// compute velocity loss from drag
-	// not 100% certain this is derived correctly, though it makes sense
-	cpFloat v_damp = -vrn*spring->v_coef;
+	cpFloat v_damp = (spring->target_vrn - vrn)*spring->v_coef;
 	spring->target_vrn = vrn + v_damp;
 	
-	apply_impulses(a, b, spring->r1, spring->r2, cpvmult(spring->n, v_damp*spring->nMass));
+	cpFloat j_damp = v_damp*spring->nMass;
+	spring->jAcc += j_damp;
+	apply_impulses(a, b, spring->r1, spring->r2, cpvmult(spring->n, j_damp));
 }
 
 static cpFloat
-getImpulse(cpConstraint *constraint)
+getImpulse(cpDampedSpring *spring)
 {
-	return 0.0f;
+	return spring->jAcc;
 }
 
 static const cpConstraintClass klass = {
-	(cpConstraintPreStepFunction)preStep,
-	(cpConstraintApplyImpulseFunction)applyImpulse,
-	(cpConstraintGetImpulseFunction)getImpulse,
+	(cpConstraintPreStepImpl)preStep,
+	(cpConstraintApplyCachedImpulseImpl)applyCachedImpulse,
+	(cpConstraintApplyImpulseImpl)applyImpulse,
+	(cpConstraintGetImpulseImpl)getImpulse,
 };
 CP_DefineClassGetter(cpDampedSpring)
 
 cpDampedSpring *
 cpDampedSpringAlloc(void)
 {
-	return (cpDampedSpring *)cpmalloc(sizeof(cpDampedSpring));
+	return (cpDampedSpring *)cpcalloc(1, sizeof(cpDampedSpring));
 }
 
 cpDampedSpring *
@@ -105,6 +110,8 @@ cpDampedSpringInit(cpDampedSpring *spring, cpBody *a, cpBody *b, cpVect anchr1,
 	spring->damping = damping;
 	spring->springForceFunc = (cpDampedSpringForceFunc)defaultSpringForce;
 	
+	spring->jAcc = 0.0f;
+	
 	return spring;
 }
 

data/ext/chipmunk/cpGearJoint.c

@@ -19,44 +19,49 @@
  * SOFTWARE.
  */
 
-#include <stdlib.h>
-
 #include "chipmunk_private.h"
 #include "constraints/util.h"
 
 static void
-preStep(cpGearJoint *joint, cpFloat dt, cpFloat dt_inv)
+preStep(cpGearJoint *joint, cpFloat dt)
 {
-	CONSTRAINT_BEGIN(joint, a, b);
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
 	
 	// calculate moment of inertia coefficient.
 	joint->iSum = 1.0f/(a->i_inv*joint->ratio_inv + joint->ratio*b->i_inv);
 	
 	// calculate bias velocity
 	cpFloat maxBias = joint->constraint.maxBias;
-	joint->bias = cpfclamp(-joint->constraint.biasCoef*dt_inv*(b->a*joint->ratio - a->a - joint->phase), -maxBias, maxBias);
-	
-	// compute max impulse
-	joint->jMax = J_MAX(joint, dt);
+	joint->bias = cpfclamp(-bias_coef(joint->constraint.errorBias, dt)*(b->a*joint->ratio - a->a - joint->phase)/dt, -maxBias, maxBias);
+}
 
-	// apply joint torque
-	cpFloat j = joint->jAcc;
+static void
+applyCachedImpulse(cpGearJoint *joint, cpFloat dt_coef)
+{
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
+	
+	cpFloat j = joint->jAcc*dt_coef;
 	a->w -= j*a->i_inv*joint->ratio_inv;
 	b->w += j*b->i_inv;
 }
 
 static void
-applyImpulse(cpGearJoint *joint)
+applyImpulse(cpGearJoint *joint, cpFloat dt)
 {
-	CONSTRAINT_BEGIN(joint, a, b);
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
 	
 	// compute relative rotational velocity
 	cpFloat wr = b->w*joint->ratio - a->w;
 	
+	cpFloat jMax = joint->constraint.maxForce*dt;
+	
 	// compute normal impulse	
 	cpFloat j = (joint->bias - wr)*joint->iSum;
 	cpFloat jOld = joint->jAcc;
-	joint->jAcc = cpfclamp(jOld + j, -joint->jMax, joint->jMax);
+	joint->jAcc = cpfclamp(jOld + j, -jMax, jMax);
 	j = joint->jAcc - jOld;
 	
 	// apply impulse
@@ -71,16 +76,17 @@ getImpulse(cpGearJoint *joint)
 }
 
 static const cpConstraintClass klass = {
-	(cpConstraintPreStepFunction)preStep,
-	(cpConstraintApplyImpulseFunction)applyImpulse,
-	(cpConstraintGetImpulseFunction)getImpulse,
+	(cpConstraintPreStepImpl)preStep,
+	(cpConstraintApplyCachedImpulseImpl)applyCachedImpulse,
+	(cpConstraintApplyImpulseImpl)applyImpulse,
+	(cpConstraintGetImpulseImpl)getImpulse,
 };
 CP_DefineClassGetter(cpGearJoint)
 
 cpGearJoint *
 cpGearJointAlloc(void)
 {
-	return (cpGearJoint *)cpmalloc(sizeof(cpGearJoint));
+	return (cpGearJoint *)cpcalloc(1, sizeof(cpGearJoint));
 }
 
 cpGearJoint *

data/ext/chipmunk/cpGrooveJoint.c

@@ -19,15 +19,14 @@
  * SOFTWARE.
  */
 
-#include <stdlib.h>
-
 #include "chipmunk_private.h"
 #include "constraints/util.h"
 
 static void
-preStep(cpGrooveJoint *joint, cpFloat dt, cpFloat dt_inv)
+preStep(cpGrooveJoint *joint, cpFloat dt)
 {
-	CONSTRAINT_BEGIN(joint, a, b);
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
 	
 	// calculate endpoints in worldspace
 	cpVect ta = cpBodyLocal2World(a, joint->grv_a);
@@ -55,30 +54,34 @@ preStep(cpGrooveJoint *joint, cpFloat dt, cpFloat dt_inv)
 	}
 	
 	// Calculate mass tensor
-	k_tensor(a, b, joint->r1, joint->r2, &joint->k1, &joint->k2);	
-	
-	// compute max impulse
-	joint->jMaxLen = J_MAX(joint, dt);
+	joint->k = k_tensor(a, b, joint->r1, joint->r2);
 	
 	// calculate bias velocity
 	cpVect delta = cpvsub(cpvadd(b->p, joint->r2), cpvadd(a->p, joint->r1));
-	joint->bias = cpvclamp(cpvmult(delta, -joint->constraint.biasCoef*dt_inv), joint->constraint.maxBias);
-	
-	// apply accumulated impulse
-	apply_impulses(a, b, joint->r1, joint->r2, joint->jAcc);
+	joint->bias = cpvclamp(cpvmult(delta, -bias_coef(joint->constraint.errorBias, dt)/dt), joint->constraint.maxBias);
+}
+
+static void
+applyCachedImpulse(cpGrooveJoint *joint, cpFloat dt_coef)
+{
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
+		
+	apply_impulses(a, b, joint->r1, joint->r2, cpvmult(joint->jAcc, dt_coef));
 }
 
 static inline cpVect
-grooveConstrain(cpGrooveJoint *joint, cpVect j){
+grooveConstrain(cpGrooveJoint *joint, cpVect j, cpFloat dt){
 	cpVect n = joint->grv_tn;
 	cpVect jClamp = (joint->clamp*cpvcross(j, n) > 0.0f) ? j : cpvproject(j, n);
-	return cpvclamp(jClamp, joint->jMaxLen);
+	return cpvclamp(jClamp, joint->constraint.maxForce*dt);
 }
 
 static void
-applyImpulse(cpGrooveJoint *joint)
+applyImpulse(cpGrooveJoint *joint, cpFloat dt)
 {
-	CONSTRAINT_BEGIN(joint, a, b);
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
 	
 	cpVect r1 = joint->r1;
 	cpVect r2 = joint->r2;
@@ -86,9 +89,9 @@ applyImpulse(cpGrooveJoint *joint)
 	// compute impulse
 	cpVect vr = relative_velocity(a, b, r1, r2);
 
-	cpVect j = mult_k(cpvsub(joint->bias, vr), joint->k1, joint->k2);
+	cpVect j = cpMat2x2Transform(joint->k, cpvsub(joint->bias, vr));
 	cpVect jOld = joint->jAcc;
-	joint->jAcc = grooveConstrain(joint, cpvadd(jOld, j));
+	joint->jAcc = grooveConstrain(joint, cpvadd(jOld, j), dt);
 	j = cpvsub(joint->jAcc, jOld);
 	
 	// apply impulse
@@ -102,16 +105,17 @@ getImpulse(cpGrooveJoint *joint)
 }
 
 static const cpConstraintClass klass = {
-	(cpConstraintPreStepFunction)preStep,
-	(cpConstraintApplyImpulseFunction)applyImpulse,
-	(cpConstraintGetImpulseFunction)getImpulse,
+	(cpConstraintPreStepImpl)preStep,
+	(cpConstraintApplyCachedImpulseImpl)applyCachedImpulse,
+	(cpConstraintApplyImpulseImpl)applyImpulse,
+	(cpConstraintGetImpulseImpl)getImpulse,
 };
 CP_DefineClassGetter(cpGrooveJoint)
 
 cpGrooveJoint *
 cpGrooveJointAlloc(void)
 {
-	return (cpGrooveJoint *)cpmalloc(sizeof(cpGrooveJoint));
+	return (cpGrooveJoint *)cpcalloc(1, sizeof(cpGrooveJoint));
 }
 
 cpGrooveJoint *

data/ext/chipmunk/cpHashSet.c

@@ -19,48 +19,49 @@
  * SOFTWARE.
  */
  
-#include <stdlib.h>
-#include <assert.h>
-
 #include "chipmunk_private.h"
 #include "prime.h"
 
-static void freeWrap(void *ptr, void *unused){cpfree(ptr);}
+typedef struct cpHashSetBin {
+	void *elt;
+	cpHashValue hash;
+	struct cpHashSetBin *next;
+} cpHashSetBin;
 
-void
-cpHashSetDestroy(cpHashSet *set)
-{
-	// Free the table.
-	cpfree(set->table);
+struct cpHashSet {
+	unsigned int entries, size;
 	
-	cpArrayEach(set->allocatedBuffers, freeWrap, NULL);
-	cpArrayFree(set->allocatedBuffers);
-}
+	cpHashSetEqlFunc eql;
+	void *default_value;
+	
+	cpHashSetBin **table;
+	cpHashSetBin *pooledBins;
+	
+	cpArray *allocatedBuffers;
+};
 
 void
 cpHashSetFree(cpHashSet *set)
 {
 	if(set){
-		cpHashSetDestroy(set);
+		cpfree(set->table);
+		
+		cpArrayFreeEach(set->allocatedBuffers, cpfree);
+		cpArrayFree(set->allocatedBuffers);
+		
 		cpfree(set);
 	}
 }
 
 cpHashSet *
-cpHashSetAlloc(void)
-{
-	return (cpHashSet *)cpcalloc(1, sizeof(cpHashSet));
-}
-
-cpHashSet *
-cpHashSetInit(cpHashSet *set, int size, cpHashSetEqlFunc eqlFunc, cpHashSetTransFunc trans)
+cpHashSetNew(int size, cpHashSetEqlFunc eqlFunc)
 {
+	cpHashSet *set = (cpHashSet *)cpcalloc(1, sizeof(cpHashSet));
+	
 	set->size = next_prime(size);
 	set->entries = 0;
 	
 	set->eql = eqlFunc;
-	set->trans = trans;
-	
 	set->default_value = NULL;
 	
 	set->table = (cpHashSetBin **)cpcalloc(set->size, sizeof(cpHashSetBin *));
@@ -71,10 +72,10 @@ cpHashSetInit(cpHashSet *set, int size, cpHashSetEqlFunc eqlFunc, cpHashSetTrans
 	return set;
 }
 
-cpHashSet *
-cpHashSetNew(int size, cpHashSetEqlFunc eqlFunc, cpHashSetTransFunc trans)
+void
+cpHashSetSetDefaultValue(cpHashSet *set, void *default_value)
 {
-	return cpHashSetInit(cpHashSetAlloc(), size, eqlFunc, trans);
+	set->default_value = default_value;
 }
 
 static int
@@ -87,18 +88,18 @@ static void
 cpHashSetResize(cpHashSet *set)
 {
 	// Get the next approximate doubled prime.
-	int newSize = next_prime(set->size + 1);
+	unsigned int newSize = next_prime(set->size + 1);
 	// Allocate a new table.
 	cpHashSetBin **newTable = (cpHashSetBin **)cpcalloc(newSize, sizeof(cpHashSetBin *));
 	
 	// Iterate over the chains.
-	for(int i=0; i<set->size; i++){
+	for(unsigned int i=0; i<set->size; i++){
 		// Rehash the bins into the new table.
 		cpHashSetBin *bin = set->table[i];
 		while(bin){
 			cpHashSetBin *next = bin->next;
 			
-			int idx = bin->hash%newSize;
+			cpHashValue idx = bin->hash%newSize;
 			bin->next = newTable[idx];
 			newTable[idx] = bin;
 			
@@ -131,41 +132,44 @@ getUnusedBin(cpHashSet *set)
 	} else {
 		// Pool is exhausted, make more
 		int count = CP_BUFFER_BYTES/sizeof(cpHashSetBin);
-		cpAssert(count, "Buffer size is too small.");
+		cpAssertHard(count, "Internal Error: Buffer size is too small.");
 		
-		cpHashSetBin *buffer = (cpHashSetBin *)cpmalloc(CP_BUFFER_BYTES);
+		cpHashSetBin *buffer = (cpHashSetBin *)cpcalloc(1, CP_BUFFER_BYTES);
 		cpArrayPush(set->allocatedBuffers, buffer);
 		
-		// push all but the first one, return the first instead
+		// push all but the first one, return it instead
 		for(int i=1; i<count; i++) recycleBin(set, buffer + i);
 		return buffer;
 	}
 }
 
+int
+cpHashSetCount(cpHashSet *set)
+{
+	return set->entries;
+}
+
 void *
-cpHashSetInsert(cpHashSet *set, cpHashValue hash, void *ptr, void *data)
+cpHashSetInsert(cpHashSet *set, cpHashValue hash, void *ptr, void *data, cpHashSetTransFunc trans)
 {
-	int idx = hash%set->size;
+	cpHashValue idx = hash%set->size;
 	
 	// Find the bin with the matching element.
 	cpHashSetBin *bin = set->table[idx];
 	while(bin && !set->eql(ptr, bin->elt))
 		bin = bin->next;
 	
-	// Create it necessary.
+	// Create it if necessary.
 	if(!bin){
 		bin = getUnusedBin(set);
 		bin->hash = hash;
-		bin->elt = set->trans(ptr, data); // Transform the pointer.
+		bin->elt = (trans ? trans(ptr, data) : data);
 		
 		bin->next = set->table[idx];
 		set->table[idx] = bin;
 		
 		set->entries++;
-		
-		// Resize the set if it's full.
-		if(setIsFull(set))
-			cpHashSetResize(set);
+		if(setIsFull(set)) cpHashSetResize(set);
 	}
 	
 	return bin->elt;
@@ -174,11 +178,9 @@ cpHashSetInsert(cpHashSet *set, cpHashValue hash, void *ptr, void *data)
 void *
 cpHashSetRemove(cpHashSet *set, cpHashValue hash, void *ptr)
 {
-	int idx = hash%set->size;
+	cpHashValue idx = hash%set->size;
 	
-	// Pointer to the previous bin pointer.
 	cpHashSetBin **prev_ptr = &set->table[idx];
-	// Pointer the the current bin.
 	cpHashSetBin *bin = set->table[idx];
 	
 	// Find the bin
@@ -189,15 +191,14 @@ cpHashSetRemove(cpHashSet *set, cpHashValue hash, void *ptr)
 	
 	// Remove it if it exists.
 	if(bin){
-		// Update the previous bin pointer to point to the next bin.
+		// Update the previous linked list pointer
 		(*prev_ptr) = bin->next;
 		set->entries--;
 		
-		void *return_value = bin->elt;
-		
+		void *elt = bin->elt;
 		recycleBin(set, bin);
 		
-		return return_value;
+		return elt;
 	}
 	
 	return NULL;
@@ -206,7 +207,7 @@ cpHashSetRemove(cpHashSet *set, cpHashValue hash, void *ptr)
 void *
 cpHashSetFind(cpHashSet *set, cpHashValue hash, void *ptr)
 {	
-	int idx = hash%set->size;
+	cpHashValue idx = hash%set->size;
 	cpHashSetBin *bin = set->table[idx];
 	while(bin && !set->eql(ptr, bin->elt))
 		bin = bin->next;
@@ -215,9 +216,9 @@ cpHashSetFind(cpHashSet *set, cpHashValue hash, void *ptr)
 }
 
 void
-cpHashSetEach(cpHashSet *set, cpHashSetIterFunc func, void *data)
+cpHashSetEach(cpHashSet *set, cpHashSetIteratorFunc func, void *data)
 {
-	for(int i=0; i<set->size; i++){
+	for(unsigned int i=0; i<set->size; i++){
 		cpHashSetBin *bin = set->table[i];
 		while(bin){
 			cpHashSetBin *next = bin->next;
@@ -230,8 +231,7 @@ cpHashSetEach(cpHashSet *set, cpHashSetIterFunc func, void *data)
 void
 cpHashSetFilter(cpHashSet *set, cpHashSetFilterFunc func, void *data)
 {
-	// Iterate over all the chains.
-	for(int i=0; i<set->size; i++){
+	for(unsigned int i=0; i<set->size; i++){
 		// The rest works similarly to cpHashSetRemove() above.
 		cpHashSetBin **prev_ptr = &set->table[i];
 		cpHashSetBin *bin = set->table[i];