chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/cpArbiter.h

@@ -18,101 +18,128 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
- 
- struct cpArbiter;
- struct cpSpace;
- struct cpCollisionHandler;
-
-// Determines how fast penetrations resolve themselves.
-extern cpFloat cp_bias_coef;
-// Amount of allowed penetration. Used to reduce vibrating contacts.
-extern cpFloat cp_collision_slop;
-
-// Data structure for contact points.
-typedef struct cpContact {
-	// Contact point and normal.
-	cpVect CP_PRIVATE(p), CP_PRIVATE(n);
-	// Penetration distance.
-	CP_PRIVATE(cpFloat dist);
-	
-	// Calculated by cpArbiterPreStep().
-	cpVect CP_PRIVATE(r1), CP_PRIVATE(r2);
-	cpFloat CP_PRIVATE(nMass), CP_PRIVATE(tMass), CP_PRIVATE(bounce);
-
-	// Persistant contact information.
-	cpFloat CP_PRIVATE(jnAcc), CP_PRIVATE(jtAcc), CP_PRIVATE(jBias);
-	CP_PRIVATE(cpFloat bias);
-	
-	// Hash value used to (mostly) uniquely identify a contact.
-	CP_PRIVATE(cpHashValue hash);
-} cpContact;
-
-// Contacts are always allocated in groups.
-cpContact* cpContactInit(cpContact *con, cpVect p, cpVect n, cpFloat dist, cpHashValue hash);
-
-// Sum the contact impulses. (Can be used after cpSpaceStep() returns)
-cpVect CP_PRIVATE(cpContactsSumImpulses)(cpContact *contacts, int numContacts);
-cpVect CP_PRIVATE(cpContactsSumImpulsesWithFriction)(cpContact *contacts, int numContacts);
-
-#define CP_MAX_CONTACTS_PER_ARBITER 6
 
+/// @defgroup cpArbiter cpArbiter
+/// The cpArbiter struct controls pairs of colliding shapes.
+/// They are also used in conjuction with collision handler callbacks
+/// allowing you to retrieve information on the collision and control it.
+/// @{
+
+/// Collision begin event function callback type.
+/// Returning false from a begin callback causes the collision to be ignored until
+/// the the separate callback is called when the objects stop colliding.
+typedef cpBool (*cpCollisionBeginFunc)(cpArbiter *arb, cpSpace *space, void *data);
+/// Collision pre-solve event function callback type.
+/// Returning false from a pre-step callback causes the collision to be ignored until the next step.
+typedef cpBool (*cpCollisionPreSolveFunc)(cpArbiter *arb, cpSpace *space, void *data);
+/// Collision post-solve event function callback type.
+typedef void (*cpCollisionPostSolveFunc)(cpArbiter *arb, cpSpace *space, void *data);
+/// Collision separate event function callback type.
+typedef void (*cpCollisionSeparateFunc)(cpArbiter *arb, cpSpace *space, void *data);
+
+/// @private
+struct cpCollisionHandler {
+	cpCollisionType a;
+	cpCollisionType b;
+	cpCollisionBeginFunc begin;
+	cpCollisionPreSolveFunc preSolve;
+	cpCollisionPostSolveFunc postSolve;
+	cpCollisionSeparateFunc separate;
+	void *data;
+};
+
+typedef struct cpContact cpContact;
+
+#define CP_MAX_CONTACTS_PER_ARBITER 4
+
+/// @private
 typedef enum cpArbiterState {
-	cpArbiterStateNormal,
+	// Arbiter is active and its the first collision.
 	cpArbiterStateFirstColl,
+	// Arbiter is active and its not the first collision.
+	cpArbiterStateNormal,
+	// Collision has been explicitly ignored.
+	// Either by returning false from a begin collision handler or calling cpArbiterIgnore().
 	cpArbiterStateIgnore,
-	cpArbiterStateSleep,
+	// Collison is no longer active. A space will cache an arbiter for up to cpSpace.collisionPersistence more steps.
 	cpArbiterStateCached,
 } cpArbiterState;
 
