chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/cpBody.c

@@ -19,11 +19,10 @@
  * SOFTWARE.
  */
  
-#include <stdlib.h>
 #include <float.h>
-#include <stdarg.h>
 
 #include "chipmunk_private.h"
+#include "constraints/util.h"
 
 // initialized in cpInitChipmunk()
 cpBody cpStaticBodySingleton;
@@ -31,41 +30,42 @@ cpBody cpStaticBodySingleton;
 cpBody*
 cpBodyAlloc(void)
 {
-	return (cpBody *)cpmalloc(sizeof(cpBody));
+	return (cpBody *)cpcalloc(1, sizeof(cpBody));
 }
 
-cpBodyVelocityFunc cpBodyUpdateVelocityDefault = cpBodyUpdateVelocity;
-cpBodyPositionFunc cpBodyUpdatePositionDefault = cpBodyUpdatePosition;
-
-cpBody*
+cpBody *
 cpBodyInit(cpBody *body, cpFloat m, cpFloat i)
 {
-	body->velocity_func = cpBodyUpdateVelocityDefault;
-	body->position_func = cpBodyUpdatePositionDefault;
+	body->space = NULL;
+	body->shapeList = NULL;
+	body->arbiterList = NULL;
+	body->constraintList = NULL;
+	
+	body->velocity_func = cpBodyUpdateVelocity;
+	body->position_func = cpBodyUpdatePosition;
+	
+	cpComponentNode node = {NULL, NULL, 0.0f};
+	body->node = node;
 	
-	cpBodySetMass(body, m);
-	cpBodySetMoment(body, i);
-
 	body->p = cpvzero;
 	body->v = cpvzero;
 	body->f = cpvzero;
 	
-	cpBodySetAngle(body, 0.0f);
 	body->w = 0.0f;
 	body->t = 0.0f;
 	
 	body->v_bias = cpvzero;
 	body->w_bias = 0.0f;
 	
-	body->data = NULL;
 	body->v_limit = (cpFloat)INFINITY;
 	body->w_limit = (cpFloat)INFINITY;
 	
-	body->space = NULL;
-	body->shapesList = NULL;
+	body->data = NULL;
 	
-	cpComponentNode node = {NULL, NULL, 0, 0.0f};
-	body->node = node;
+	// Setters must be called after full initialization so the sanity checks don't assert on garbage data.
+	cpBodySetMass(body, m);
+	cpBodySetMoment(body, i);
+	cpBodySetAngle(body, 0.0f);
 	
 	return body;
 }
@@ -86,7 +86,7 @@ cpBodyInitStatic(cpBody *body)
 }
 
 cpBody *
-cpBodyNewStatic()
+cpBodyNewStatic(void)
 {
 	return cpBodyInitStatic(cpBodyAlloc());
 }
@@ -102,32 +102,131 @@ cpBodyFree(cpBody *body)
 	}
 }
 
+static void cpv_assert_nan(cpVect v, const char *message){cpAssertSoft(v.x == v.x && v.y == v.y, message);}
+static void cpv_assert_infinite(cpVect v, const char *message){cpAssertSoft(cpfabs(v.x) != INFINITY && cpfabs(v.y) != INFINITY, message);}
+static void cpv_assert_sane(cpVect v, const char *message){cpv_assert_nan(v, message); cpv_assert_infinite(v, message);}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void
+cpBodySanityCheck(cpBody *body)
+{
+	cpAssertSoft(body->m == body->m && body->m_inv == body->m_inv, "Body's mass is invalid.");
+	cpAssertSoft(body->i == body->i && body->i_inv == body->i_inv, "Body's moment is invalid.");
+	
+	cpv_assert_sane(body->p, "Body's position is invalid.");
+	cpv_assert_sane(body->v, "Body's velocity is invalid.");
+	cpv_assert_sane(body->f, "Body's force is invalid.");
+
+	cpAssertSoft(body->a == body->a && cpfabs(body->a) != INFINITY, "Body's angle is invalid.");
+	cpAssertSoft(body->w == body->w && cpfabs(body->w) != INFINITY, "Body's angular velocity is invalid.");
+	cpAssertSoft(body->t == body->t && cpfabs(body->t) != INFINITY, "Body's torque is invalid.");
+	
+	cpv_assert_sane(body->rot, "Body's rotation vector is invalid.");
+	
+	cpAssertSoft(body->v_limit == body->v_limit, "Body's velocity limit is invalid.");
+	cpAssertSoft(body->w_limit == body->w_limit, "Body's angular velocity limit is invalid.");
+}
+
+#ifdef __cplusplus
+}
+#endif
+
 void
 cpBodySetMass(cpBody *body, cpFloat mass)
 {
+	cpAssertHard(mass > 0.0f, "Mass must be positive and non-zero.");
+	
+	cpBodyActivate(body);
 	body->m = mass;
 	body->m_inv = 1.0f/mass;
+	cpBodyAssertSane(body);
 }
 
 void
 cpBodySetMoment(cpBody *body, cpFloat moment)
 {
+	cpAssertHard(moment > 0.0f, "Moment of Inertia must be positive and non-zero.");
+	
+	cpBodyActivate(body);
 	body->i = moment;
 	body->i_inv = 1.0f/moment;
+	cpBodyAssertSane(body);
 }
 
 void
