chipmunk 4.1.0

data/ext/chipmunk/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+$CFLAGS += ' -std=gnu99 -ffast-math'
+create_makefile('chipmunk')

data/ext/chipmunk/prime.h

@@ -0,0 +1,68 @@
+/* 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.
+ */
+ 
+// Used for resizing hash tables.
+// Values approximately double.
+
+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
+	0,
+};
+
+static int
+next_prime(int n)
+{
+	int i = 0;
+	while(n > primes[i]){
+		i++;
+		assert(primes[i]); // realistically this should never happen
+	}
+	
+	return primes[i];
+}

data/ext/chipmunk/rb_chipmunk.c

@@ -0,0 +1,109 @@
+/* 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();
+}

data/ext/chipmunk/rb_chipmunk.h

@@ -0,0 +1,77 @@
+/* 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.
+ */
+ 
+extern VALUE m_Chipmunk;
+
+extern VALUE c_cpVect;
+extern VALUE c_cpBB;
+extern VALUE c_cpBody;
+extern VALUE m_cpShape;
+extern VALUE c_cpCircleShape;
+extern VALUE c_cpSegmentShape;
+extern VALUE c_cpPolyShape;
+extern VALUE m_cpJoint;
+extern VALUE c_cpSpace;
+
+extern ID id_parent;
+
+static inline VALUE
+VNEW(cpVect v)
+{
+	cpVect *ptr = malloc(sizeof(cpVect));
+	*ptr = v;
+	return Data_Wrap_Struct(c_cpVect, NULL, free, ptr);	
+}
+
+static inline VALUE
+VWRAP(VALUE parent, cpVect *v)
+{
+	VALUE vec_obj = Data_Wrap_Struct(c_cpVect, NULL, NULL, v);
+	rb_ivar_set(vec_obj, id_parent, parent);
+	
+	return vec_obj;	
+}
+
+#define GETTER_TEMPLATE(func_name, klass, klass_name, type)\
+static inline type *\
+func_name(VALUE self)\
+{\
+	if(!rb_obj_is_kind_of(self, klass))\
+		rb_raise(rb_eTypeError, "wrong argument type %s (expected CP::klass_name)", rb_obj_classname(self));\
+	type *ptr;\
+	Data_Get_Struct(self, type, ptr);\
+	return ptr;\
+}\
+
+GETTER_TEMPLATE(VGET , c_cpVect , Vec2 , cpVect )
+GETTER_TEMPLATE(BBGET, c_cpBB   , BB   , cpBB   )
+GETTER_TEMPLATE(BODY , c_cpBody , Body , cpBody )
+GETTER_TEMPLATE(SHAPE, m_cpShape, Shape, cpShape)
+GETTER_TEMPLATE(JOINT, m_cpJoint, Joint, cpJoint)
+GETTER_TEMPLATE(SPACE, c_cpSpace, Space, cpSpace)
+
+void Init_chipmunk(void);
+void Init_cpVect();
+void Init_cpBB();
+void Init_cpBody();
+void Init_cpShape();
+void Init_cpJoint();
+void Init_cpSpace();

data/ext/chipmunk/rb_cpBB.c