-// Data structure for tracking collisions between shapes.
-typedef struct cpArbiter {
-	// Information on the contact points between the objects.
-	CP_PRIVATE(int numContacts);
-	CP_PRIVATE(cpContact *contacts);
+/// @private
+struct cpArbiterThread {
+	// Links to next and previous arbiters in the contact graph.
+	struct cpArbiter *next, *prev;
+};
+
+/// A colliding pair of shapes.
+struct cpArbiter {
+	/// Calculated value to use for the elasticity coefficient.
+	/// Override in a pre-solve collision handler for custom behavior.
+	cpFloat e;
+	/// Calculated value to use for the friction coefficient.
+	/// Override in a pre-solve collision handler for custom behavior.
+	cpFloat u;
+	 /// Calculated value to use for applying surface velocities.
+	/// Override in a pre-solve collision handler for custom behavior.
+	cpVect surface_vr;
 	
-	// The two shapes and bodies involved in the collision.
-	// These variables are NOT in the order defined by the collision handler.
-	// Using CP_ARBITER_GET_SHAPES and CP_ARBITER_GET_BODIES will save you from
-	// many headaches
-	cpShape CP_PRIVATE(*a), CP_PRIVATE(*b);
+	/// User definable data pointer.
+	/// The value will persist for the pair of shapes until the separate() callback is called.
+	/// NOTE: If you need to clean up this pointer, you should implement the separate() callback to do it.
+	cpDataPointer data;
 	
-	// Calculated before calling the pre-solve collision handler
-	// Override them with custom values if you want specialized behavior
-	CP_PRIVATE(cpFloat e);
-	CP_PRIVATE(cpFloat u);
-	 // Used for surface_v calculations, implementation may change
-	CP_PRIVATE(cpVect surface_vr);
+	CP_PRIVATE(cpShape *a);
+	CP_PRIVATE(cpShape *b);
+	CP_PRIVATE(cpBody *body_a);
+	CP_PRIVATE(cpBody *body_b);
 	
-	// Time stamp of the arbiter. (from cpSpace)
-	CP_PRIVATE(cpTimestamp stamp);
+	CP_PRIVATE(struct cpArbiterThread thread_a);
+	CP_PRIVATE(struct cpArbiterThread thread_b);
 	
-	CP_PRIVATE(struct cpCollisionHandler *handler);
+	CP_PRIVATE(int numContacts);
+	CP_PRIVATE(cpContact *contacts);
 	
-	// Are the shapes swapped in relation to the collision handler?
+	CP_PRIVATE(cpTimestamp stamp);
+	CP_PRIVATE(cpCollisionHandler *handler);
 	CP_PRIVATE(cpBool swappedColl);
 	CP_PRIVATE(cpArbiterState state);
-} cpArbiter;
-
-// Arbiters are allocated in large buffers by the space and don't require a destroy function
-cpArbiter* CP_PRIVATE(cpArbiterInit)(cpArbiter *arb, cpShape *a, cpShape *b);
-
-// These functions are all intended to be used internally.
-// Inject new contact points into the arbiter while preserving contact history.
-void CP_PRIVATE(cpArbiterUpdate)(cpArbiter *arb, cpContact *contacts, int numContacts, struct cpCollisionHandler *handler, cpShape *a, cpShape *b);
-// Precalculate values used by the solver.
-void CP_PRIVATE(cpArbiterPreStep)(cpArbiter *arb, cpFloat dt_inv);
-void CP_PRIVATE(cpArbiterApplyCachedImpulse)(cpArbiter *arb);
-// Run an iteration of the solver on the arbiter.
-void CP_PRIVATE(cpArbiterApplyImpulse)(cpArbiter *arb, cpFloat eCoef);
-
-// Arbiter Helper Functions
-cpVect cpArbiterTotalImpulse(cpArbiter *arb);
-cpVect cpArbiterTotalImpulseWithFriction(cpArbiter *arb);
-void cpArbiterIgnore(cpArbiter *arb);
+};
+
+#define CP_DefineArbiterStructGetter(type, member, name) \
+static inline type cpArbiterGet##name(const cpArbiter *arb){return arb->member;}
+
+#define CP_DefineArbiterStructSetter(type, member, name) \
+static inline void cpArbiterSet##name(cpArbiter *arb, type value){arb->member = value;}
 
+#define CP_DefineArbiterStructProperty(type, member, name) \
+CP_DefineArbiterStructGetter(type, member, name) \
+CP_DefineArbiterStructSetter(type, member, name)
+
+CP_DefineArbiterStructProperty(cpFloat, e, Elasticity)
+CP_DefineArbiterStructProperty(cpFloat, u, Friction)
+CP_DefineArbiterStructProperty(cpVect, surface_vr, SurfaceVelocity)
+CP_DefineArbiterStructProperty(cpDataPointer, data, UserData)
+
+/// Calculate the total impulse that was applied by this arbiter.
+/// This function should only be called from a post-solve, post-step or cpBodyEachArbiter callback.
+cpVect cpArbiterTotalImpulse(const cpArbiter *arb);
+/// Calculate the total impulse including the friction that was applied by this arbiter.
+/// This function should only be called from a post-solve, post-step or cpBodyEachArbiter callback.
+cpVect cpArbiterTotalImpulseWithFriction(const cpArbiter *arb);
+/// Calculate the amount of energy lost in a collision including static, but not dynamic friction.
+/// This function should only be called from a post-solve, post-step or cpBodyEachArbiter callback.
+cpFloat cpArbiterTotalKE(const cpArbiter *arb);
+
+
+/// Causes a collision pair to be ignored as if you returned false from a begin callback.
+/// If called from a pre-step callback, you will still need to return false
+/// if you want it to be ignored in the current step.
+void cpArbiterIgnore(cpArbiter *arb);
 
