chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/cpShape.h

@@ -19,17 +19,33 @@
  * SOFTWARE.
  */
  
-// Forward declarations required for defining other structs.
-struct cpShape;
-struct cpShapeClass;
-
+/// @defgroup cpShape cpShape
+/// The cpShape struct defines the shape of a rigid body.
+/// @{
+
+typedef struct cpShapeClass cpShapeClass;
+
+/// Nearest point query info struct.
+typedef struct cpNearestPointQueryInfo {
+	/// The nearest shape, NULL if no shape was within range.
+	cpShape *shape;
+	/// The closest point on the shape's surface. (in world space coordinates)
+	cpVect p;
+	/// The distance to the point. The distance is negative if the point is inside the shape.
+	cpFloat d;
+} cpNearestPointQueryInfo;
+
+/// Segment query info struct.
 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
+	/// The shape that was hit, NULL if no collision occured.
+	cpShape *shape;
+	/// The normalized distance along the query segment in the range [0, 1].
+	cpFloat t;
+	/// The normal of the surface hit.
+	cpVect n;
 } cpSegmentQueryInfo;
 
-// Enumeration of shape types.
+/// @private
 typedef enum cpShapeType{
 	CP_CIRCLE_SHAPE,
 	CP_SEGMENT_SHAPE,
@@ -37,141 +53,176 @@ typedef enum cpShapeType{
 	CP_NUM_SHAPES
 } cpShapeType;
 
-// Shape class. Holds function pointers and type data.
-typedef struct cpShapeClass {
+typedef cpBB (*cpShapeCacheDataImpl)(cpShape *shape, cpVect p, cpVect rot);
+typedef void (*cpShapeDestroyImpl)(cpShape *shape);
+typedef void (*cpShapeNearestPointQueryImpl)(cpShape *shape, cpVect p, cpNearestPointQueryInfo *info);
+typedef void (*cpShapeSegmentQueryImpl)(cpShape *shape, cpVect a, cpVect b, cpSegmentQueryInfo *info);
+
+/// @private
+struct cpShapeClass {
 	cpShapeType type;
 	
-	// Called by cpShapeCacheBB().
-	cpBB (*cacheData)(struct cpShape *shape, cpVect p, cpVect rot);
-	// Called to by cpShapeDestroy().
-	void (*destroy)(struct cpShape *shape);
-	
-	// called by cpShapePointQuery().
-	cpBool (*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.
-typedef struct cpShape{
-	// The "class" of a shape as defined above 
+	cpShapeCacheDataImpl cacheData;
+	cpShapeDestroyImpl destroy;
+	cpShapeNearestPointQueryImpl nearestPointQuery;
+	cpShapeSegmentQueryImpl segmentQuery;
+};
+
+/// Opaque collision shape struct.
+struct cpShape {
 	CP_PRIVATE(const cpShapeClass *klass);
 	
-	// cpBody that the shape is attached to.
+	/// The rigid body this collision shape is attached to.
 	cpBody *body;
 
-	// Cached BBox for the shape.
+	/// The current bounding box of the shape.
 	cpBB bb;
 	
-	// Sensors invoke callbacks, but do not generate collisions
+	/// Sensor flag.
+	/// Sensor shapes call collision callbacks but don't produce collisions.
 	cpBool sensor;
 	
-	// *** Surface properties.
-	
-	// Coefficient of restitution. (elasticity)
+	/// Coefficient of restitution. (elasticity)
 	cpFloat e;
-	// Coefficient of friction.
+	/// Coefficient of friction.
 	cpFloat u;
-	// Surface velocity used when solving for friction.
+	/// Surface velocity used when solving for friction.
 	cpVect surface_v;
 
-	// *** User Definable Fields
-
-	// User defined data pointer for the shape.
+	/// User definable data pointer.
+	/// Generally this points to your the game object class so you can access it
+	/// when given a cpShape reference in a callback.
 	cpDataPointer data;
 	
-	// User defined collision type for the shape.
+	/// Collision type of this shape used when picking collision handlers.
 	cpCollisionType collision_type;
-	// User defined collision group for the shape.
+	/// Group of this shape. Shapes in the same group don't collide.
 	cpGroup group;
-	// User defined layer bitmask for the shape.
+	// Layer bitmask for this shape. Shapes only collide if the bitwise and of their layers is non-zero.
 	cpLayers layers;
 	
-	// *** Internally Used Fields
+	CP_PRIVATE(cpSpace *space);
 	
-	// Shapes form a linked list when added to space on a non-NULL body
-	CP_PRIVATE(struct cpShape *next);
+	CP_PRIVATE(cpShape *next);
+	CP_PRIVATE(cpShape *prev);
 	
-	// Unique id used as the hash value.
 	CP_PRIVATE(cpHashValue hashid);
-} cpShape;
-
-// Low level shape initialization func.
-cpShape* cpShapeInit(cpShape *shape, const struct cpShapeClass *klass, cpBody *body);
+};
 
-// Basic destructor functions. (allocation functions are not shared)
+/// Destroy a shape.
 void cpShapeDestroy(cpShape *shape);
+/// Destroy and Free a shape.
 void cpShapeFree(cpShape *shape);
 
-// Cache the BBox of the shape.
+/// Update, cache and return the bounding box of a shape based on the body it's attached to.
 cpBB cpShapeCacheBB(cpShape *shape);
+/// Update, cache and return the bounding box of a shape with an explicit transformation.
+cpBB cpShapeUpdate(cpShape *shape, cpVect pos, cpVect rot);
 
-// Test if a point lies within a shape.
+/// Test if a point lies within a shape.
 cpBool cpShapePointQuery(cpShape *shape, cpVect p);
 
-#define CP_DeclareShapeGetter(struct, type, name) type struct##Get##name(cpShape *shape)
+/// Perform a nearest point query. It finds the closest point on the surface of shape to a specific point.
+/// The value returned is the distance between the points. A negative distance means the point is inside the shape.
+cpFloat cpShapeNearestPointQuery(cpShape *shape, cpVect p, cpNearestPointQueryInfo *out);
 
-// Circle shape structure.
-typedef struct cpCircleShape{
-	CP_PRIVATE(cpShape shape);
-	
-	// Center in body space coordinates
-	CP_PRIVATE(cpVect c);
-	// Radius.
-	CP_PRIVATE(cpFloat r);
+/// Perform a segment query against a shape. @c info must be a pointer to a valid cpSegmentQueryInfo structure.
+cpBool cpShapeSegmentQuery(cpShape *shape, cpVect a, cpVect b, cpSegmentQueryInfo *info);
+
+/// Get the hit point for a segment query.
+static inline cpVect cpSegmentQueryHitPoint(const cpVect start, const cpVect end, const cpSegmentQueryInfo info)
+{
+	return cpvlerp(start, end, info.t);
+}
+
+/// Get the hit distance for a segment query.
+static inline cpFloat cpSegmentQueryHitDist(const cpVect start, const cpVect end, const cpSegmentQueryInfo info)
+{
+	return cpvdist(start, end)*info.t;
+}
+
+#define CP_DefineShapeStructGetter(type, member, name) \
+static inline type cpShapeGet##name(const cpShape *shape){return shape->member;}
+
+#define CP_DefineShapeStructSetter(type, member, name, activates) \
+static inline void cpShapeSet##name(cpShape *shape, type value){ \
+	if(activates && shape->body) cpBodyActivate(shape->body); \
+	shape->member = value; \
+}
+
+#define CP_DefineShapeStructProperty(type, member, name, activates) \
+CP_DefineShapeStructGetter(type, member, name) \
+CP_DefineShapeStructSetter(type, member, name, activates)
+
+CP_DefineShapeStructGetter(cpSpace*, CP_PRIVATE(space), Space)
+
+CP_DefineShapeStructGetter(cpBody*, body, Body)
+void cpShapeSetBody(cpShape *shape, cpBody *body);
+
+CP_DefineShapeStructGetter(cpBB, bb, BB)
+CP_DefineShapeStructProperty(cpBool, sensor, Sensor, cpTrue)
+CP_DefineShapeStructProperty(cpFloat, e, Elasticity, cpFalse)
+CP_DefineShapeStructProperty(cpFloat, u, Friction, cpTrue)
+CP_DefineShapeStructProperty(cpVect, surface_v, SurfaceVelocity, cpTrue)
+CP_DefineShapeStructProperty(cpDataPointer, data, UserData, cpFalse)
+CP_DefineShapeStructProperty(cpCollisionType, collision_type, CollisionType, cpTrue)
+CP_DefineShapeStructProperty(cpGroup, group, Group, cpTrue)
+CP_DefineShapeStructProperty(cpLayers, layers, Layers, cpTrue)
+
+/// When initializing a shape, it's hash value comes from a counter.
+/// Because the hash value may affect iteration order, you can reset the shape ID counter
+/// when recreating a space. This will make the simulation be deterministic.
+void cpResetShapeIdCounter(void);
+
+#define CP_DeclareShapeGetter(struct, type, name) type struct##Get##name(const cpShape *shape)
+
+/// @}
+/// @defgroup cpCircleShape cpCircleShape
+
+/// @private
+typedef struct cpCircleShape {
+	cpShape shape;
 	
-	// Transformed center. (world space coordinates)
-	CP_PRIVATE(cpVect tc);
+	cpVect c, tc;
+	cpFloat r;
 } cpCircleShape;
 
-// Basic allocation functions for cpCircleShape.
-cpCircleShape *cpCircleShapeAlloc(void);
-cpCircleShape *cpCircleShapeInit(cpCircleShape *circle, cpBody *body, cpFloat radius, cpVect offset);
-cpShape *cpCircleShapeNew(cpBody *body, cpFloat radius, cpVect offset);
+/// Allocate a circle shape.
+cpCircleShape* cpCircleShapeAlloc(void);
+/// Initialize a circle shape.
+cpCircleShape* cpCircleShapeInit(cpCircleShape *circle, cpBody *body, cpFloat radius, cpVect offset);
+/// Allocate and initialize a circle shape.
+cpShape* cpCircleShapeNew(cpBody *body, cpFloat radius, cpVect offset);
 
 CP_DeclareShapeGetter(cpCircleShape, cpVect, Offset);
 CP_DeclareShapeGetter(cpCircleShape, cpFloat, Radius);
 
-// Segment shape structure.
-typedef struct cpSegmentShape{
-	CP_PRIVATE(cpShape shape);
-	
-	// Endpoints and normal of the segment. (body space coordinates)
-	cpVect CP_PRIVATE(a), CP_PRIVATE(b), CP_PRIVATE(n);
-	// Radius of the segment. (Thickness)
-	cpFloat CP_PRIVATE(r);
+/// @}
+/// @defgroup cpSegmentShape cpSegmentShape
 
-	// Transformed endpoints and normal. (world space coordinates)
-	cpVect CP_PRIVATE(ta), CP_PRIVATE(tb), CP_PRIVATE(tn);
+/// @private
+typedef struct cpSegmentShape {
+	cpShape shape;
+	
+	cpVect a, b, n;
+	cpVect ta, tb, tn;
+	cpFloat r;
+	
+	cpVect a_tangent, b_tangent;
 } cpSegmentShape;
 
-// Basic allocation functions for cpSegmentShape.
+/// Allocate a segment shape.
 cpSegmentShape* cpSegmentShapeAlloc(void);
+/// Initialize a segment shape.
 cpSegmentShape* cpSegmentShapeInit(cpSegmentShape *seg, cpBody *body, cpVect a, cpVect b, cpFloat radius);
+/// Allocate and initialize a segment shape.
 cpShape* cpSegmentShapeNew(cpBody *body, cpVect a, cpVect b, cpFloat radius);
 
+void cpSegmentShapeSetNeighbors(cpShape *shape, cpVect prev, cpVect next);
+
 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);
-
-cpBool cpShapeSegmentQuery(cpShape *shape, cpVect a, cpVect b, cpSegmentQueryInfo *info);
-
-static inline cpVect
-cpSegmentQueryHitPoint(const cpVect start, const cpVect end, const cpSegmentQueryInfo info)
-{
-	return cpvlerp(start, end, info.t);
-}
-
-static inline cpFloat
-cpSegmentQueryHitDist(const cpVect start, const cpVect end, const cpSegmentQueryInfo info)
-{
-	return cpvdist(start, end)*info.t;
-}
+/// @}

data/ext/chipmunk/cpSimpleMotor.c

@@ -19,39 +19,45 @@
  * SOFTWARE.
  */
 
-#include <stdlib.h>
-
 #include "chipmunk_private.h"
 #include "constraints/util.h"
 
 static void
-preStep(cpSimpleMotor *joint, cpFloat dt, cpFloat dt_inv)
+preStep(cpSimpleMotor *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 + b->i_inv);
-	
-	// compute max impulse
-	joint->jMax = J_MAX(joint, dt);
+}
 
-	// apply joint torque
-	a->w -= joint->jAcc*a->i_inv;
-	b->w += joint->jAcc*b->i_inv;
+static void
+applyCachedImpulse(cpSimpleMotor *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;
+	b->w += j*b->i_inv;
 }
 
 static void
-applyImpulse(cpSimpleMotor *joint)
+applyImpulse(cpSimpleMotor *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 - a->w + joint->rate;
 	
+	cpFloat jMax = joint->constraint.maxForce*dt;
+	
 	// compute normal impulse	
 	cpFloat j = -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
@@ -66,16 +72,17 @@ getImpulse(cpSimpleMotor *joint)
 }
 
 static const cpConstraintClass klass = {
-	(cpConstraintPreStepFunction)preStep,
-	(cpConstraintApplyImpulseFunction)applyImpulse,
-	(cpConstraintGetImpulseFunction)getImpulse,
+	(cpConstraintPreStepImpl)preStep,
+	(cpConstraintApplyCachedImpulseImpl)applyCachedImpulse,
+	(cpConstraintApplyImpulseImpl)applyImpulse,
+	(cpConstraintGetImpulseImpl)getImpulse,
 };
 CP_DefineClassGetter(cpSimpleMotor)
 
 cpSimpleMotor *
 cpSimpleMotorAlloc(void)
 {
-	return (cpSimpleMotor *)cpmalloc(sizeof(cpSimpleMotor));
+	return (cpSimpleMotor *)cpcalloc(1, sizeof(cpSimpleMotor));
 }
 
 cpSimpleMotor *

data/ext/chipmunk/cpSlideJoint.c

@@ -19,15 +19,14 @@
  * SOFTWARE.
  */
 
-#include <stdlib.h>
-
 #include "chipmunk_private.h"
 #include "constraints/util.h"
 
 static void
-preStep(cpSlideJoint *joint, cpFloat dt, cpFloat dt_inv)
+preStep(cpSlideJoint *joint, cpFloat dt)
 {
-	CONSTRAINT_BEGIN(joint, a, b);
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
 	
 	joint->r1 = cpvrotate(joint->anchr1, a->rot);
 	joint->r2 = cpvrotate(joint->anchr2, b->rot);
@@ -37,38 +36,40 @@ preStep(cpSlideJoint *joint, cpFloat dt, cpFloat dt_inv)
 	cpFloat pdist = 0.0f;
 	if(dist > joint->max) {
 		pdist = dist - joint->max;
+		joint->n = cpvnormalize_safe(delta);
 	} else if(dist < joint->min) {
 		pdist = joint->min - dist;
-		dist = -dist;
+		joint->n = cpvneg(cpvnormalize_safe(delta));
+	} else {
+		joint->n = cpvzero;
+		joint->jnAcc = 0.0f;
 	}
-	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*(pdist), -maxBias, maxBias);
-	
-	// compute max impulse
-	joint->jnMax = J_MAX(joint, dt);
+	joint->bias = cpfclamp(-bias_coef(joint->constraint.errorBias, dt)*pdist/dt, -maxBias, maxBias);
+}
 
-	// apply accumulated impulse
-	if(!joint->bias) //{
-		// if bias is 0, then the joint is not at a limit.
-		joint->jnAcc = 0.0f;
-//	} else {
-		cpVect j = cpvmult(joint->n, joint->jnAcc);
-		apply_impulses(a, b, joint->r1, joint->r2, j);
-//	}
+static void
+applyCachedImpulse(cpSlideJoint *joint, cpFloat dt_coef)
+{
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
+	
+	cpVect j = cpvmult(joint->n, joint->jnAcc*dt_coef);
+	apply_impulses(a, b, joint->r1, joint->r2, j);
 }
 
 static void
-applyImpulse(cpSlideJoint *joint)
+applyImpulse(cpSlideJoint *joint, cpFloat dt)
 {
-	if(!joint->bias) return;  // early exit
+	if(cpveql(joint->n, cpvzero)) return;  // early exit
 
-	CONSTRAINT_BEGIN(joint, a, b);
+	cpBody *a = joint->constraint.a;
+	cpBody *b = joint->constraint.b;
 	
 	cpVect n = joint->n;
 	cpVect r1 = joint->r1;
@@ -81,7 +82,7 @@ applyImpulse(cpSlideJoint *joint)
 	// compute normal impulse
 	cpFloat jn = (joint->bias - vrn)*joint->nMass;
 	cpFloat jnOld = joint->jnAcc;
-	joint->jnAcc = cpfclamp(jnOld + jn, -joint->jnMax, 0.0f);
+	joint->jnAcc = cpfclamp(jnOld + jn, -joint->constraint.maxForce*dt, 0.0f);
 	jn = joint->jnAcc - jnOld;
 	
 	// apply impulse
@@ -95,16 +96,17 @@ getImpulse(cpConstraint *joint)
 }
 
 static const cpConstraintClass klass = {
-	(cpConstraintPreStepFunction)preStep,
-	(cpConstraintApplyImpulseFunction)applyImpulse,
-	(cpConstraintGetImpulseFunction)getImpulse,
+	(cpConstraintPreStepImpl)preStep,
+	(cpConstraintApplyCachedImpulseImpl)applyCachedImpulse,
+	(cpConstraintApplyImpulseImpl)applyImpulse,
+	(cpConstraintGetImpulseImpl)getImpulse,
 };
 CP_DefineClassGetter(cpSlideJoint)
 
 cpSlideJoint *
 cpSlideJointAlloc(void)
 {
-	return (cpSlideJoint *)cpmalloc(sizeof(cpSlideJoint));
+	return (cpSlideJoint *)cpcalloc(1, sizeof(cpSlideJoint));
 }
 
 cpSlideJoint *