Chipmunk Physics

Code: Select all

#define CELLDIM	48
#define SEG_RADIUS	2
static cpBody body_world;
static cpSegmentShape segment_world[3];

static void InitStaticObjects (void)
{
	const vec2_t arr[]= {
		{0, 0},
		{0, 480},
		{320, 480},
		{320, 0},
	};
	
	cpBody* body= &body_world;
	cpBodyInitStatic (body);
	
	for (UINT i= 0; i < COUNT (segment_world); i++)
	{
		cpSegmentShapeInit (&segment_world[i], body, arr[i], arr[i + 1], SEG_RADIUS);
		cpShape* shape= &segment_world[i].shape;
		shape->e= 1.0f;
		shape->u= 1.0f;
	}
}

Code: Select all

typedef struct
{
	cpCircleShape shape;
	cpBody body;
} ball_t;

static apr_array_header_t* arr_balls;

static void AddDynamicObject (void)
{	
	ball_t* self= apr_array_push (arr_balls);
	
	const float radius= 15.0f;
	const float mass = 10.0f;
	
	cpBodyInit (&self->body, mass, cpMomentForCircle (mass, 0, radius, vec2_zero));
	input_getfloatv (INPUT_MOUSE_POS, self->body.p);
	
	cpCircleShapeInit (&self->shape, &self->body, radius, vec2_zero);	
	
	cpShape* shape= &self->shape.shape;
	shape->e= 0.0f;
	shape->u= 0.9f;	
}

Code: Select all

static BOOL IntegratePositionAndUpdateBBCache (ball_t* self, const float *dt)
{
	cpBodyUpdatePosition (&self->body, *dt);
	if (480 + 15 < self->body.p[1])
		return FALSE;
	
	cpShapeCacheBB (&self->shape.shape);
	return TRUE;
}
...
	array_filterself (arr_balls, IntegratePositionAndUpdateBBCache, &dt);

Code: Select all

static void FillStaticObjects (apr_hash_t* ht)
{
	irect_t key;
	for (UINT i= 0 ; i < COUNT (segment_world); i++)
	{
		cpShape* self= &segment_world[i].shape;
		cpspace_hash_key (&key, &self->bb, CELLDIM);
		cpspace_hash_put (ht, &key, self);
	}
}

Code: Select all

static void CollideDynamicObject (ball_t* self, userdata_t* userdata)
{
	cpShape* shape= &self->shape.shape;
	apr_hash_t* ht= userdata->ht;
	apr_array_header_t* arr= userdata->arr;
	cpSpace* space= userdata->space;
	
	//body need to be reassigned to shape because we store all our object in a dynamic array
	shape->body= &self->body;
	
	//clear the temporary array for new broadphase collisions	
	apr_array_clear (arr);
	
	//retrieve a list of broadphase collisions for shape's bounding box
	irect_t key;
	cpspace_hash_key(&key, &shape->bb, CELLDIM);
	cpspace_hash_get (ht, &key, arr);
	
	//loop through all broadphase collisions
	for (UINT i= 0; i < arr->nelts; i++)
	{
		//sort shapes so they are always processed in the same order
		cpShape* a= ((cpShape**) arr->elts)[i];
		cpShape* b= shape;
		CPCOLLIDE_SWAP (&a, &b);
		
		//retrieve list of contact points (narrow phase collision test)
		UINT i= space->contactArray->nelts;
		UINT n= cpCollideShapes (a, b, space->contactArray);
		if (n == 0)
			continue;
		
		//store contact points for future processing
		cpArbiter* arbiter= cpspace_newarbiter (space, a, b);
		cpArbiterUpdate (arbiter, ((cpContact* ) space->contactArray->elts) + i, n);
	}
	
	//add current shape to broadphase 
	cpspace_hash_put (ht, &key, shape);
}
...
	array_map (arr_balls, CollideDynamicObject, &userdata);

Code: Select all

static void frame_tick (void)
{
...	
	array_filterself (arr_balls, (array_filterfunc_t) IntegratePositionAndUpdateBBCache, &dt);
	
	cpspace_begin (space);
	apr_hash_t* ht= apr_hash_make (POOL_GETFRAME());
	FillStaticObjects (ht);
	
	userdata_t userdata;
	userdata.ht= ht;
	userdata.arr= apr_array_make (POOL_GETFRAME(), 8, sizeof (const void*));
	userdata.space= space;
	
	array_map (arr_balls, (array_mapfunc_t) CollideDynamicObject, &userdata);
	
	const rect_t rect= {0, 0, 320, 480};
	drawSpatialHash (ht, &rect, CELLDIM, buffer_solid);
	
	ht= cpspace_getarbiters (space);
	PrestepArbiters (ht, dt);
	RunImpulseSolver (ht, DEFAULT_ELASTIC_ITERATIONS, 1);
	
	array_map (arr_balls, (array_mapfunc_t) IntegrateVelocity, &dt);
	ApplyCachedImpulse (ht);
	RunImpulseSolver (ht, DEFAULT_ITERATIONS, 0);

	array_map (arr_balls, draw_ball, NULL);
}

Code: Select all

typedef struct cpBody
{
	cpFloat m_inv, i_inv;
	cpVect p, v, f;	// Linear components of motion (position, velocity, and force)
	cpFloat a, w, t;	//Angular components of motion (angle, angular velocity, and torque)
	cpVect rot;	//Cached unit length vector representing the angle of the body.
	
	//Internally Used Fields
	//Velocity bias values used when solving penetrations and correcting joints.
	cpVect v_bias;
	cpFloat w_bias;
} cpBody;

struct cpShape
{
	const cpShapeClass *klass;	// The "class" of a shape as defined above 
	struct cpBody *body;	//cpBody that the shape is attached to.
	cpBB bb;	// Cached BBox for the shape.
	
	//Surface properties.
	cpFloat e;	// Coefficient of restitution. (elasticity)
	cpFloat u;	// Coefficient of friction.
	cpVect surface_v;	// Surface velocity used when solving for friction.
	
	//Internally Used Fields
	unsigned id;		// Unique id used as the hash value.
};

#define CPCONTACT_PERSISTENCE	3
typedef struct cpSpace
{
	struct apr_pool_t* pool;
	struct apr_hash_t *contactSet[CPCONTACT_PERSISTENCE];
	struct apr_array_header_t* contactArray;
} cpSpace;