chipmunk 4.1.0 → 5.2.0

data/ext/chipmunk/cpHashSet.c

@@ -25,35 +25,31 @@
 #include "chipmunk.h"
 #include "prime.h"
 
+static void freeWrap(void *ptr, void *unused){cpfree(ptr);}
+
 void
 cpHashSetDestroy(cpHashSet *set)
 {
-	// Free the chains.
-	for(int i=0; i<set->size; i++){
-		// Free the bins in the chain.
-		cpHashSetBin *bin = set->table[i];
-		while(bin){
-			cpHashSetBin *next = bin->next;
-			free(bin);
-			bin = next;
-		}
-	}
-	
 	// Free the table.
-	free(set->table);
+	cpfree(set->table);
+	
+	cpArrayEach(set->allocatedBuffers, freeWrap, NULL);
+	cpArrayFree(set->allocatedBuffers);
 }
 
 void
 cpHashSetFree(cpHashSet *set)
 {
-	if(set) cpHashSetDestroy(set);
-	free(set);
+	if(set){
+		cpHashSetDestroy(set);
+		cpfree(set);
+	}
 }
 
 cpHashSet *
 cpHashSetAlloc(void)
 {
-	return (cpHashSet *)calloc(1, sizeof(cpHashSet));
+	return (cpHashSet *)cpcalloc(1, sizeof(cpHashSet));
 }
 
 cpHashSet *
@@ -67,7 +63,10 @@ cpHashSetInit(cpHashSet *set, int size, cpHashSetEqlFunc eqlFunc, cpHashSetTrans
 	
 	set->default_value = NULL;
 	
-	set->table = (cpHashSetBin **)calloc(set->size, sizeof(cpHashSetBin *));
+	set->table = (cpHashSetBin **)cpcalloc(set->size, sizeof(cpHashSetBin *));
+	set->pooledBins = NULL;
+	
+	set->allocatedBuffers = cpArrayNew(0);
 	
 	return set;
 }
@@ -90,7 +89,7 @@ cpHashSetResize(cpHashSet *set)
 	// Get the next approximate doubled prime.
 	int newSize = next_prime(set->size + 1);
 	// Allocate a new table.
-	cpHashSetBin **newTable = (cpHashSetBin **)calloc(newSize, sizeof(cpHashSetBin *));
+	cpHashSetBin **newTable = (cpHashSetBin **)cpcalloc(newSize, sizeof(cpHashSetBin *));
 	
 	// Iterate over the chains.
 	for(int i=0; i<set->size; i++){
@@ -99,38 +98,68 @@ cpHashSetResize(cpHashSet *set)
 		while(bin){
 			cpHashSetBin *next = bin->next;
 			
-			int index = bin->hash%newSize;
-			bin->next = newTable[index];
-			newTable[index] = bin;
+			int idx = bin->hash%newSize;
+			bin->next = newTable[idx];
+			newTable[idx] = bin;
 			
 			bin = next;
 		}
 	}
 	
-	free(set->table);
+	cpfree(set->table);
 	
 	set->table = newTable;
 	set->size = newSize;
 }
 
+static inline void
+recycleBin(cpHashSet *set, cpHashSetBin *bin)
+{
+	bin->next = set->pooledBins;
+	set->pooledBins = bin;
+	bin->elt = NULL;
+}
+
+static cpHashSetBin *
+getUnusedBin(cpHashSet *set)
+{
+	cpHashSetBin *bin = set->pooledBins;
+	
+	if(bin){
+		set->pooledBins = bin->next;
+		return bin;
+	} else {
+		// Pool is exhausted, make more
+		int count = CP_BUFFER_BYTES/sizeof(cpHashSetBin);
+		cpAssert(count, "Buffer size is too small.");
+		
+		cpHashSetBin *buffer = (cpHashSetBin *)cpmalloc(CP_BUFFER_BYTES);
+		cpArrayPush(set->allocatedBuffers, buffer);
+		
+		// push all but the first one, return the first instead
+		for(int i=1; i<count; i++) recycleBin(set, buffer + i);
+		return buffer;
+	}
+}
+
 void *
