chipmunk 4.1.0 → 5.2.0

data/ext/chipmunk/{cpArbiter.h → include/chipmunk/cpArbiter.h}

@@ -18,6 +18,10 @@
  * 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;
@@ -25,7 +29,7 @@ extern cpFloat cp_bias_coef;
 extern cpFloat cp_collision_slop;
 
 // Data structure for contact points.
-typedef struct cpContact{
+typedef struct cpContact {
 	// Contact point and normal.
 	cpVect p, n;
 	// Penetration distance.
@@ -40,46 +44,93 @@ typedef struct cpContact{
 	cpFloat bias;
 	
 	// Hash value used to (mostly) uniquely identify a contact.
-	unsigned int hash;
+	cpHashValue hash;
 } cpContact;
 
 // Contacts are always allocated in groups.
-cpContact* cpContactInit(cpContact *con, cpVect p, cpVect n, cpFloat dist, unsigned int hash);
+cpContact* cpContactInit(cpContact *con, cpVect p, cpVect n, cpFloat dist, cpHashValue hash);
 
 // Sum the contact impulses. (Can be used after cpSpaceStep() returns)
 cpVect cpContactsSumImpulses(cpContact *contacts, int numContacts);
 cpVect cpContactsSumImpulsesWithFriction(cpContact *contacts, int numContacts);
 
+typedef enum cpArbiterState {
+	cpArbiterStateNormal,
+	cpArbiterStateFirstColl,
+	cpArbiterStateIgnore,
+} cpArbiterState;
+
 // Data structure for tracking collisions between shapes.
-typedef struct cpArbiter{
+typedef struct cpArbiter {
 	// Information on the contact points between the objects.
 	int numContacts;
 	cpContact *contacts;
 	
 	// The two shapes involved in the collision.
-	cpShape *a, *b;
+	// These variables are NOT in the order defined by the collision handler.
+	cpShape *private_a, *private_b;
 	
-	// Calculated by cpArbiterPreStep().
+	// Calculated before calling the pre-solve collision handler
+	// Override them with custom values if you want specialized behavior
+	cpFloat e;
 	cpFloat u;
-	cpVect target_v;
+	 // Used for surface_v calculations, implementation may change
+	cpVect surface_vr;
 	
 	// Time stamp of the arbiter. (from cpSpace)
 	int stamp;
+	
+	struct cpCollisionHandler *handler;
+	
+	// Are the shapes swapped in relation to the collision handler?
+	char swappedColl;
+	char state;
 } cpArbiter;
 
-// Basic allocation/destruction functions.
-cpArbiter* cpArbiterAlloc(void);
-cpArbiter* cpArbiterInit(cpArbiter *arb, cpShape *a, cpShape *b, int stamp);
-cpArbiter* cpArbiterNew(cpShape *a, cpShape *b, int stamp);
-
-void cpArbiterDestroy(cpArbiter *arb);
-void cpArbiterFree(cpArbiter *arb);
+// Arbiters are allocated in large buffers by the space and don't require a destroy function
+cpArbiter* 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 cpArbiterInject(cpArbiter *arb, cpContact *contacts, int numContacts);
+void cpArbiterUpdate(cpArbiter *arb, cpContact *contacts, int numContacts, struct cpCollisionHandler *handler, cpShape *a, cpShape *b);
 // Precalculate values used by the solver.
 void cpArbiterPreStep(cpArbiter *arb, cpFloat dt_inv);
 void cpArbiterApplyCachedImpulse(cpArbiter *arb);
 // Run an iteration of the solver on the arbiter.
 void cpArbiterApplyImpulse(cpArbiter *arb, cpFloat eCoef);
+
+// Arbiter Helper Functions
+cpVect cpArbiterTotalImpulse(cpArbiter *arb);
+cpVect cpArbiterTotalImpulseWithFriction(cpArbiter *arb);
+void cpArbiterIgnore(cpArbiter *arb);
+
+
+static inline void
+cpArbiterGetShapes(cpArbiter *arb, cpShape **a, cpShape **b)
+{
+	if(arb->swappedColl){
+		(*a) = arb->private_b, (*b) = arb->private_a;
+	} else {
+		(*a) = arb->private_a, (*b) = arb->private_b;
+	}
+}
+#define CP_ARBITER_GET_SHAPES(arb, a, b) cpShape *a, *b; cpArbiterGetShapes(arb, &a, &b);
+
+static inline int
+cpArbiterIsFirstContact(cpArbiter *arb)
+{
+	return arb->state == cpArbiterStateFirstColl;
+}
+
+static inline cpVect
+cpArbiterGetNormal(cpArbiter *arb, int i)
+{
+	cpVect n = arb->contacts[i].n;
+	return arb->swappedColl ? cpvneg(n) : n;
+}
+
+static inline cpVect
+cpArbiterGetPoint(cpArbiter *arb, int i)
+{
+	return arb->contacts[i].p;
+}

data/ext/chipmunk/{cpArray.h → include/chipmunk/cpArray.h}

@@ -38,7 +38,8 @@ void cpArrayFree(cpArray *arr);
 void cpArrayClear(cpArray *arr);
 
 void cpArrayPush(cpArray *arr, void *object);
-void cpArrayDeleteIndex(cpArray *arr, int index);
+void *cpArrayPop(cpArray *arr);
+void cpArrayDeleteIndex(cpArray *arr, int idx);
 void cpArrayDeleteObj(cpArray *arr, void *obj);
 
 void cpArrayEach(cpArray *arr, cpArrayIter iterFunc, void *data);

data/ext/chipmunk/{cpBB.h → include/chipmunk/cpBB.h}

@@ -49,5 +49,26 @@ cpBBcontainsVect(const cpBB bb, const cpVect v)
 	return (bb.l < v.x && bb.r > v.x && bb.b < v.y && bb.t > v.y);
 }
 
+static inline cpBB
+cpBBmerge(const cpBB a, const cpBB b){
+	return cpBBNew(
+		cpfmin(a.l, b.l),
+		cpfmin(a.b, b.b),
+		cpfmax(a.r, b.r),
+		cpfmax(a.t, b.t)
+	);
+}
+
+static inline cpBB
+cpBBexpand(const cpBB bb, const cpVect v){
+	return cpBBNew(
+		cpfmin(bb.l, v.x),
+		cpfmin(bb.b, v.y),
+		cpfmax(bb.r, v.x),
+		cpfmax(bb.t, v.y)
+	);
+}
+
 cpVect cpBBClampVect(const cpBB bb, const cpVect v); // clamps the vector to lie within the bbox
+// TODO edge case issue
 cpVect cpBBWrapVect(const cpBB bb, const cpVect v); // wrap a vector to a bbox

data/ext/chipmunk/{cpBody.h → include/chipmunk/cpBody.h}

@@ -23,9 +23,11 @@ struct cpBody;
 typedef void (*cpBodyVelocityFunc)(struct cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt);
 typedef void (*cpBodyPositionFunc)(struct cpBody *body, cpFloat dt);
 
+extern cpBodyVelocityFunc cpBodyUpdateVelocityDefault;
+extern cpBodyPositionFunc cpBodyUpdatePositionDefault;
  
 typedef struct cpBody{
-	// *** Integration Functions.
+	// *** Integration Functions.ntoehu
 
 	// Function that is called to integrate the body's velocity. (Defaults to cpBodyUpdateVelocity)
 	cpBodyVelocityFunc velocity_func;
@@ -40,7 +42,7 @@ typedef struct cpBody{
 	cpFloat m, m_inv;
 	
 	// Moment of inertia and it's inverse.
-	// Always use cpBodySetMass() whenever changing the mass as these values must agree.
+	// Always use cpBodySetMoment() whenever changing the moment as these values must agree.
 	cpFloat i, i_inv;
 	
 	// *** Positional Properties
@@ -59,11 +61,14 @@ typedef struct cpBody{
 	// *** User Definable Fields
 	
 	// User defined data pointer.
-	void *data;
+	cpDataPointer data;
+	
+	// Maximum velocities this body can move at after integrating velocity
+	cpFloat v_limit, w_limit;
 	
 	// *** Internally Used Fields
 	
-	// Velocity bias values used when solving penetrations and correcting joints.
+	// Velocity bias values used when solving penetrations and correcting constraints.
 	cpVect v_bias;
 	cpFloat w_bias;
 	
@@ -78,10 +83,32 @@ cpBody *cpBodyNew(cpFloat m, cpFloat i);
 void cpBodyDestroy(cpBody *body);
 void cpBodyFree(cpBody *body);
 
-// Setters for some of the special properties (mandatory!)
+#define CP_DefineBodyGetter(type, member, name) static inline type cpBodyGet##name(cpBody *body){return body->member;}
+#define CP_DefineBodySetter(type, member, name) static inline void cpBodySet##name(cpBody *body, type value){body->member = value;}
+
+#define CP_DefineBodyProperty(type, member, name) \
+CP_DefineBodyGetter(type, member, name) \
+CP_DefineBodySetter(type, member, name)
+
+
+// Accessors for cpBody struct members
+CP_DefineBodyGetter(cpFloat, m, Mass);
 void cpBodySetMass(cpBody *body, cpFloat m);
+
+CP_DefineBodyGetter(cpFloat, i, Moment);
 void cpBodySetMoment(cpBody *body, cpFloat i);
+
+
+CP_DefineBodyProperty(cpVect, p, Pos);
+CP_DefineBodyProperty(cpVect, v, Vel);
+CP_DefineBodyProperty(cpVect, f, Force);
+CP_DefineBodyGetter(cpFloat, a, Angle);
 void cpBodySetAngle(cpBody *body, cpFloat a);
+CP_DefineBodyProperty(cpFloat, w, AngVel);
+CP_DefineBodyProperty(cpFloat, t, Torque);
+CP_DefineBodyGetter(cpVect, rot, Rot);
+CP_DefineBodyProperty(cpFloat, v_limit, VelLimit);
+CP_DefineBodyProperty(cpFloat, w_limit, AngVelLimit);
 
 //  Modify the velocity of the body so that it will move to the specified absolute coordinates in the next timestep.
 // Intended for objects that are moved manually with a custom velocity integration function.
@@ -105,7 +132,7 @@ cpBodyWorld2Local(cpBody *body, cpVect v)
 	return cpvunrotate(cpvsub(v, body->p), body->rot);
 }
 
-// Apply an impulse (in world coordinates) to the body.
+// Apply an impulse (in world coordinates) to the body at a point relative to the center of gravity (also in world coordinates).
 static inline void
 cpBodyApplyImpulse(cpBody *body, cpVect j, cpVect r)
 {
@@ -113,7 +140,7 @@ cpBodyApplyImpulse(cpBody *body, cpVect j, cpVect r)
 	body->w += body->i_inv*cpvcross(r, j);
 }
 
-// Not intended for external use. Used by cpArbiter.c and cpJoint.c.
+// Not intended for external use. Used by cpArbiter.c and cpConstraint.c.
 static inline void
 cpBodyApplyBiasImpulse(cpBody *body, cpVect j, cpVect r)
 {
@@ -123,10 +150,11 @@ cpBodyApplyBiasImpulse(cpBody *body, cpVect j, cpVect r)
 
 // Zero the forces on a body.
 void cpBodyResetForces(cpBody *body);
-// Apply a force (in world coordinates) to a body.
+// Apply a force (in world coordinates) to a body at a point relative to the center of gravity (also in world coordinates).
 void cpBodyApplyForce(cpBody *body, cpVect f, cpVect r);
 
 // Apply a damped spring force between two bodies.
-void cpDampedSpring(cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2, cpFloat rlen, cpFloat k, cpFloat dmp, cpFloat dt);
+// Warning: Large damping values can be unstable. Use a cpDampedSpring constraint for this instead.
+void cpApplyDampedSpring(cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2, cpFloat rlen, cpFloat k, cpFloat dmp, cpFloat dt);
 
 //int cpBodyMarkLowEnergy(cpBody *body, cpFloat dvsq, int max);

data/ext/chipmunk/{cpCollision.h → include/chipmunk/cpCollision.h}

@@ -20,4 +20,4 @@
  */
 
 // Collides two cpShape structures. (this function is lonely :( )
-int cpCollideShapes(cpShape *a, cpShape *b, cpContact **arr);
+int cpCollideShapes(cpShape *a, cpShape *b, cpContact *arr);

data/ext/chipmunk/{cpHashSet.h → include/chipmunk/cpHashSet.h}

@@ -27,7 +27,7 @@ typedef struct cpHashSetBin {
 	// Pointer to the element.
 	void *elt;
 	// Hash value of the element.
-	unsigned int hash;
+	cpHashValue hash;
 	// Next element in the chain.
 	struct cpHashSetBin *next;
 } cpHashSetBin;
@@ -38,8 +38,8 @@ typedef int (*cpHashSetEqlFunc)(void *ptr, void *elt);
 typedef void *(*cpHashSetTransFunc)(void *ptr, void *data);
 // Iterator function for a hashset.
 typedef void (*cpHashSetIterFunc)(void *elt, void *data);
-// Reject function. Returns true if elt should be dropped.
-typedef int (*cpHashSetRejectFunc)(void *elt, void *data);
+// Filter function. Returns false if elt should be dropped.
+typedef int (*cpHashSetFilterFunc)(void *elt, void *data);
 
 typedef struct cpHashSet {
 	// Number of elements stored in the table.
@@ -54,7 +54,10 @@ typedef struct cpHashSet {
 	// Defaults to NULL.
 	void *default_value;
 	
-	cpHashSetBin **table;
+	// The table and recycled bins
+	cpHashSetBin **table, *pooledBins;
+	
+	cpArray *allocatedBuffers;
 } cpHashSet;
 
 // Basic allocation/destruction functions.
@@ -67,13 +70,13 @@ cpHashSet *cpHashSetNew(int size, cpHashSetEqlFunc eqlFunc, cpHashSetTransFunc t
 
 // Insert an element into the set, returns the element.
 // If it doesn't already exist, the transformation function is applied.
-void *cpHashSetInsert(cpHashSet *set, unsigned int hash, void *ptr, void *data);
+void *cpHashSetInsert(cpHashSet *set, cpHashValue hash, void *ptr, void *data);
 // Remove and return an element from the set.
-void *cpHashSetRemove(cpHashSet *set, unsigned int hash, void *ptr);
+void *cpHashSetRemove(cpHashSet *set, cpHashValue hash, void *ptr);
 // Find an element in the set. Returns the default value if the element isn't found.
-void *cpHashSetFind(cpHashSet *set, unsigned int hash, void *ptr);
+void *cpHashSetFind(cpHashSet *set, cpHashValue hash, void *ptr);
 
 // Iterate over a hashset.
 void cpHashSetEach(cpHashSet *set, cpHashSetIterFunc func, void *data);
-// Iterate over a hashset while rejecting certain elements.
-void cpHashSetReject(cpHashSet *set, cpHashSetRejectFunc func, void *data);
+// Iterate over a hashset, retain .
+void cpHashSetFilter(cpHashSet *set, cpHashSetFilterFunc func, void *data);

data/ext/chipmunk/{cpPolyShape.h → include/chipmunk/cpPolyShape.h}

@@ -46,6 +46,17 @@ cpPolyShape *cpPolyShapeAlloc(void);
 cpPolyShape *cpPolyShapeInit(cpPolyShape *poly, cpBody *body, int numVerts, cpVect *verts, cpVect offset);
 cpShape *cpPolyShapeNew(cpBody *body, int numVerts, cpVect *verts, cpVect offset);
 
+cpPolyShape *cpBoxShapeInit(cpPolyShape *poly, cpBody *body, cpFloat width, cpFloat height);
+cpShape *cpBoxShapeNew(cpBody *body, cpFloat width, cpFloat height);
+
+// Check that a set of vertexes has a correct winding and that they are convex
+int cpPolyValidate(cpVect *verts, int numVerts);
+
+int cpPolyShapeGetNumVerts(cpShape *shape);
+cpVect cpPolyShapeGetVert(cpShape *shape, int idx);
+
+// *** inlined utility functions
+
 // Returns the minimum distance of the polygon to the axis.
 static inline cpFloat
 cpPolyShapeValueOnAxis(const cpPolyShape *poly, const cpVect n, const cpFloat d)
@@ -69,7 +80,7 @@ cpPolyShapeContainsVert(cpPolyShape *poly, cpVect v)
 	int i;
 	for(i=0; i<poly->numVerts; i++){
 		cpFloat dist = cpvdot(axes[i].n, v) - axes[i].d;
-		if(dist > 0.0) return 0;
+		if(dist > 0.0f) return 0;
 	}
 	
 	return 1;
@@ -85,7 +96,7 @@ cpPolyShapeContainsVertPartial(cpPolyShape *poly, cpVect v, cpVect n)
 	for(i=0; i<poly->numVerts; i++){
 		if(cpvdot(axes[i].n, n) < 0.0f) continue;
 		cpFloat dist = cpvdot(axes[i].n, v) - axes[i].d;
-		if(dist > 0.0) return 0;
+		if(dist > 0.0f) return 0;
 	}
 	
 	return 1;

data/ext/chipmunk/{cpShape.h → include/chipmunk/cpShape.h}

@@ -18,9 +18,16 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+ 
+// Forward declarations required for defining other structs.
+struct cpShape;
+struct cpShapeClass;
 
-// For determinism, you can reset the shape id counter.
-void cpResetShapeIdCounter(void);
+typedef struct cpSegmentQueryInfo {
+	struct cpShape *shape; // shape that was hit, NULL if no collision
+	cpFloat t; // Distance along query segment, will always be in the range [0, 1].
+	cpVect n; // normal of hit surface
+} cpSegmentQueryInfo;
 
 // Enumeration of shape types.
 typedef enum cpShapeType{
@@ -30,10 +37,6 @@ typedef enum cpShapeType{
 	CP_NUM_SHAPES
 } cpShapeType;
 
-// Forward declarations required for defining the cpShape and cpShapeClass structs.
-struct cpShape;
-struct cpShapeClass;
-
 // Shape class. Holds function pointers and type data.
 typedef struct cpShapeClass {
 	cpShapeType type;
@@ -43,8 +46,11 @@ typedef struct cpShapeClass {
 	// Called to by cpShapeDestroy().
 	void (*destroy)(struct cpShape *shape);
 	
-	// called by cpShapeQueryPointQuery().
+	// called by cpShapePointQuery().
 	int (*pointQuery)(struct cpShape *shape, cpVect p);
+	
+	// called by cpShapeSegmentQuery()
+	 void (*segmentQuery)(struct cpShape *shape, cpVect a, cpVect b, cpSegmentQueryInfo *info);
 } cpShapeClass;
 
 // Basic shape struct that the others inherit from.
@@ -58,6 +64,9 @@ typedef struct cpShape{
 	// Cached BBox for the shape.
 	cpBB bb;
 	
+	// Sensors invoke callbacks, but do not generate collisions
+	int sensor;
+	
 	// *** Surface properties.
 	
 	// Coefficient of restitution. (elasticity)
@@ -70,19 +79,19 @@ typedef struct cpShape{
 	// *** User Definable Fields
 
 	// User defined data pointer for the shape.
-	void *data;
+	cpDataPointer data;
 	
 	// User defined collision type for the shape.
-	unsigned int collision_type;
+	cpCollisionType collision_type;
 	// User defined collision group for the shape.
-	unsigned int group;
+	cpGroup group;
 	// User defined layer bitmask for the shape.
-	unsigned int layers;
+	cpLayers layers;
 	
 	// *** Internally Used Fields
 	
 	// Unique id used as the hash value.
-	unsigned int id;
+	cpHashValue hashid;
 } cpShape;
 
 // Low level shape initialization func.
@@ -98,17 +107,13 @@ cpBB cpShapeCacheBB(cpShape *shape);
 // Test if a point lies within a shape.
 int cpShapePointQuery(cpShape *shape, cpVect p);
 
-// Test if a segment collides with a shape.
-// Returns [0-1] if the segment collides and -1 otherwise.
-// 0 would be a collision at point a, 1 would be a collision at point b.
-//cpFloat cpShapeSegmentQuery(cpShape *shape, cpVect a, cpVect b);
-
+#define CP_DeclareShapeGetter(struct, type, name) type struct##Get##name(cpShape *shape)
 
 // Circle shape structure.
 typedef struct cpCircleShape{
 	cpShape shape;
 	
-	// Center. (body space coordinates)
+	// Center in body space coordinates
 	cpVect c;
 	// Radius.
 	cpFloat r;
@@ -122,6 +127,9 @@ cpCircleShape *cpCircleShapeAlloc(void);
 cpCircleShape *cpCircleShapeInit(cpCircleShape *circle, cpBody *body, cpFloat radius, cpVect offset);
 cpShape *cpCircleShapeNew(cpBody *body, cpFloat radius, cpVect offset);
 
+CP_DeclareShapeGetter(cpCircleShape, cpVect, Offset);
+CP_DeclareShapeGetter(cpCircleShape, cpFloat, Radius);
+
 // Segment shape structure.
 typedef struct cpSegmentShape{
 	cpShape shape;
@@ -139,3 +147,28 @@ typedef struct cpSegmentShape{
 cpSegmentShape* cpSegmentShapeAlloc(void);
 cpSegmentShape* cpSegmentShapeInit(cpSegmentShape *seg, cpBody *body, cpVect a, cpVect b, cpFloat radius);
 cpShape* cpSegmentShapeNew(cpBody *body, cpVect a, cpVect b, cpFloat radius);
+
+CP_DeclareShapeGetter(cpSegmentShape, cpVect, A);
+CP_DeclareShapeGetter(cpSegmentShape, cpVect, B);
+CP_DeclareShapeGetter(cpSegmentShape, cpVect, Normal);
+CP_DeclareShapeGetter(cpSegmentShape, cpFloat, Radius);
+
+// For determinism, you can reset the shape id counter.
+void cpResetShapeIdCounter(void);
+
+// Directed segment queries against individual shapes.
+void cpSegmentQueryInfoPrint(cpSegmentQueryInfo *info);
+
+int cpShapeSegmentQuery(cpShape *shape, cpVect a, cpVect b, cpSegmentQueryInfo *info);
+
+static inline cpVect
+cpSegmentQueryHitPoint(cpVect start, cpVect end, cpSegmentQueryInfo info)
+{
+	return cpvlerp(start, end, info.t);
+}
+
+static inline cpFloat
+cpSegmentQueryHitDist(cpVect start, cpVect end, cpSegmentQueryInfo info)
+{
+	return cpvdist(start, end)*info.t;
+}