-cpBodySetAngle(cpBody *body, cpFloat angle)
+cpBodyAddShape(cpBody *body, cpShape *shape)
+{
+	cpShape *next = body->shapeList;
+	if(next) next->prev = shape;
+	
+	shape->next = next;
+	body->shapeList = shape;
+}
+
+void
+cpBodyRemoveShape(cpBody *body, cpShape *shape)
+{
+  cpShape *prev = shape->prev;
+  cpShape *next = shape->next;
+  
+  if(prev){
+		prev->next = next;
+  } else {
+		body->shapeList = next;
+  }
+  
+  if(next){
+		next->prev = prev;
+	}
+  
+  shape->prev = NULL;
+  shape->next = NULL;
+}
+
+static cpConstraint *
+filterConstraints(cpConstraint *node, cpBody *body, cpConstraint *filter)
+{
+	if(node == filter){
+		return cpConstraintNext(node, body);
+	} else if(node->a == body){
+		node->next_a = filterConstraints(node->next_a, body, filter);
+	} else {
+		node->next_b = filterConstraints(node->next_b, body, filter);
+	}
+	
+	return node;
+}
+
+void
+cpBodyRemoveConstraint(cpBody *body, cpConstraint *constraint)
+{
+	body->constraintList = filterConstraints(body->constraintList, body, constraint);
+}
+
+void
+cpBodySetPos(cpBody *body, cpVect pos)
+{
+	cpBodyActivate(body);
+	body->p = pos;
+	cpBodyAssertSane(body);
+}
+
+static inline void
+setAngle(cpBody *body, cpFloat angle)
 {
 	body->a = angle;//fmod(a, (cpFloat)M_PI*2.0f);
 	body->rot = cpvforangle(angle);
+	cpBodyAssertSane(body);
 }
 
 void
-cpBodySlew(cpBody *body, cpVect pos, cpFloat dt)
+cpBodySetAngle(cpBody *body, cpFloat angle)
 {
-	cpVect delta = cpvsub(pos, body->p);
-	body->v = cpvmult(delta, 1.0f/dt);
+	cpBodyActivate(body);
+	setAngle(body, angle);
 }
 
 void
@@ -137,21 +236,26 @@ cpBodyUpdateVelocity(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt)
 	
 	cpFloat w_limit = body->w_limit;
 	body->w = cpfclamp(body->w*damping + body->t*body->i_inv*dt, -w_limit, w_limit);
+	
+	cpBodySanityCheck(body);
 }
 
 void
 cpBodyUpdatePosition(cpBody *body, cpFloat dt)
 {
 	body->p = cpvadd(body->p, cpvmult(cpvadd(body->v, body->v_bias), dt));
-	cpBodySetAngle(body, body->a + (body->w + body->w_bias)*dt);
+	setAngle(body, body->a + (body->w + body->w_bias)*dt);
 	
 	body->v_bias = cpvzero;
 	body->w_bias = 0.0f;
+	
+	cpBodySanityCheck(body);
 }
 
 void
 cpBodyResetForces(cpBody *body)
 {
+	cpBodyActivate(body);
 	body->f = cpvzero;
 	body->t = 0.0f;
 }
@@ -159,34 +263,68 @@ cpBodyResetForces(cpBody *body)
 void
 cpBodyApplyForce(cpBody *body, cpVect force, cpVect r)
 {
+	cpBodyActivate(body);
 	body->f = cpvadd(body->f, force);
 	body->t += cpvcross(r, force);
 }
 
 void