@@ -0,0 +1,154 @@
+/* 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 c_cpBB;
+
+static VALUE
+rb_cpBBAlloc(VALUE klass)
+{
+	cpBB *bb = malloc(sizeof(cpBB));
+	return Data_Wrap_Struct(klass, NULL, free, bb);
+}
+
+static VALUE
+rb_cpBBInitialize(VALUE self, VALUE l, VALUE b, VALUE r, VALUE t)
+{
+	cpBB *bb = BBGET(self);
+	bb->l = NUM2DBL(l);
+	bb->b = NUM2DBL(b);
+	bb->r = NUM2DBL(r);
+	bb->t = NUM2DBL(t);
+	
+	return self;
+}
+
+static VALUE
+rb_cpBBintersects(VALUE self, VALUE other)
+{
+	int bool = cpBBintersects(*BBGET(self), *BBGET(other));
+	return bool ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_cpBBClampVect(VALUE self, VALUE v)
+{
+	return VNEW(cpBBClampVect(*BBGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpBBWrapVect(VALUE self, VALUE v)
+{
+	return VNEW(cpBBWrapVect(*BBGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpBBGetL(VALUE self)
+{
+	return rb_float_new(BBGET(self)->l);
+}
+
+static VALUE
+rb_cpBBGetB(VALUE self)
+{
+	return rb_float_new(BBGET(self)->b);
+}
+
+static VALUE
+rb_cpBBGetR(VALUE self)
+{
+	return rb_float_new(BBGET(self)->r);
+}
+
+static VALUE
+rb_cpBBGetT(VALUE self)
+{
+	return rb_float_new(BBGET(self)->t);
+}
+
+static VALUE
+rb_cpBBSetL(VALUE self, VALUE val)
+{
+	BBGET(self)->l = NUM2DBL(val);
+	return val;
+}
+
+static VALUE
+rb_cpBBSetB(VALUE self, VALUE val)
+{
+	BBGET(self)->b = NUM2DBL(val);
+	return val;
+}
+
+static VALUE
+rb_cpBBSetR(VALUE self, VALUE val)
+{
+	BBGET(self)->r = NUM2DBL(val);
+	return val;
+}
+
+static VALUE
+rb_cpBBSetT(VALUE self, VALUE val)
+{
+	BBGET(self)->t = NUM2DBL(val);
+	return val;
+}
+
+static VALUE
+rb_cpBBToString(VALUE self)
+{
+	char str[256];
+	cpBB *bb = BBGET(self);
+	
+	sprintf(str, "#<CP::BB:(% .3f, % .3f) -> (% .3f, % .3f)>", bb->l, bb->b, bb->r, bb->t);
+	
+	return rb_str_new2(str);
+}
+
+void
+Init_cpBB(void)
+{
+	c_cpBB = rb_define_class_under(m_Chipmunk, "BB", rb_cObject);
+	rb_define_alloc_func(c_cpBB, rb_cpBBAlloc);
+	rb_define_method(c_cpBB, "initialize", rb_cpBBInitialize, 4);
+	
+	rb_define_method(c_cpBB, "l", rb_cpBBGetL, 0);
+	rb_define_method(c_cpBB, "b", rb_cpBBGetB, 0);
+	rb_define_method(c_cpBB, "r", rb_cpBBGetR, 0);
+	rb_define_method(c_cpBB, "t", rb_cpBBGetT, 0);
+
+	rb_define_method(c_cpBB, "l=", rb_cpBBSetL, 1);
+	rb_define_method(c_cpBB, "b=", rb_cpBBSetB, 1);
+	rb_define_method(c_cpBB, "r=", rb_cpBBSetR, 1);
+	rb_define_method(c_cpBB, "t=", rb_cpBBSetT, 1);
+
+	rb_define_method(c_cpBB, "intersect?", rb_cpBBintersects, 1);
+	//containsBB
+	//containsVect
+	rb_define_method(c_cpBB, "clamp_vect", rb_cpBBClampVect, 1);
+	rb_define_method(c_cpBB, "wrap_vect", rb_cpBBWrapVect, 1);
+	
+	rb_define_method(c_cpBB, "to_s", rb_cpBBToString, 0);
+}

data/ext/chipmunk/rb_cpBody.c

@@ -0,0 +1,239 @@
+/* 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 c_cpBody;
+
+static VALUE
+rb_cpBodyAlloc(VALUE klass)
+{
+	cpBody *body = cpBodyNew(1.0f, 1.0f);
+	return Data_Wrap_Struct(klass, NULL, cpBodyFree, body);
+}
+
+static VALUE
+rb_cpBodyInitialize(VALUE self, VALUE m, VALUE i)
+{
+	cpBody *body = BODY(self);
+	cpBodyInit(body, NUM2DBL(m), NUM2DBL(i));
+	
+	return self;
+}
+
+static VALUE
+rb_cpBodyGetMass(VALUE self)
+{
+	return rb_float_new(BODY(self)->m);
+}
+
+static VALUE
+rb_cpBodyGetMoment(VALUE self)
+{
+	return rb_float_new(BODY(self)->i);
+}
+
+static VALUE
+rb_cpBodyGetPos(VALUE self)
+{
+	return VWRAP(self, &BODY(self)->p);
+}
+
+static VALUE
+rb_cpBodyGetVel(VALUE self)
+{
+	return VWRAP(self, &BODY(self)->v);
+}
+
+static VALUE
+rb_cpBodyGetForce(VALUE self)
+{
+	return VWRAP(self, &BODY(self)->f);
+}
+
+static VALUE
+rb_cpBodyGetAngle(VALUE self)
+{
+	return rb_float_new(BODY(self)->a);
+}
+
+static VALUE
+rb_cpBodyGetAVel(VALUE self)
+{
+	return rb_float_new(BODY(self)->w);
+}
+
+static VALUE
+rb_cpBodyGetTorque(VALUE self)
+{
+	return rb_float_new(BODY(self)->t);
+}
+
+static VALUE
+rb_cpBodyGetRot(VALUE self)
+{
+	return VWRAP(self, &BODY(self)->rot);
+}
+
+
+static VALUE
+rb_cpBodySetMass(VALUE self, VALUE val)
+{
+	cpBodySetMass(BODY(self), NUM2DBL(val));
+	return val;
+}
+
+static VALUE
+rb_cpBodySetMoment(VALUE self, VALUE val)
+{
+	cpBodySetMoment(BODY(self), NUM2DBL(val));
+	return val;
+}
+
+static VALUE
+rb_cpBodySetPos(VALUE self, VALUE val)
+{
+	BODY(self)->p = *VGET(val);
+	return val;
+}
+
+static VALUE
+rb_cpBodySetVel(VALUE self, VALUE val)
+{
+	BODY(self)->v = *VGET(val);
+	return val;
+}
+
+static VALUE
+rb_cpBodySetForce(VALUE self, VALUE val)
+{
+	BODY(self)->f = *VGET(val);
+	return val;
+}
+
+static VALUE
+rb_cpBodySetAngle(VALUE self, VALUE val)
+{
+	cpBodySetAngle(BODY(self), NUM2DBL(val));
+	return val;
+}
+
+static VALUE
+rb_cpBodySetAVel(VALUE self, VALUE val)
+{
+	BODY(self)->w = NUM2DBL(val);
+	return val;
+}
+
+static VALUE
+rb_cpBodySetTorque(VALUE self, VALUE val)
+{
+	BODY(self)->t = NUM2DBL(val);
+	return val;
+}
+
+static VALUE
+rb_cpBodyLocal2World(VALUE self, VALUE v)
+{
+	return VNEW(cpBodyLocal2World(BODY(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpBodyWorld2Local(VALUE self, VALUE v)
+{
+	return VNEW(cpBodyWorld2Local(BODY(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpBodyResetForces(VALUE self)
+{
+	cpBodyResetForces(BODY(self));
+	return Qnil;
+}
+
+static VALUE
+rb_cpBodyApplyForce(VALUE self, VALUE f, VALUE r)
+{
+	cpBodyApplyForce(BODY(self), *VGET(f), *VGET(r));
+	return Qnil;
+}
+
+static VALUE
+rb_cpBodyApplyImpulse(VALUE self, VALUE j, VALUE r)
+{
+	cpBodyApplyImpulse(BODY(self), *VGET(j), *VGET(r));
+	return Qnil;
+}
+
+static VALUE
+rb_cpBodyUpdateVelocity(VALUE self, VALUE g, VALUE dmp, VALUE dt)
+{
+	cpBodyUpdateVelocity(BODY(self), *VGET(g), NUM2DBL(dmp), NUM2DBL(dt));
+	return Qnil;
+}
+
+static VALUE
+rb_cpBodyUpdatePosition(VALUE self, VALUE dt)
+{
+	cpBodyUpdatePosition(BODY(self), NUM2DBL(dt));
+	return Qnil;
+}
+
+
+void
+Init_cpBody(void)
+{
+	c_cpBody = rb_define_class_under(m_Chipmunk, "Body", rb_cObject);
+	rb_define_alloc_func(c_cpBody, rb_cpBodyAlloc);
+	rb_define_method(c_cpBody, "initialize", rb_cpBodyInitialize, 2);
+
+	rb_define_method(c_cpBody, "m" , rb_cpBodyGetMass, 0);
+	rb_define_method(c_cpBody, "i" , rb_cpBodyGetMoment, 0);	
+	rb_define_method(c_cpBody, "p" , rb_cpBodyGetPos, 0);
+	rb_define_method(c_cpBody, "v" , rb_cpBodyGetVel, 0);
+	rb_define_method(c_cpBody, "f" , rb_cpBodyGetForce, 0);
+	rb_define_method(c_cpBody, "a" , rb_cpBodyGetAngle, 0);
+	rb_define_method(c_cpBody, "w" , rb_cpBodyGetAVel, 0);
+	rb_define_method(c_cpBody, "t" , rb_cpBodyGetTorque, 0);
+	rb_define_method(c_cpBody, "rot", rb_cpBodyGetRot, 0);
+	
+	rb_define_method(c_cpBody, "m=", rb_cpBodySetMass, 1);
+	rb_define_method(c_cpBody, "i=", rb_cpBodySetMoment, 1);
+	rb_define_method(c_cpBody, "p=", rb_cpBodySetPos, 1);
+	rb_define_method(c_cpBody, "v=", rb_cpBodySetVel, 1);
+	rb_define_method(c_cpBody, "f=", rb_cpBodySetForce, 1);
+	rb_define_method(c_cpBody, "a=", rb_cpBodySetAngle, 1);
+	rb_define_method(c_cpBody, "w=", rb_cpBodySetAVel, 1);
+	rb_define_method(c_cpBody, "t=", rb_cpBodySetTorque, 1);
+	
+	rb_define_method(c_cpBody, "local2world", rb_cpBodyLocal2World, 1);
+	rb_define_method(c_cpBody, "world2local", rb_cpBodyWorld2Local, 1);
+
+	rb_define_method(c_cpBody, "reset_forces", rb_cpBodyResetForces, 0);
+	rb_define_method(c_cpBody, "apply_force", rb_cpBodyApplyForce, 2);
+	rb_define_method(c_cpBody, "apply_impulse", rb_cpBodyApplyImpulse, 2);
+	
+	rb_define_method(c_cpBody, "update_velocity", rb_cpBodyUpdateVelocity, 3);
+	rb_define_method(c_cpBody, "update_position", rb_cpBodyUpdatePosition, 1);
+}