chipmunk 4.1.0 → 5.2.0

data/ext/chipmunk/include/chipmunk/cpSpace.h

@@ -0,0 +1,180 @@
+/* Copyright (c) 2007 Scott Lembcke
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+struct cpSpace;
+
+// Number of frames that contact information should persist.
+extern int cp_contact_persistence;
+
+// User collision handler function types.
+typedef int (*cpCollisionBeginFunc)(cpArbiter *arb, struct cpSpace *space, void *data);
+typedef int (*cpCollisionPreSolveFunc)(cpArbiter *arb, struct cpSpace *space, void *data);
+typedef void (*cpCollisionPostSolveFunc)(cpArbiter *arb, struct cpSpace *space, void *data);
+typedef void (*cpCollisionSeparateFunc)(cpArbiter *arb, struct cpSpace *space, void *data);
+
+// Structure for holding collision pair function information.
+// Used internally.
+typedef struct cpCollisionHandler {
+	cpCollisionType a;
+	cpCollisionType b;
+	cpCollisionBeginFunc begin;
+	cpCollisionPreSolveFunc preSolve;
+	cpCollisionPostSolveFunc postSolve;
+	cpCollisionSeparateFunc separate;
+	void *data;
+} cpCollisionHandler;
+
+#define CP_MAX_CONTACTS_PER_ARBITER 6
+typedef struct cpContactBufferHeader {
+	int stamp;
+	struct cpContactBufferHeader *next;
+	unsigned int numContacts;
+} cpContactBufferHeader;
+
+typedef struct cpSpace{
+	// *** User definable fields
+	
+	// Number of iterations to use in the impulse solver to solve contacts.
+	int iterations;
+	
+	// Number of iterations to use in the impulse solver to solve elastic collisions.
+	int elasticIterations;
+	
+	// Default gravity to supply when integrating rigid body motions.
+	cpVect gravity;
+	
+	// Default damping to supply when integrating rigid body motions.
+	cpFloat damping;
+	
+	// *** Internally Used Fields
+	
+	// When the space is locked, you should not add or remove objects;
+	int locked;
+	
+	// Time stamp. Is incremented on every call to cpSpaceStep().
+	int stamp;
+
+	// The static and active shape spatial hashes.
+	cpSpaceHash *staticShapes;
+	cpSpaceHash *activeShapes;
+	
+	// List of bodies in the system.
+	cpArray *bodies;
+	
+	// List of active arbiters for the impulse solver.
+	cpArray *arbiters, *pooledArbiters;
+	
+	// Linked list ring of contact buffers.
+	// Head is the current buffer. Tail is the oldest buffer.
+	// The list points in the direction of tail->head.
+	cpContactBufferHeader *contactBuffersHead, *contactBuffersTail;
+	
+	// List of buffers to be free()ed when destroying the space.
+	cpArray *allocatedBuffers;
+	
+	// Persistant contact set.
+	cpHashSet *contactSet;
+	
+	// List of constraints in the system.
+	cpArray *constraints;
+	
+	// Set of collisionpair functions.
+	cpHashSet *collFuncSet;
+	// Default collision handler.
+	cpCollisionHandler defaultHandler;
+	
+	cpHashSet *postStepCallbacks;
+} cpSpace;
+
+// Basic allocation/destruction functions.
+cpSpace* cpSpaceAlloc(void);
+cpSpace* cpSpaceInit(cpSpace *space);
+cpSpace* cpSpaceNew(void);
+
+void cpSpaceDestroy(cpSpace *space);
+void cpSpaceFree(cpSpace *space);
+
+// Convenience function. Frees all referenced entities. (bodies, shapes and constraints)
+void cpSpaceFreeChildren(cpSpace *space);
+
+// Collision handler management functions.
+void cpSpaceSetDefaultCollisionHandler(
+	cpSpace *space,
+	cpCollisionBeginFunc begin,
+	cpCollisionPreSolveFunc preSolve,
+	cpCollisionPostSolveFunc postSolve,
+	cpCollisionSeparateFunc separate,
+	void *data
+);
+void cpSpaceAddCollisionHandler(
+	cpSpace *space,
+	cpCollisionType a, cpCollisionType b,
+	cpCollisionBeginFunc begin,
+	cpCollisionPreSolveFunc preSolve,
+	cpCollisionPostSolveFunc postSolve,
+	cpCollisionSeparateFunc separate,
+	void *data
+);
+void cpSpaceRemoveCollisionHandler(cpSpace *space, cpCollisionType a, cpCollisionType b);
+
+// Add and remove entities from the system.
+cpShape *cpSpaceAddShape(cpSpace *space, cpShape *shape);
+cpShape *cpSpaceAddStaticShape(cpSpace *space, cpShape *shape);
+cpBody *cpSpaceAddBody(cpSpace *space, cpBody *body);
+cpConstraint *cpSpaceAddConstraint(cpSpace *space, cpConstraint *constraint);
+
+void cpSpaceRemoveShape(cpSpace *space, cpShape *shape);
+void cpSpaceRemoveStaticShape(cpSpace *space, cpShape *shape);
+void cpSpaceRemoveBody(cpSpace *space, cpBody *body);
+void cpSpaceRemoveConstraint(cpSpace *space, cpConstraint *constraint);
+
+// Post Step function definition
+typedef void (*cpPostStepFunc)(cpSpace *space, void *obj, void *data);
+// Register a post step function to be called after cpSpaceStep() has finished.
+// obj is used a key, you can only register one callback per unique value for obj
+void cpSpaceAddPostStepCallback(cpSpace *space, cpPostStepFunc func, void *obj, void *data);
+
+// Point query callback function
+typedef void (*cpSpacePointQueryFunc)(cpShape *shape, void *data);
+void cpSpacePointQuery(cpSpace *space, cpVect point, cpLayers layers, cpGroup group, cpSpacePointQueryFunc func, void *data);
+cpShape *cpSpacePointQueryFirst(cpSpace *space, cpVect point, cpLayers layers, cpGroup group);
+
+// Segment query callback function
+typedef void (*cpSpaceSegmentQueryFunc)(cpShape *shape, cpFloat t, cpVect n, void *data);
+int cpSpaceSegmentQuery(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSpaceSegmentQueryFunc func, void *data);
+cpShape *cpSpaceSegmentQueryFirst(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSegmentQueryInfo *out);
+
+// BB query callback function
+typedef void (*cpSpaceBBQueryFunc)(cpShape *shape, void *data);
+void cpSpaceBBQuery(cpSpace *space, cpBB bb, cpLayers layers, cpGroup group, cpSpaceBBQueryFunc func, void *data);
+
+
+// Iterator function for iterating the bodies in a space.
+typedef void (*cpSpaceBodyIterator)(cpBody *body, void *data);
+void cpSpaceEachBody(cpSpace *space, cpSpaceBodyIterator func, void *data);
+
+// Spatial hash management functions.
+void cpSpaceResizeStaticHash(cpSpace *space, cpFloat dim, int count);
+void cpSpaceResizeActiveHash(cpSpace *space, cpFloat dim, int count);
+void cpSpaceRehashStatic(cpSpace *space);
+
+// Update the space.
+void cpSpaceStep(cpSpace *space, cpFloat dt);

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

@@ -51,13 +51,16 @@ typedef struct cpSpaceHash{
 	// BBox callback.
 	cpSpaceHashBBFunc bbfunc;
 
-	// Hashset of all the handles.
+	// Hashset of the handles and the recycled ones.
 	cpHashSet *handleSet;
+	cpArray *pooledHandles;
+	
+	// The table and the recycled bins.
+	cpSpaceHashBin **table, *pooledBins;
+	
+	// list of buffers to free on destruction.
+	cpArray *allocatedBuffers;
 	
-	cpSpaceHashBin **table;
-	// List of recycled bins.
-	cpSpaceHashBin *bins;
-
 	// Incremented on each query. See cpHandle.stamp.
 	int stamp;
 } cpSpaceHash;
@@ -74,9 +77,9 @@ void cpSpaceHashFree(cpSpaceHash *hash);
 void cpSpaceHashResize(cpSpaceHash *hash, cpFloat celldim, int numcells);
 
 // Add an object to the hash.
-void cpSpaceHashInsert(cpSpaceHash *hash, void *obj, unsigned int id, cpBB bb);
+void cpSpaceHashInsert(cpSpaceHash *hash, void *obj, cpHashValue id, cpBB bb);
 // Remove an object from the hash.
-void cpSpaceHashRemove(cpSpaceHash *hash, void *obj, unsigned int id);
+void cpSpaceHashRemove(cpSpaceHash *hash, void *obj, cpHashValue id);
 
 // Iterator function
 typedef void (*cpSpaceHashIterator)(void *obj, void *data);
@@ -86,10 +89,10 @@ void cpSpaceHashEach(cpSpaceHash *hash, cpSpaceHashIterator func, void *data);
 // Rehash the contents of the hash.
 void cpSpaceHashRehash(cpSpaceHash *hash);
 // Rehash only a specific object.
-void cpSpaceHashRehashObject(cpSpaceHash *hash, void *obj, unsigned int id);
+void cpSpaceHashRehashObject(cpSpaceHash *hash, void *obj, cpHashValue id);
 
 // Query callback.
-typedef int (*cpSpaceHashQueryFunc)(void *obj1, void *obj2, void *data);
+typedef void (*cpSpaceHashQueryFunc)(void *obj1, void *obj2, void *data);
 // Point query the hash. A reference to the query point is passed as obj1 to the query callback.
 void cpSpaceHashPointQuery(cpSpaceHash *hash, cpVect point, cpSpaceHashQueryFunc func, void *data);
 // Query the hash for a given BBox.
@@ -98,3 +101,9 @@ void cpSpaceHashQuery(cpSpaceHash *hash, void *obj, cpBB bb, cpSpaceHashQueryFun
 void cpSpaceHashQueryInsert(cpSpaceHash *hash, void *obj, cpBB bb, cpSpaceHashQueryFunc func, void *data);
 // Rehashes while querying for each object. (Optimized case) 
 void cpSpaceHashQueryRehash(cpSpaceHash *hash, cpSpaceHashQueryFunc func, void *data);
+
+// Segment Query callback.
+// Return value is uesd for early exits of the query.
+// If while traversing the grid, the raytrace function detects that an entire grid cell is beyond the hit point, it will stop the trace.
+typedef cpFloat (*cpSpaceHashSegmentQueryFunc)(void *obj1, void *obj2, void *data);
+void cpSpaceHashSegmentQuery(cpSpaceHash *hash, void *obj, cpVect a, cpVect b, cpFloat t_exit, cpSpaceHashSegmentQueryFunc func, void *data);

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

@@ -18,10 +18,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
- 
-typedef struct cpVect{
-	cpFloat x,y;
-} cpVect;
 
 static const cpVect cpvzero={0.0f,0.0f};
 
@@ -32,6 +28,14 @@ cpv(const cpFloat x, const cpFloat y)
 	return v;
 }
 
+// non-inlined functions
+cpFloat cpvlength(const cpVect v);
+cpVect cpvslerp(const cpVect v1, const cpVect v2, const cpFloat t);
+cpVect cpvslerpconst(const cpVect v1, const cpVect v2, const cpFloat a);
+cpVect cpvforangle(const cpFloat a); // convert radians to a normalized vector
+cpFloat cpvtoangle(const cpVect v); // convert a vector to radians
+char *cpvstr(const cpVect v); // get a string representation of a vector
+
 static inline cpVect
 cpvadd(const cpVect v1, const cpVect v2)
 {
@@ -98,9 +102,56 @@ cpvunrotate(const cpVect v1, const cpVect v2)
 	return cpv(v1.x*v2.x + v1.y*v2.y, v1.y*v2.x - v1.x*v2.y);
 }
 
-cpFloat cpvlength(const cpVect v);
-cpFloat cpvlengthsq(const cpVect v); // no sqrt() call
-cpVect cpvnormalize(const cpVect v);
-cpVect cpvforangle(const cpFloat a); // convert radians to a normalized vector
-cpFloat cpvtoangle(const cpVect v); // convert a vector to radians
-char *cpvstr(const cpVect v); // get a string representation of a vector
+static inline cpFloat
+cpvlengthsq(const cpVect v)
+{
+	return cpvdot(v, v);
+}
+
+static inline cpVect
+cpvlerp(const cpVect v1, const cpVect v2, const cpFloat t)
+{
+	return cpvadd(cpvmult(v1, 1.0f - t), cpvmult(v2, t));
+}
+
+static inline cpVect
+cpvnormalize(const cpVect v)
+{
+	return cpvmult(v, 1.0f/cpvlength(v));
+}
+
+static inline cpVect
+cpvnormalize_safe(const cpVect v)
+{
+	return (v.x == 0.0f && v.y == 0.0f ? cpvzero : cpvnormalize(v));
+}
+
+static inline cpVect
+cpvclamp(const cpVect v, const cpFloat len)
+{
+	return (cpvdot(v,v) > len*len) ? cpvmult(cpvnormalize(v), len) : v;
+}
+
+static inline cpVect
+cpvlerpconst(cpVect v1, cpVect v2, cpFloat d)
+{
+	return cpvadd(v1, cpvclamp(cpvsub(v2, v1), d));
+}
+
+static inline cpFloat
+cpvdist(const cpVect v1, const cpVect v2)
+{
+	return cpvlength(cpvsub(v1, v2));
+}
+
+static inline cpFloat
+cpvdistsq(const cpVect v1, const cpVect v2)
+{
+	return cpvlengthsq(cpvsub(v1, v2));
+}
+
+static inline int
+cpvnear(const cpVect v1, const cpVect v2, const cpFloat dist)
+{
+	return cpvdistsq(v1, v2) < dist*dist;
+}

data/ext/chipmunk/prime.h

@@ -21,47 +21,47 @@
  
 // Used for resizing hash tables.
 // Values approximately double.
-
+// http://planetmath.org/encyclopedia/GoodHashTablePrimes.html
 static int primes[] = {
-	5,          //2^2  + 1
-	11,         //2^3  + 3
-	17,         //2^4  + 1
-	37,         //2^5  + 5
-	67,         //2^6  + 3
-	131,        //2^7  + 3
-	257,        //2^8  + 1
-	521,        //2^9  + 9
-	1031,       //2^10 + 7
-	2053,       //2^11 + 5
-	4099,       //2^12 + 3
-	8209,       //2^13 + 17
-	16411,      //2^14 + 27
-	32771,      //2^15 + 3
-	65537,      //2^16 + 1
-	131101,     //2^17 + 29
-	262147,     //2^18 + 3
-	524309,     //2^19 + 21
-	1048583,    //2^20 + 7
-	2097169,    //2^21 + 17
-	4194319,    //2^22 + 15
-	8388617,    //2^23 + 9
-	16777259,   //2^24 + 43
-	33554467,   //2^25 + 35
-	67108879,   //2^26 + 15
-	134217757,  //2^27 + 29
-	268435459,  //2^28 + 3
-	536870923,  //2^29 + 11
-	1073741827, //2^30 + 3
+	5,
+	13,
+	23,
+	47,
+	97,
+	193,
+	389,
+	769,
+	1543,
+	3079,
+	6151,
+	12289,
+	24593,
+	49157,
+	98317,
+	196613,
+	393241,
+	786433,
+	1572869,
+	3145739,
+	6291469,
+	12582917,
+	25165843,
+	50331653,
+	100663319,
+	201326611,
+	402653189,
+	805306457,
+	1610612741,
 	0,
 };
 
-static int
+static inline int
 next_prime(int n)
 {
 	int i = 0;
 	while(n > primes[i]){
 		i++;
-		assert(primes[i]); // realistically this should never happen
+		cpAssert(primes[i], "Tried to resize a hash table to a size greater than 1610612741 O_o"); // realistically this should never happen
 	}
 	
 	return primes[i];

data/ext/chipmunk/rb_chipmunk.c

@@ -1,109 +1,125 @@
-/* Copyright (c) 2007 Scott Lembcke
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
- 
-#include "chipmunk.h"
-
-#include "ruby.h"
-#include "rb_chipmunk.h"
-
-VALUE m_Chipmunk;
-
-ID id_parent;
-
-static VALUE
-rb_get_cp_bias_coef(VALUE self)
-{
-	return rb_float_new(cp_bias_coef);
-}
-
-static VALUE
-rb_set_cp_bias_coef(VALUE self, VALUE num)
-{
-	cp_bias_coef = NUM2DBL(num);
-	return num;
-}
-
-static VALUE
-rb_get_cp_collision_slop(VALUE self)
-{
-	return rb_float_new(cp_collision_slop);
-}
-
-static VALUE
-rb_set_cp_collision_slop(VALUE self, VALUE num)
-{
-	cp_collision_slop = NUM2DBL(num);
-	return num;
-}
-
-static VALUE
-rb_momentForCircle(VALUE self, VALUE m, VALUE r1, VALUE r2, VALUE offset)
-{
-	cpFloat i = cpMomentForCircle(NUM2DBL(m), NUM2DBL(r1), NUM2DBL(r2), *VGET(offset));
-	return rb_float_new(i);
-}
-
-static VALUE
-rb_momentForPoly(VALUE self, VALUE m, VALUE arr, VALUE offset)
-{
-	Check_Type(arr, T_ARRAY);
-	int numVerts = RARRAY_LEN(arr);
-	cpVect verts[numVerts];
-	
-	for(int i=0; i<numVerts; i++)
-		verts[i] = *VGET(RARRAY_PTR(arr)[i]);
-	
-	cpFloat inertia = cpMomentForPoly(NUM2DBL(m), numVerts, verts, *VGET(offset));
-	return rb_float_new(inertia);
-}
-
-static VALUE
-rb_dampedSpring(VALUE self, VALUE a, VALUE b, VALUE r1, VALUE r2, VALUE len, VALUE k, VALUE dmp, VALUE dt)
-{
-	cpDampedSpring(BODY(a), BODY(b), *VGET(r1), *VGET(r2), NUM2DBL(len), NUM2DBL(k), NUM2DBL(dmp), NUM2DBL(dt));
-	return Qnil;
-}
-
-void
-Init_chipmunk(void)
-{
-	id_parent = rb_intern("parent");
-	
-	cpInitChipmunk();
-	
-	m_Chipmunk = rb_define_module("CP");
-	rb_define_module_function(m_Chipmunk, "bias_coef", rb_get_cp_bias_coef, 0);
-	rb_define_module_function(m_Chipmunk, "bias_coef=", rb_set_cp_bias_coef, 1);
-	rb_define_module_function(m_Chipmunk, "collision_slop", rb_get_cp_collision_slop, 0);
-	rb_define_module_function(m_Chipmunk, "collision_slop=", rb_set_cp_collision_slop, 1);
-	
-	rb_define_module_function(m_Chipmunk, "moment_for_circle", rb_momentForCircle, 4);
-	rb_define_module_function(m_Chipmunk, "moment_for_poly", rb_momentForPoly, 3);
-	
-	rb_define_module_function(m_Chipmunk, "damped_spring", rb_dampedSpring, 8);
-	
-	Init_cpVect();
-	Init_cpBB();
-	Init_cpBody();
-	Init_cpShape();
-	Init_cpJoint();
-	Init_cpSpace();
-}
+/* Copyright (c) 2007 Scott Lembcke
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+
+#include "chipmunk.h"
+
+#include "ruby.h"
+#include "rb_chipmunk.h"
+
+VALUE m_Chipmunk;
+
+ID id_parent;
+
+static VALUE
+rb_get_cp_bias_coef(VALUE self)
+{
+	return rb_float_new(cp_bias_coef);
+}
+
+static VALUE
+rb_set_cp_bias_coef(VALUE self, VALUE num)
+{
+	cp_bias_coef = NUM2DBL(num);
+	return num;
+}
+
+static VALUE
+rb_get_cp_collision_slop(VALUE self)
+{
+	return rb_float_new(cp_collision_slop);
+}
+
+static VALUE
+rb_set_cp_collision_slop(VALUE self, VALUE num)
+{
+	cp_collision_slop = NUM2DBL(num);
+	return num;
+}
+
+static VALUE
+rb_momentForCircle(VALUE self, VALUE m, VALUE r1, VALUE r2, VALUE offset)
+{
+	cpFloat i = cpMomentForCircle(NUM2DBL(m), NUM2DBL(r1), NUM2DBL(r2), *VGET(offset));
+	return rb_float_new(i);
+}
+
+static VALUE
+rb_momentForPoly(VALUE self, VALUE m, VALUE arr, VALUE offset)
+{
+	Check_Type(arr, T_ARRAY);
+	int numVerts = RARRAY_LEN(arr);
+	VALUE *ary_ptr = RARRAY_PTR(arr);
+	cpVect verts[numVerts];
+	
+	for(int i=0; i<numVerts; i++)
+		verts[i] = *VGET(ary_ptr[i]);
+	
+	cpFloat inertia = cpMomentForPoly(NUM2DBL(m), numVerts, verts, *VGET(offset));
+	return rb_float_new(inertia);
+}
+
+static VALUE
+rb_momentForSegment(VALUE self, VALUE m, VALUE a, VALUE b)
+{
+  cpFloat i = cpMomentForSegment(NUM2DBL(m), *VGET(a), *VGET(b));
+  return rb_float_new(i);
+}
+
+
+void
+Init_chipmunk(void)
+{
+  id_parent = rb_intern("parent");
+	
+  cpInitChipmunk();
+	
+  rb_eval_string("Float::INFINITY = 1.0/0.0");
+	
+  m_Chipmunk = rb_define_module("CP");
+  rb_define_module_function(m_Chipmunk, "bias_coef", 
+    rb_get_cp_bias_coef, 0);
+  rb_define_module_function(m_Chipmunk, "bias_coef=", 
+    rb_set_cp_bias_coef, 1);
+  rb_define_module_function(m_Chipmunk, "collision_slop",
+    rb_get_cp_collision_slop, 0);  
+  rb_define_module_function(m_Chipmunk, "collision_slop=",
+    rb_set_cp_collision_slop, 1);	
+  rb_define_module_function(m_Chipmunk, "moment_for_circle", 
+    rb_momentForCircle, 4);
+  rb_define_module_function(m_Chipmunk, "moment_for_poly", 
+    rb_momentForPoly, 3);
+  rb_define_module_function(m_Chipmunk, "moment_for_segment",
+    rb_momentForSegment, 3);
+  rb_define_const(m_Chipmunk, "INFINITY", rb_float_new(INFINITY)); 
+  rb_define_const(m_Chipmunk, "VERSION" ,
+    rb_str_new2(cpVersionString));
+	
+  Init_cpVect();
+  Init_cpArbiter(); 
+  Init_cpBB();
+  Init_cpBody();
+  Init_cpShape();
+  Init_cpConstraint();
+  Init_cpSpace();
+  
+}