-cpApplyDampedSpring(cpBody *a, cpBody *b, cpVect anchr1, cpVect anchr2, cpFloat rlen, cpFloat k, cpFloat dmp, cpFloat dt)
+cpBodyApplyImpulse(cpBody *body, const cpVect j, const cpVect r)
 {
-	// Calculate the world space anchor coordinates.
-	cpVect r1 = cpvrotate(anchr1, a->rot);
-	cpVect r2 = cpvrotate(anchr2, b->rot);
-	
-	cpVect delta = cpvsub(cpvadd(b->p, r2), cpvadd(a->p, r1));
-	cpFloat dist = cpvlength(delta);
-	cpVect n = dist ? cpvmult(delta, 1.0f/dist) : cpvzero;
-	
-	cpFloat f_spring = (dist - rlen)*k;
+	cpBodyActivate(body);
+	apply_impulse(body, j, r);
+}
 
-	// Calculate the world relative velocities of the anchor points.
-	cpVect v1 = cpvadd(a->v, cpvmult(cpvperp(r1), a->w));
-	cpVect v2 = cpvadd(b->v, cpvmult(cpvperp(r2), b->w));
-	
-	// Calculate the damping force.
-	// This really should be in the impulse solver and can produce problems when using large damping values.
-	cpFloat vrn = cpvdot(cpvsub(v2, v1), n);
-	cpFloat f_damp = vrn*cpfmin(dmp, 1.0f/(dt*(a->m_inv + b->m_inv)));
-	
-	// Apply!
-	cpVect f = cpvmult(n, f_spring + f_damp);
-	cpBodyApplyForce(a, f, r1);
-	cpBodyApplyForce(b, cpvneg(f), r2);
+static inline cpVect
+cpBodyGetVelAtPoint(cpBody *body, cpVect r)
+{
+	return cpvadd(body->v, cpvmult(cpvperp(r), body->w));
+}
+
+cpVect
+cpBodyGetVelAtWorldPoint(cpBody *body, cpVect point)
+{
+	return cpBodyGetVelAtPoint(body, cpvsub(point, body->p));
+}
+
+cpVect
+cpBodyGetVelAtLocalPoint(cpBody *body, cpVect point)
+{
+	return cpBodyGetVelAtPoint(body, cpvrotate(point, body->rot));
+}
+
+void
+cpBodyEachShape(cpBody *body, cpBodyShapeIteratorFunc func, void *data)
+{
+	cpShape *shape = body->shapeList;
+	while(shape){
+		cpShape *next = shape->next;
+		func(body, shape, data);
+		shape = next;
+	}
+}
+
+void
+cpBodyEachConstraint(cpBody *body, cpBodyConstraintIteratorFunc func, void *data)
+{
+	cpConstraint *constraint = body->constraintList;
+	while(constraint){
+		cpConstraint *next = cpConstraintNext(constraint, body);
+		func(body, constraint, data);
+		constraint = next;
+	}
+}
+
+void
+cpBodyEachArbiter(cpBody *body, cpBodyArbiterIteratorFunc func, void *data)
+{
+	cpArbiter *arb = body->arbiterList;
+	while(arb){
+		cpArbiter *next = cpArbiterNext(arb, body);
+		
+		arb->swappedColl = (body == arb->body_b);
+		func(body, arb, data);
+		
+		arb = next;
+	}
 }

data/ext/chipmunk/cpBody.h

@@ -19,194 +19,213 @@
  * SOFTWARE.
  */
 
-struct cpBody;
-struct cpShape;
-struct cpSpace;
-
-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;
-
-// Structure to hold information about the contact graph components
-// when putting groups of objects to sleep.
-// No interesting user accessible fields.
+/// @defgroup cpBody cpBody
+/// Chipmunk's rigid body type. Rigid bodies hold the physical properties of an object like
+/// it's mass, and position and velocity of it's center of gravity. They don't have an shape on their own.
+/// They are given a shape by creating collision shapes (cpShape) that point to the body.
+/// @{
+
+/// Rigid body velocity update function type.
+typedef void (*cpBodyVelocityFunc)(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt);
+/// Rigid body position update function type.
+typedef void (*cpBodyPositionFunc)(cpBody *body, cpFloat dt);
+
+/// Used internally to track information on the collision graph.
+/// @private
 typedef struct cpComponentNode {
-	struct cpBody *parent;
-	struct cpBody *next;
-	int rank;
+	cpBody *root;
+	cpBody *next;
 	cpFloat idleTime;
 } cpComponentNode;
 