-static inline void
-cpArbiterGetShapes(const cpArbiter *arb, cpShape **a, cpShape **b)
+/// Return the colliding shapes involved for this arbiter.
+/// The order of their cpSpace.collision_type values will match
+/// the order set when the collision handler was registered.
+static inline void cpArbiterGetShapes(const cpArbiter *arb, cpShape **a, cpShape **b)
 {
 	if(arb->CP_PRIVATE(swappedColl)){
 		(*a) = arb->CP_PRIVATE(b), (*b) = arb->CP_PRIVATE(a);
@@ -120,69 +147,48 @@ cpArbiterGetShapes(const cpArbiter *arb, cpShape **a, cpShape **b)
 		(*a) = arb->CP_PRIVATE(a), (*b) = arb->CP_PRIVATE(b);
 	}
 }
+/// A macro shortcut for defining and retrieving the shapes from an arbiter.
 #define CP_ARBITER_GET_SHAPES(arb, a, b) cpShape *a, *b; cpArbiterGetShapes(arb, &a, &b);
 
-static inline void
-cpArbiterGetBodies(const cpArbiter *arb, cpBody **a, cpBody **b)
+/// Return the colliding bodies involved for this arbiter.
+/// The order of the cpSpace.collision_type the bodies are associated with values will match
+/// the order set when the collision handler was registered.
+static inline void cpArbiterGetBodies(const cpArbiter *arb, cpBody **a, cpBody **b)
 {
 	CP_ARBITER_GET_SHAPES(arb, shape_a, shape_b);
 	(*a) = shape_a->body;
 	(*b) = shape_b->body;
 }
+/// A macro shortcut for defining and retrieving the bodies from an arbiter.
 #define CP_ARBITER_GET_BODIES(arb, a, b) cpBody *a, *b; cpArbiterGetBodies(arb, &a, &b);
 
-static inline cpBool
-cpArbiterIsFirstContact(const cpArbiter *arb)
-{
-	return arb->CP_PRIVATE(state) == cpArbiterStateFirstColl;
-}
-
-static inline int
-cpArbiterGetCount(const cpArbiter *arb)
-{
-	return arb->CP_PRIVATE(numContacts);
-}
-
-static inline cpVect
-cpArbiterGetNormal(const cpArbiter *arb, int i)
-{
-	cpVect n = arb->CP_PRIVATE(contacts)[i].CP_PRIVATE(n);
-	return arb->CP_PRIVATE(swappedColl) ? cpvneg(n) : n;
-}
-
-static inline cpVect
-cpArbiterGetPoint(const cpArbiter *arb, int i)
-{
-	return arb->CP_PRIVATE(contacts)[i].CP_PRIVATE(p);
-}
-
-static inline cpFloat
-cpArbiteGetDepth(const cpArbiter *arb, int i)
-{
-	return arb->CP_PRIVATE(contacts)[i].CP_PRIVATE(dist);
-}
-
+/// A struct that wraps up the important collision data for an arbiter.
 typedef struct cpContactPointSet {
+	/// The number of contact points in the set.
 	int count;
 	
+	/// The array of contact points.
 	struct {
-		cpVect point, normal;
+		/// The position of the contact point.
+		cpVect point;
+		/// The normal of the contact point.
+		cpVect normal;
+		/// The depth of the contact point.
 		cpFloat dist;
 	} points[CP_MAX_CONTACTS_PER_ARBITER];
 } cpContactPointSet;
-
-static inline cpContactPointSet
-cpArbiterGetContactPointSet(const cpArbiter *arb)
-{
-	cpContactPointSet set;
-	set.count = cpArbiterGetCount(arb);
-	
-	int i;
-	for(i=0; i<set.count; i++){
-		set.points[i].point = arb->CP_PRIVATE(contacts)[i].CP_PRIVATE(p);
-		set.points[i].normal = arb->CP_PRIVATE(contacts)[i].CP_PRIVATE(n);
-		set.points[i].dist = arb->CP_PRIVATE(contacts)[i].CP_PRIVATE(dist);
-	}
-	
-	return set;
-}
+/// Return a contact set from an arbiter.
+cpContactPointSet cpArbiterGetContactPointSet(const cpArbiter *arb);
+
+/// Returns true if this is the first step a pair of objects started colliding.
+cpBool cpArbiterIsFirstContact(const cpArbiter *arb);
+/// Get the number of contact points for this arbiter.
+int cpArbiterGetCount(const cpArbiter *arb);
+/// Get the normal of the @c ith contact point.
+cpVect cpArbiterGetNormal(const cpArbiter *arb, int i);
+/// Get the position of the @c ith contact point.
+cpVect cpArbiterGetPoint(const cpArbiter *arb, int i);
+/// Get the depth of the @c ith contact point.
+cpFloat cpArbiterGetDepth(const cpArbiter *arb, int i);
+
+/// @}