-cpHashSetInsert(cpHashSet *set, unsigned int hash, void *ptr, void *data)
+cpHashSetInsert(cpHashSet *set, cpHashValue hash, void *ptr, void *data)
 {
-	int index = hash%set->size;
+	int idx = hash%set->size;
 	
 	// Find the bin with the matching element.
-	cpHashSetBin *bin = set->table[index];
+	cpHashSetBin *bin = set->table[idx];
 	while(bin && !set->eql(ptr, bin->elt))
 		bin = bin->next;
 	
 	// Create it necessary.
 	if(!bin){
-		bin = (cpHashSetBin *)malloc(sizeof(cpHashSetBin));
+		bin = getUnusedBin(set);
 		bin->hash = hash;
 		bin->elt = set->trans(ptr, data); // Transform the pointer.
 		
-		bin->next = set->table[index];
-		set->table[index] = bin;
+		bin->next = set->table[idx];
+		set->table[idx] = bin;
 		
 		set->entries++;
 		
@@ -143,14 +172,14 @@ cpHashSetInsert(cpHashSet *set, unsigned int hash, void *ptr, void *data)
 }
 
 void *
-cpHashSetRemove(cpHashSet *set, unsigned int hash, void *ptr)
+cpHashSetRemove(cpHashSet *set, cpHashValue hash, void *ptr)
 {
-	int index = hash%set->size;
+	int idx = hash%set->size;
 	
 	// Pointer to the previous bin pointer.
-	cpHashSetBin **prev_ptr = &set->table[index];
+	cpHashSetBin **prev_ptr = &set->table[idx];
 	// Pointer the the current bin.
-	cpHashSetBin *bin = set->table[index];
+	cpHashSetBin *bin = set->table[idx];
 	
 	// Find the bin
 	while(bin && !set->eql(ptr, bin->elt)){
@@ -160,12 +189,14 @@ cpHashSetRemove(cpHashSet *set, unsigned int hash, void *ptr)
 	
 	// Remove it if it exists.
 	if(bin){
-		// Update the previos bin pointer to point to the next bin.
+		// Update the previous bin pointer to point to the next bin.
 		(*prev_ptr) = bin->next;
 		set->entries--;
 		
 		void *return_value = bin->elt;
-		free(bin);
+		
+		recycleBin(set, bin);
+		
 		return return_value;
 	}
 	
@@ -173,10 +204,10 @@ cpHashSetRemove(cpHashSet *set, unsigned int hash, void *ptr)
 }
 
 void *
-cpHashSetFind(cpHashSet *set, unsigned int hash, void *ptr)
+cpHashSetFind(cpHashSet *set, cpHashValue hash, void *ptr)
 {	
-	int index = hash%set->size;
-	cpHashSetBin *bin = set->table[index];
+	int idx = hash%set->size;
+	cpHashSetBin *bin = set->table[idx];
 	while(bin && !set->eql(ptr, bin->elt))
 		bin = bin->next;
 		
@@ -187,14 +218,17 @@ void
 cpHashSetEach(cpHashSet *set, cpHashSetIterFunc func, void *data)
 {
 	for(int i=0; i<set->size; i++){
-		cpHashSetBin *bin;
-		for(bin = set->table[i]; bin; bin = bin->next)
+		cpHashSetBin *bin = set->table[i];
+		while(bin){
+			cpHashSetBin *next = bin->next;
 			func(bin->elt, data);
+			bin = next;
+		}
 	}
 }
 
 void
-cpHashSetReject(cpHashSet *set, cpHashSetRejectFunc func, void *data)
+cpHashSetFilter(cpHashSet *set, cpHashSetFilterFunc func, void *data)
 {
 	// Iterate over all the chains.
 	for(int i=0; i<set->size; i++){
@@ -210,7 +244,7 @@ cpHashSetReject(cpHashSet *set, cpHashSetRejectFunc func, void *data)
 				(*prev_ptr) = next;
 
 				set->entries--;
-				free(bin);
+				recycleBin(set, bin);
 			}
 			
 			bin = next;

data/ext/chipmunk/cpPinJoint.c

@@ -0,0 +1,117 @@
+/* Copyright (c) 2007 Scott Lembcke
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+//#include <math.h>
+
+#include "chipmunk.h"
+#include "constraints/util.h"
+
+static void
+preStep(cpPinJoint *joint, cpFloat dt, cpFloat dt_inv)
+{
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
+	
+	joint->r1 = cpvrotate(joint->anchr1, a->rot);
+	joint->r2 = cpvrotate(joint->anchr2, b->rot);
+	
+	cpVect delta = cpvsub(cpvadd(b->p, joint->r2), cpvadd(a->p, joint->r1));
+	cpFloat dist = cpvlength(delta);
+	joint->n = cpvmult(delta, 1.0f/(dist ? dist : (cpFloat)INFINITY));
+	
+	// calculate mass normal
+	joint->nMass = 1.0f/k_scalar(a, b, joint->r1, joint->r2, joint->n);
+	
+	// calculate bias velocity
+	cpFloat maxBias = joint->constraint.maxBias;
+	joint->bias = cpfclamp(-joint->constraint.biasCoef*dt_inv*(dist - joint->dist), -maxBias, maxBias);
+	
+	// compute max impulse
+	joint->jnMax = J_MAX(joint, dt);
+	
+	// apply accumulated impulse
+	cpVect j = cpvmult(joint->n, joint->jnAcc);
+	apply_impulses(a, b, joint->r1, joint->r2, j);
+}
+
+static void
+applyImpulse(cpPinJoint *joint)
+{
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
+	cpVect n = joint->n;
+
+	// compute relative velocity
+	cpFloat vrn = normal_relative_velocity(a, b, joint->r1, joint->r2, n);
+	
+	// compute normal impulse
+	cpFloat jn = (joint->bias - vrn)*joint->nMass;
+	cpFloat jnOld = joint->jnAcc;
+	joint->jnAcc = cpfclamp(jnOld + jn, -joint->jnMax, joint->jnMax);
+	jn = joint->jnAcc - jnOld;
+	
+	// apply impulse
+	apply_impulses(a, b, joint->r1, joint->r2, cpvmult(n, jn));
+}
+
+static cpFloat
+getImpulse(cpPinJoint *joint)
+{
+	return cpfabs(joint->jnAcc);
+}
+
+static const cpConstraintClass klass = {
+	(cpConstraintPreStepFunction)preStep,
+	(cpConstraintApplyImpulseFunction)applyImpulse,
+	(cpConstraintGetImpulseFunction)getImpulse,
+};
+CP_DefineClassGetter(cpPinJoint);
+
+
+cpPinJoint *
+cpPinJointAlloc(void)
+{
+	return (cpPinJoint *)cpmalloc(sizeof(cpPinJoint));
+}
+
+cpPinJoint *
+cpPinJointInit(cpPinJoint *joint, cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2)
+{
+	cpConstraintInit((cpConstraint *)joint, &klass, a, b);
+	
+	joint->anchr1 = anchr1;
+	joint->anchr2 = anchr2;
+	
+	cpVect p1 = cpvadd(a->p, cpvrotate(anchr1, a->rot));
+	cpVect p2 = cpvadd(b->p, cpvrotate(anchr2, b->rot));
+	joint->dist = cpvlength(cpvsub(p2, p1));
+
+	joint->jnAcc = 0.0f;
+	
+	return joint;
+}
+
+cpConstraint *
+cpPinJointNew(cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2)
+{
+	return (cpConstraint *)cpPinJointInit(cpPinJointAlloc(), a, b, anchr1, anchr2);
+}

data/ext/chipmunk/cpPivotJoint.c

@@ -0,0 +1,114 @@
+/* Copyright (c) 2007 Scott Lembcke
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+
+#include "chipmunk.h"
+#include "constraints/util.h"
+
+static void
+preStep(cpPivotJoint *joint, cpFloat dt, cpFloat dt_inv)
+{
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
+	
+	joint->r1 = cpvrotate(joint->anchr1, a->rot);
+	joint->r2 = cpvrotate(joint->anchr2, b->rot);
+	
+	// Calculate mass tensor
+	k_tensor(a, b, joint->r1, joint->r2, &joint->k1, &joint->k2);
+	
+	// compute max impulse
+	joint->jMaxLen = J_MAX(joint, dt);
+	
+	// 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);
+}
+
+static void
+applyImpulse(cpPivotJoint *joint)
+{
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
+	
+	cpVect r1 = joint->r1;
+	cpVect r2 = joint->r2;
+		
+	// compute relative velocity
+	cpVect vr = relative_velocity(a, b, r1, r2);
+	
+	// compute normal impulse
+	cpVect j = mult_k(cpvsub(joint->bias, vr), joint->k1, joint->k2);
+	cpVect jOld = joint->jAcc;
+	joint->jAcc = cpvclamp(cpvadd(joint->jAcc, j), joint->jMaxLen);
+	j = cpvsub(joint->jAcc, jOld);
+	
+	// apply impulse
+	apply_impulses(a, b, joint->r1, joint->r2, j);
+}
+
+static cpFloat
+getImpulse(cpConstraint *joint)
+{
+	return cpvlength(((cpPivotJoint *)joint)->jAcc);
+}
+
+static const cpConstraintClass klass = {
+	(cpConstraintPreStepFunction)preStep,
+	(cpConstraintApplyImpulseFunction)applyImpulse,
+	(cpConstraintGetImpulseFunction)getImpulse,
+};
+CP_DefineClassGetter(cpPivotJoint)
+
+cpPivotJoint *
+cpPivotJointAlloc(void)
+{
+	return (cpPivotJoint *)cpmalloc(sizeof(cpPivotJoint));
+}
+
+cpPivotJoint *
+cpPivotJointInit(cpPivotJoint *joint, cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2)
+{
+	cpConstraintInit((cpConstraint *)joint, &klass, a, b);
+	
+	joint->anchr1 = anchr1;
+	joint->anchr2 = anchr2;
+	
+	joint->jAcc = cpvzero;
+	
+	return joint;
+}
+
+cpConstraint *
+cpPivotJointNew2(cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2)
+{
+	return (cpConstraint *)cpPivotJointInit(cpPivotJointAlloc(), a, b, anchr1, anchr2);
+}
+
+cpConstraint *
+cpPivotJointNew(cpBody *a, cpBody *b, cpVect pivot)
+{
+	return cpPivotJointNew2(a, b, cpBodyWorld2Local(a, pivot), cpBodyWorld2Local(b, pivot));
+}