-typedef struct cpBody{
-	// *** Integration Functions.
-
-	// Function that is called to integrate the body's velocity. (Defaults to cpBodyUpdateVelocity)
+/// Chipmunk's rigid body struct.
+struct cpBody {
+	/// Function that is called to integrate the body's velocity. (Defaults to cpBodyUpdateVelocity)
 	cpBodyVelocityFunc velocity_func;
 	
-	// Function that is called to integrate the body's position. (Defaults to cpBodyUpdatePosition)
+	/// Function that is called to integrate the body's position. (Defaults to cpBodyUpdatePosition)
 	cpBodyPositionFunc position_func;
 	
-	// *** Mass Properties
-	
-	// Mass and it's inverse.
-	// Always use cpBodySetMass() whenever changing the mass as these values must agree.
-	cpFloat m, m_inv;
-	
-	// Moment of inertia and it's inverse.
-	// Always use cpBodySetMoment() whenever changing the moment as these values must agree.
-	cpFloat i, i_inv;
-	
-	// *** Positional Properties
-	
-	// Linear components of motion (position, velocity, and force)
-	cpVect p, v, f;
-	
-	// Angular components of motion (angle, angular velocity, and torque)
-	// Always use cpBodySetAngle() to set the angle of the body as a and rot must agree.
-	cpFloat a, w, t;
-	
-	// Cached unit length vector representing the angle of the body.
-	// Used for fast vector rotation using cpvrotate().
+	/// Mass of the body.
+	/// Must agree with cpBody.m_inv! Use cpBodySetMass() when changing the mass for this reason.
+	cpFloat m;
+	/// Mass inverse.
+	cpFloat m_inv;
+	
+	/// Moment of inertia of the body.
+	/// Must agree with cpBody.i_inv! Use cpBodySetMoment() when changing the moment for this reason.
+	cpFloat i;
+	/// Moment of inertia inverse.
+	cpFloat i_inv;
+	
+	/// Position of the rigid body's center of gravity.
+	cpVect p;
+	/// Velocity of the rigid body's center of gravity.
+	cpVect v;
+	/// Force acting on the rigid body's center of gravity.
+	cpVect f;
+	
+	/// Rotation of the body around it's center of gravity in radians.
+	/// Must agree with cpBody.rot! Use cpBodySetAngle() when changing the angle for this reason.
+	cpFloat a;
+	/// Angular velocity of the body around it's center of gravity in radians/second.
+	cpFloat w;
+	/// Torque applied to the body around it's center of gravity.
+	cpFloat t;
+	
+	/// Cached unit length vector representing the angle of the body.
+	/// Used for fast rotations using cpvrotate().
 	cpVect rot;
 	
-	// *** User Definable Fields
-	
-	// User defined data pointer.
+	/// User definable data pointer.
+	/// Generally this points to your the game object class so you can access it
+	/// when given a cpBody reference in a callback.
 	cpDataPointer data;
 	
-	// *** Other Fields
-	
-	// Maximum velocities this body can move at after integrating velocity
-	cpFloat v_limit, w_limit;
-	
-	// *** Internally Used Fields
+	/// Maximum velocity allowed when updating the velocity.
+	cpFloat v_limit;
+	/// Maximum rotational rate (in radians/second) allowed when updating the angular velocity.
+	cpFloat w_limit;
 	
-	// Velocity bias values used when solving penetrations and correcting constraints.
 	CP_PRIVATE(cpVect v_bias);
 	CP_PRIVATE(cpFloat w_bias);
 	
-	// Space this body has been added to
-	CP_PRIVATE(struct cpSpace *space);
+	CP_PRIVATE(cpSpace *space);
 	
-	// Pointer to the shape list.
-	// Shapes form a linked list using cpShape.next when added to a space.
-	CP_PRIVATE(struct cpShape *shapesList);
+	CP_PRIVATE(cpShape *shapeList);
+	CP_PRIVATE(cpArbiter *arbiterList);
+	CP_PRIVATE(cpConstraint *constraintList);
 	
-	// Used by cpSpaceStep() to store contact graph information.
 	CP_PRIVATE(cpComponentNode node);
-} cpBody;
+};
 
-// Basic allocation/destruction functions
-cpBody *cpBodyAlloc(void);
-cpBody *cpBodyInit(cpBody *body, cpFloat m, cpFloat i);
-cpBody *cpBodyNew(cpFloat m, cpFloat i);
+/// Allocate a cpBody.
+cpBody* cpBodyAlloc(void);
+/// Initialize a cpBody.
+cpBody* cpBodyInit(cpBody *body, cpFloat m, cpFloat i);
+/// Allocate and initialize a cpBody.
+cpBody* cpBodyNew(cpFloat m, cpFloat i);
 