data/ext/chipmunk/cpArray.c

@@ -19,52 +19,30 @@
  * SOFTWARE.
  */
  
-#include <stdlib.h>
 #include <string.h>
 
 #include "chipmunk_private.h"
 
 
-//#define CP_ARRAY_INCREMENT 10
-
-// NOTE: cpArray is rarely used and will probably go away.
-
-cpArray*
-cpArrayAlloc(void)
-{
-	return (cpArray *)cpcalloc(1, sizeof(cpArray));
-}
-
-cpArray*
-cpArrayInit(cpArray *arr, int size)
+cpArray *
+cpArrayNew(int size)
 {
-	arr->num = 0;
+	cpArray *arr = (cpArray *)cpcalloc(1, sizeof(cpArray));
 	
-	size = (size ? size : 4);
-	arr->max = size;
-	arr->arr = (void **)cpmalloc(size*sizeof(void**));
+	arr->num = 0;
+	arr->max = (size ? size : 4);
+	arr->arr = (void **)cpcalloc(arr->max, sizeof(void**));
 	
 	return arr;
 }
 
-cpArray*
-cpArrayNew(int size)
-{
-	return cpArrayInit(cpArrayAlloc(), size);
-}
-
-void
-cpArrayDestroy(cpArray *arr)
-{
-	cpfree(arr->arr);
-	arr->arr = NULL;
-}
-
 void
 cpArrayFree(cpArray *arr)
 {
 	if(arr){
-		cpArrayDestroy(arr);
+		cpfree(arr->arr);
+		arr->arr = NULL;
+		
 		cpfree(arr);
 	}
 }
@@ -92,45 +70,48 @@ cpArrayPop(cpArray *arr)
 	return value;
 }
 
-void
-cpArrayDeleteIndex(cpArray *arr, int idx)
-{
-	arr->num--;
-	
-	arr->arr[idx] = arr->arr[arr->num];
-	arr->arr[arr->num] = NULL;
-}
+//static void
+//cpArrayDeleteIndex(cpArray *arr, int idx)
+//{
+//	arr->num--;
+//	
+//	arr->arr[idx] = arr->arr[arr->num];
+//	arr->arr[arr->num] = NULL;
+//}
 
 void
 cpArrayDeleteObj(cpArray *arr, void *obj)
 {
 	for(int i=0; i<arr->num; i++){
 		if(arr->arr[i] == obj){
-			cpArrayDeleteIndex(arr, i);
+			arr->num--;
+			
+			arr->arr[i] = arr->arr[arr->num];
+			arr->arr[arr->num] = NULL;
+			
 			return;
 		}
 	}
 }
 
-void
-cpArrayAppend(cpArray *arr, cpArray *other)
-{
-	void *tail = &arr->arr[arr->num];
-	
-	arr->num += other->num;
-	if(arr->num >= arr->max){
-		arr->max = arr->num;
-		arr->arr = (void **)cprealloc(arr->arr, arr->max*sizeof(void**));
-	}
-	
-	memcpy(tail, other->arr, other->num*sizeof(void**));
-}
+//void
+//cpArrayAppend(cpArray *arr, cpArray *other)
+//{
+//	void *tail = &arr->arr[arr->num];
+//	
+//	arr->num += other->num;
+//	if(arr->num >= arr->max){
+//		arr->max = arr->num;
+//		arr->arr = (void **)cprealloc(arr->arr, arr->max*sizeof(void**));
+//	}
+//	
+//	memcpy(tail, other->arr, other->num*sizeof(void**));
+//}
 
 void
-cpArrayEach(cpArray *arr, cpArrayIter iterFunc, void *data)
+cpArrayFreeEach(cpArray *arr, void (freeFunc)(void*))
 {
-	for(int i=0; i<arr->num; i++)
-		iterFunc(arr->arr[i], data);
+	for(int i=0; i<arr->num; i++) freeFunc(arr->arr[i]);
 }
 
 cpBool

data/ext/chipmunk/cpBB.c

@@ -19,18 +19,7 @@
  * SOFTWARE.
  */
  
-#include <math.h>
-#include <stdlib.h>
-
-#include "chipmunk.h"
-
-cpVect
-cpBBClampVect(const cpBB bb, const cpVect v)
-{
-	cpFloat x = cpfmin(cpfmax(bb.l, v.x), bb.r);
-	cpFloat y = cpfmin(cpfmax(bb.b, v.y), bb.t);
-	return cpv(x, y);
-}
+#include "chipmunk_private.h"
 
 cpVect
 cpBBWrapVect(const cpBB bb, const cpVect v)