-cpBody *cpBodyInitStatic(cpBody *body);
-cpBody *cpBodyNewStatic();
+/// Initialize a static cpBody.
+cpBody* cpBodyInitStatic(cpBody *body);
+/// Allocate and initialize a static cpBody.
+cpBody* cpBodyNewStatic(void);
 
+/// Destroy a cpBody.
 void cpBodyDestroy(cpBody *body);
+/// Destroy and free a cpBody.
 void cpBodyFree(cpBody *body);
 
-// Wake up a sleeping or idle body. (defined in cpSpace.c)
+/// Check that the properties of a body is sane. (Only in debug mode)
+#ifdef NDEBUG
+	#define	cpBodyAssertSane(body)
+#else
+	void cpBodySanityCheck(cpBody *body);
+	#define	cpBodyAssertSane(body) cpBodySanityCheck(body)
+#endif
+
+// Defined in cpSpace.c
+/// Wake up a sleeping or idle body.
 void cpBodyActivate(cpBody *body);
+/// Wake up any sleeping or idle bodies touching a static body.
+void cpBodyActivateStatic(cpBody *body, cpShape *filter);
 
-// Force a body to sleep;
-// defined in cpSpaceComponent.c
+/// Force a body to fall asleep immediately.
 void cpBodySleep(cpBody *body);
+/// Force a body to fall asleep immediately along with other bodies in a group.
 void cpBodySleepWithGroup(cpBody *body, cpBody *group);
 
-static inline cpBool
-cpBodyIsSleeping(const cpBody *body)
+/// Returns true if the body is sleeping.
+static inline cpBool cpBodyIsSleeping(const cpBody *body)
 {
-	return (CP_PRIVATE(body->node).next != ((cpBody*)0));
+	return (CP_PRIVATE(body->node).root != ((cpBody*)0));
 }
 
-static inline cpBool
-cpBodyIsStatic(const cpBody *body)
+/// Returns true if the body is static.
+static inline cpBool cpBodyIsStatic(const cpBody *body)
 {
 	return CP_PRIVATE(body->node).idleTime == INFINITY;
 }
 
-static inline cpBool
-cpBodyIsRogue(const cpBody *body)
+/// Returns true if the body has not been added to a space.
+/// Note: Static bodies are a subtype of rogue bodies.
+static inline cpBool cpBodyIsRogue(const cpBody *body)
 {
-	return (body->CP_PRIVATE(space) == ((struct cpSpace*)0));
+	return (body->CP_PRIVATE(space) == ((cpSpace*)0));
 }
 
 
-#define CP_DefineBodyGetter(type, member, name) \
+#define CP_DefineBodyStructGetter(type, member, name) \
 static inline type cpBodyGet##name(const cpBody *body){return body->member;}
 
-#define CP_DefineBodySetter(type, member, name) \
-static inline void \
-cpBodySet##name(cpBody *body, const type value){ \
+#define CP_DefineBodyStructSetter(type, member, name) \
+static inline void cpBodySet##name(cpBody *body, const type value){ \
 	cpBodyActivate(body); \
 	body->member = value; \
-} \
+	cpBodyAssertSane(body); \
+}
 
-#define CP_DefineBodyProperty(type, member, name) \
-CP_DefineBodyGetter(type, member, name) \
-CP_DefineBodySetter(type, member, name)
+#define CP_DefineBodyStructProperty(type, member, name) \
+CP_DefineBodyStructGetter(type, member, name) \
+CP_DefineBodyStructSetter(type, member, name)
 
+// TODO add to docs
+CP_DefineBodyStructGetter(cpSpace*, CP_PRIVATE(space), Space)
 
-// Accessors for cpBody struct members
-CP_DefineBodyGetter(cpFloat, m, Mass);
+CP_DefineBodyStructGetter(cpFloat, m, Mass)
+/// Set the mass of a body.
 void cpBodySetMass(cpBody *body, cpFloat m);
 
-CP_DefineBodyGetter(cpFloat, i, Moment);
+CP_DefineBodyStructGetter(cpFloat, i, Moment)
+/// Set the moment of a body.
 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);
+CP_DefineBodyStructGetter(cpVect, p, Pos)
+/// Set the position of a body.
+void cpBodySetPos(cpBody *body, cpVect pos);
+CP_DefineBodyStructProperty(cpVect, v, Vel)
+CP_DefineBodyStructProperty(cpVect, f, Force)
+CP_DefineBodyStructGetter(cpFloat, a, Angle)
+/// Set the angle of a body.
 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.
-void cpBodySlew(cpBody *body, cpVect pos, cpFloat dt);
-
-// Default Integration functions.
+CP_DefineBodyStructProperty(cpFloat, w, AngVel)
+CP_DefineBodyStructProperty(cpFloat, t, Torque)
+CP_DefineBodyStructGetter(cpVect, rot, Rot)
+CP_DefineBodyStructProperty(cpFloat, v_limit, VelLimit)
+CP_DefineBodyStructProperty(cpFloat, w_limit, AngVelLimit)
+CP_DefineBodyStructProperty(cpDataPointer, data, UserData)
+
+/// Default Integration functions.
 void cpBodyUpdateVelocity(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt);
 void cpBodyUpdatePosition(cpBody *body, cpFloat dt);
 
-// Convert body local to world coordinates
-static inline cpVect
-cpBodyLocal2World(const cpBody *body, const cpVect v)
+/// Convert body relative/local coordinates to absolute/world coordinates.
+static inline cpVect cpBodyLocal2World(const cpBody *body, const cpVect v)
 {
 	return cpvadd(body->p, cpvrotate(v, body->rot));
 }
 
-// Convert world to body local coordinates
-static inline cpVect
-cpBodyWorld2Local(const cpBody *body, const cpVect v)
+/// Convert body absolute/world coordinates to  relative/local coordinates.
+static inline cpVect cpBodyWorld2Local(const cpBody *body, const cpVect v)
 {
 	return cpvunrotate(cpvsub(v, body->p), body->rot);
 }
 
-// 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, const cpVect j, const cpVect r)
-{
-	body->v = cpvadd(body->v, cpvmult(j, body->m_inv));
-	body->w += body->i_inv*cpvcross(r, j);
-}
-
-// Zero the forces on a body.
+/// Set the forces and torque or a body to zero.
 void cpBodyResetForces(cpBody *body);
-// Apply a force (in world coordinates) to a body at a point relative to the center of gravity (also in world coordinates).
+/// Apply an force (in world coordinates) to the body at a point relative to the center of gravity (also in world coordinates).
 void cpBodyApplyForce(cpBody *body, const cpVect f, const cpVect r);
+/// Apply an impulse (in world coordinates) to the body at a point relative to the center of gravity (also in world coordinates).
+void cpBodyApplyImpulse(cpBody *body, const cpVect j, const cpVect r);
+
+/// Get the velocity on a body (in world units) at a point on the body in world coordinates.
+cpVect cpBodyGetVelAtWorldPoint(cpBody *body, cpVect point);
+/// Get the velocity on a body (in world units) at a point on the body in local coordinates.
+cpVect cpBodyGetVelAtLocalPoint(cpBody *body, cpVect point);
+
 
-static inline cpFloat
-cpBodyKineticEnergy(const cpBody *body)
+/// Get the kinetic energy of a body.
+static inline cpFloat cpBodyKineticEnergy(const cpBody *body)
 {
 	// Need to do some fudging to avoid NaNs
 	cpFloat vsq = cpvdot(body->v, body->v);
@@ -214,6 +233,19 @@ cpBodyKineticEnergy(const cpBody *body)
 	return (vsq ? vsq*body->m : 0.0f) + (wsq ? wsq*body->i : 0.0f);
 }
 
-// Apply a damped spring force between two bodies.
-// 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);
+/// Body/shape iterator callback function type. 
+typedef void (*cpBodyShapeIteratorFunc)(cpBody *body, cpShape *shape, void *data);
+/// Call @c func once for each shape attached to @c body and added to the space.
+void cpBodyEachShape(cpBody *body, cpBodyShapeIteratorFunc func, void *data);
+
+/// Body/constraint iterator callback function type. 
+typedef void (*cpBodyConstraintIteratorFunc)(cpBody *body, cpConstraint *constraint, void *data);
+/// Call @c func once for each constraint attached to @c body and added to the space.
+void cpBodyEachConstraint(cpBody *body, cpBodyConstraintIteratorFunc func, void *data);
+
+/// Body/arbiter iterator callback function type. 
+typedef void (*cpBodyArbiterIteratorFunc)(cpBody *body, cpArbiter *arbiter, void *data);
+/// Call @c func once for each arbiter that is currently active on the body.
+void cpBodyEachArbiter(cpBody *body, cpBodyArbiterIteratorFunc func, void *data);
+
+///@}