chipmunk 4.1.0-x86-mswin32 → 5.3.4.0-x86-mswin32

data/ext/chipmunk/rb_chipmunk.h

@@ -28,8 +28,11 @@ extern VALUE m_cpShape;
 extern VALUE c_cpCircleShape;
 extern VALUE c_cpSegmentShape;
 extern VALUE c_cpPolyShape;
-extern VALUE m_cpJoint;
+extern VALUE m_cpConstraint;
 extern VALUE c_cpSpace;
+extern VALUE c_cpArbiter;
+extern VALUE c_cpStaticBody;
+extern VALUE c_cpSegmentQueryInfo;
 
 extern ID id_parent;
 
@@ -50,28 +53,53 @@ VWRAP(VALUE parent, cpVect *v)
 	return vec_obj;	
 }
 
-#define GETTER_TEMPLATE(func_name, klass, klass_name, type)\
+#define GETTER_TEMPLATE(func_name, klass, 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));\
+	if(!rb_obj_is_kind_of(self, klass)){\
+		VALUE klass_name = rb_funcall(klass, rb_intern("to_s"), 0);\
+		rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(self), StringValuePtr(klass_name));\
+	}\
 	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)
+GETTER_TEMPLATE(VGET , c_cpVect , cpVect )
+GETTER_TEMPLATE(BBGET, c_cpBB   , cpBB   )
+GETTER_TEMPLATE(BODY , c_cpBody , cpBody )
+GETTER_TEMPLATE(STATICBODY , c_cpStaticBody , cpBody)
+GETTER_TEMPLATE(SHAPE, m_cpShape, cpShape)
+GETTER_TEMPLATE(CONSTRAINT, m_cpConstraint, cpConstraint)
+GETTER_TEMPLATE(SPACE, c_cpSpace, cpSpace)
+GETTER_TEMPLATE(ARBITER, c_cpArbiter, cpArbiter)
+/* GETTER_TEMPLATE(SPACEHASH, c_cpSpaceHash, cpSpaceHash) */
+
+// Helper to wrap cpArbter objects.
+VALUE ARBWRAP(cpArbiter *arb);
+
+//Helper that allocates and initializes a SegmenQueryInfo struct
+VALUE rb_cpSegmentQueryInfoNew(VALUE shape, VALUE t, VALUE n);
 
 void Init_chipmunk(void);
 void Init_cpVect();
 void Init_cpBB();
 void Init_cpBody();
 void Init_cpShape();
-void Init_cpJoint();
+void Init_cpConstraint();
 void Init_cpSpace();
+void Init_cpArbiter(void);
+
+// transforms a boolean VALUE to an int
+#define CP_BOOL_INT(VAL) (((VAL) == Qnil) || ((VAL) == Qfalse) ? 0 : 1)
+
+// transforms a C value (pointer or int) to Qtrue of Qfalse
+// For consistency with RBH_BOOL_INT. 
+#define CP_INT_BOOL(VAL) ((VAL) ? Qtrue : Qfalse)
+ 
+
+
+
+
+

data/ext/chipmunk/rb_cpArbiter.c

@@ -0,0 +1,253 @@
+/* Copyright (c) 2010 Beoran (beoran@rubyforge.org)
+ * 
+ * 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 c_cpArbiter;
+
+/*
+* I quote the C docs on cpArbiter: 
+* Memory Management
+* You should never need to create an arbiter, nor will you ever need to free 
+* one as they are handled by the space. More importantly, because they are 
+* handled by the space you should never hold onto a reference to an arbiter as 
+* you don't know when they will be destroyed. Use them within the callback 
+* where they are given to you and then forget about them or copy out the 
+* information you need from them. 
+* 
+* This means that Arbiter doesn't need an initialize, and also 
+* does NOT need any garbage collection.
+*/
+
+VALUE ARBWRAP(cpArbiter *arb)
+{
+  return Data_Wrap_Struct(c_cpArbiter, NULL, NULL, arb);
+}
+
+
+/*
+static VALUE
+rb_cpArbiterAlloc(VALUE klass)
+{
+  cpArbiter *arb = cpArbiterAlloc();
+  return Data_Wrap_Struct(klass, NULL, cpArbiterFree, arb);
+}
+
+
+static VALUE
+rb_cpArbiterInitialize(VALUE self, VALUE a, VALUE b, VALUE r, VALUE t)
+{
+  cpArbiter *arb = ARBITER(self);
+  cpShape   *sa  = SHAPE(a);
+  cpShape   *sb  = SHAPE(b);  
+  cpArbiterInit(arb, sa, sb);
+  return self;
+}
+*/
+
+static VALUE
+rb_cpArbiterTotalImpulse(VALUE self) {
+  cpArbiter *arb = ARBITER(self);  
+  return VNEW(cpArbiterTotalImpulse(arb));
+}
+
+static VALUE
+rb_cpArbiterTotalImpulseWithFriction(VALUE self) {
+  cpArbiter *arb = ARBITER(self);  
+  return VNEW(cpArbiterTotalImpulseWithFriction(arb));
+}
+
+static VALUE
+rb_cpArbiterGetImpulse(int argc, VALUE *argv, VALUE self)
+{
+  VALUE friction = Qnil;
+  rb_scan_args(argc, argv, "01", &friction);
+  if (NIL_P(friction) || friction == Qnil) {
+    return rb_cpArbiterTotalImpulse(self);
+  } 
+  /* Here, it's with friction */
+  return rb_cpArbiterTotalImpulseWithFriction(self);
+}
+
+
+static VALUE
+rb_cpArbiterIgnore(VALUE self) {
+  cpArbiter *arb = ARBITER(self);
+  cpArbiterIgnore(arb);
+  return Qnil;
+}
+
+static VALUE
+rb_cpArbiterGetShapes(VALUE self) {
+  cpArbiter *arb = ARBITER(self);
+  CP_ARBITER_GET_SHAPES(arb, a, b)    
+  return rb_ary_new3(2, (VALUE)a->data, (VALUE)b->data);
+}
+
+static VALUE
+rb_cpArbiterGetA(VALUE self) {
+  cpArbiter *arb = ARBITER(self);
+  CP_ARBITER_GET_SHAPES(arb, a, b)    
+  return (VALUE)a->data;
+}
+
+static VALUE
+rb_cpArbiterGetB(VALUE self) {
+  cpArbiter *arb = ARBITER(self);
+  CP_ARBITER_GET_SHAPES(arb, a, b)    
+  return (VALUE)b->data;
+}
+
+static VALUE 
+rb_cpArbiterGetE(VALUE self) {
+  return rb_float_new(ARBITER(self)->e);
+}  
+ 
+static VALUE 
+rb_cpArbiterSetE(VALUE self, VALUE e) {
+  ARBITER(self)->e = NUM2DBL(e);
+  return e;
+}  
+
+static VALUE 
+rb_cpArbiterGetCount(VALUE self) {
+  return INT2NUM(cpArbiterGetCount(ARBITER(self)));
+}  
+ 
+static VALUE 
+rb_cpArbiterGetU(VALUE self) {
+  return rb_float_new(ARBITER(self)->u);
+}  
+
+static VALUE 
+rb_cpArbiterSetU(VALUE self, VALUE u) {
+  ARBITER(self)->u = NUM2DBL(u);
+  return u;
+}  
+
+static VALUE
+rb_cpArbiterIsFirstContact(VALUE self) {
+  int bool = cpArbiterIsFirstContact(ARBITER(self));
+  return bool ? Qtrue : Qfalse;
+}
+
+static int arbiterBadIndex(cpArbiter *arb, int i)  {
+  return ((i<0) || (i >= cpArbiterGetCount(arb)));
+}  
+
+
+static VALUE
+rb_cpArbiterGetNormal(VALUE self, VALUE index) {
+  cpArbiter *arb = ARBITER(self);
+  int i          = NUM2LONG(index);    
+  if (arbiterBadIndex(arb, i)) {
+    rb_raise(rb_eIndexError, "No such normal.");
+  }
+  return VNEW(cpArbiterGetNormal(arb, i));
+}
+
+static VALUE
+rb_cpArbiterGetPoint(VALUE self, VALUE index) {
+  cpArbiter *arb = ARBITER(self);
+  int i          = NUM2LONG(index);
+  if (arbiterBadIndex(arb, i)) {
+    rb_raise(rb_eIndexError, "No such contact point.");
+  }    
+  return VNEW(cpArbiterGetPoint(arb, i));
+}
+
+static VALUE
+rb_cpArbiterGetDepth(VALUE self, VALUE index) {
+  cpArbiter *arb = ARBITER(self);
+  int i          = NUM2LONG(index);    
+  if (arbiterBadIndex(arb, i)) {
+    rb_raise(rb_eIndexError, "No such depth.");
+  }
+  // there"s a typo in the cpArbiter.h class.
+  return rb_float_new(cpArbiteGetDepth(arb, i));
+}
+
+
+static VALUE
+rb_cpArbiterToString(VALUE self)
+{
+  char str[256];
+  cpArbiter *arb = ARBITER(self);  
+  sprintf(str, "#<CP::Arbiter:%p>", arb);  
+  return rb_str_new2(str);
+}
+
+static VALUE 
+rb_cpArbiterEachContact(VALUE self) 
+{ 
+  cpArbiter *arb = ARBITER(self);
+  int i = 0;
+  for( i = 0; i < cpArbiterGetCount(arb); i++) {
+    VALUE index = INT2NUM(i);
+    VALUE contact, normal;
+    normal  = rb_cpArbiterGetNormal(self, index);
+    contact = rb_cpArbiterGetPoint(self, index);
+    /* Yield an array of contact and normal */
+    rb_yield(rb_ary_new3(2, contact, normal));
+  }  
+  return self;
+}
+
+
+
+void
+Init_cpArbiter(void)
+{
+  c_cpArbiter = rb_define_class_under(m_Chipmunk, "Arbiter", rb_cObject);
+  /*  
+  rb_define_alloc_func(c_cpArbiter, rb_cpArbiterAlloc);  
+  rb_define_method(c_cpArbiter    , "initialize", rb_cpArbiterInitialize, 2);
+  */
+  rb_define_method(c_cpArbiter, "a", rb_cpArbiterGetA, 0);
+  rb_define_method(c_cpArbiter, "b", rb_cpArbiterGetB, 0);  
+  rb_define_method(c_cpArbiter, "e" , rb_cpArbiterGetE, 0);
+  rb_define_method(c_cpArbiter, "u" , rb_cpArbiterGetU, 0);
+  rb_define_method(c_cpArbiter, "e=", rb_cpArbiterSetE, 1);
+  rb_define_method(c_cpArbiter, "u=", rb_cpArbiterSetU, 1);
+
+  rb_define_method(c_cpArbiter, "point"   , rb_cpArbiterGetPoint    , 1);  
+  rb_define_method(c_cpArbiter, "normal"  , rb_cpArbiterGetNormal   , 1);
+  rb_define_method(c_cpArbiter, "normal"  , rb_cpArbiterGetDepth    , 1);
+  rb_define_method(c_cpArbiter, "impulse" , rb_cpArbiterGetImpulse  , -1);
+  
+  rb_define_method(c_cpArbiter, "to_s", rb_cpArbiterToString, 0);
+  
+  rb_define_method(c_cpArbiter, "first_contact?", rb_cpArbiterIsFirstContact, 0);
+  rb_define_method(c_cpArbiter, "count"    , rb_cpArbiterGetCount, 0);
+  rb_define_method(c_cpArbiter, "contacts" , rb_cpArbiterGetCount, 0);
+  rb_define_method(c_cpArbiter, "size"     , rb_cpArbiterGetCount, 0);
+  rb_define_method(c_cpArbiter, "length"   , rb_cpArbiterGetCount, 0);
+  rb_define_method(c_cpArbiter, "each_contact"  , rb_cpArbiterEachContact   , 0);
+  
+  rb_define_method(c_cpArbiter, "shapes"        , rb_cpArbiterGetShapes     , 0);
+  /* Ignore is new in the 5.x API, I think. */
+  rb_define_method(c_cpArbiter, "ignore"        , rb_cpArbiterIgnore        , 0);
+    
+}

data/ext/chipmunk/rb_cpBB.c

@@ -18,7 +18,8 @@
  * 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"
@@ -26,6 +27,12 @@
 
 VALUE c_cpBB;
 
+static VALUE BBNEW(cpBB bb) {
+  cpBB *ptr = malloc(sizeof(cpBB));
+  *ptr = bb;
+  return Data_Wrap_Struct(c_cpBB, NULL, free, ptr); 
+}
+
 static VALUE
 rb_cpBBAlloc(VALUE klass)
 {
@@ -48,8 +55,34 @@ rb_cpBBInitialize(VALUE self, VALUE l, VALUE b, VALUE r, VALUE t)
 static VALUE
 rb_cpBBintersects(VALUE self, VALUE other)
 {
-	int bool = cpBBintersects(*BBGET(self), *BBGET(other));
-	return bool ? Qtrue : Qfalse;
+	int value = cpBBintersects(*BBGET(self), *BBGET(other));
+	return value ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_cpBBcontainsBB(VALUE self, VALUE other)
+{
+  int value = cpBBcontainsBB(*BBGET(self), *BBGET(other));
+  return value ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_cpBBcontainsVect(VALUE self, VALUE other)
+{
+  int value = cpBBcontainsVect(*BBGET(self), *VGET(other));
+  return value ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_cpBBcontains(VALUE self, VALUE other)
+{
+  if (rb_class_of(other) == c_cpBB) {  
+    return rb_cpBBcontainsBB(self, other);
+  } else if (rb_class_of(other) == c_cpVect) {
+    return rb_cpBBcontainsVect(self, other);
+  } 
+  rb_raise(rb_eArgError, "contains works only with a BB or A Vect2 argument");
+  return Qnil;
 }
 
 static VALUE
@@ -127,6 +160,17 @@ rb_cpBBToString(VALUE self)
 	return rb_str_new2(str);
 }
 
+static VALUE
+rb_cpBBmerge(VALUE self, VALUE other) {
+  return BBNEW(cpBBmerge(*BBGET(self), *BBGET(other)));
+}
+
+static VALUE
+rb_cpBBexpand(VALUE self, VALUE other) {
+  return BBNEW(cpBBexpand(*BBGET(self), *VGET(other)));
+}
+
+
 void
 Init_cpBB(void)
 {
@@ -145,10 +189,22 @@ Init_cpBB(void)
 	rb_define_method(c_cpBB, "t=", rb_cpBBSetT, 1);
 
 	rb_define_method(c_cpBB, "intersect?", rb_cpBBintersects, 1);
+  rb_define_method(c_cpBB, "intersects?", rb_cpBBintersects, 1); 
 	//containsBB
 	//containsVect
+  rb_define_method(c_cpBB, "contains?", rb_cpBBcontains, 1);
+  rb_define_method(c_cpBB, "contain?", rb_cpBBcontains, 1);
+   
+  rb_define_method(c_cpBB, "contains_bb?", rb_cpBBcontainsBB, 1);
+  rb_define_method(c_cpBB, "contain_bb?", rb_cpBBcontainsBB, 1);
+  rb_define_method(c_cpBB, "contains_vect?", rb_cpBBcontainsVect, 1);
+  rb_define_method(c_cpBB, "contain_vect?", rb_cpBBcontainsVect, 1);
+  
 	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, "wrap_vect" , rb_cpBBWrapVect, 1);
+  rb_define_method(c_cpBB, "merge"     , rb_cpBBmerge, 1);
+  rb_define_method(c_cpBB, "expand"    , rb_cpBBexpand, 1);
+   
 	
 	rb_define_method(c_cpBB, "to_s", rb_cpBBToString, 0);
 }

data/ext/chipmunk/rb_cpBody.c

@@ -19,17 +19,19 @@
  * SOFTWARE.
  */
  
+#include <stdlib.h>
 #include "chipmunk.h"
 
 #include "ruby.h"
 #include "rb_chipmunk.h"
 
 VALUE c_cpBody;
+VALUE c_cpStaticBody;
 
 static VALUE
 rb_cpBodyAlloc(VALUE klass)
 {
-	cpBody *body = cpBodyNew(1.0f, 1.0f);
+	cpBody *body = cpBodyNew(1.0f, 1.0f);   
 	return Data_Wrap_Struct(klass, NULL, cpBodyFree, body);
 }
 
@@ -38,22 +40,57 @@ rb_cpBodyInitialize(VALUE self, VALUE m, VALUE i)
 {
 	cpBody *body = BODY(self);
 	cpBodyInit(body, NUM2DBL(m), NUM2DBL(i));
-	
+  body->data   = (void *)self; 
 	return self;
 }
 
+static VALUE
+rb_cpBodyAllocStatic(VALUE klass)
+{
+  cpBody *body = cpBodyNewStatic();
+  return Data_Wrap_Struct(c_cpStaticBody, NULL, cpBodyFree, body);
+}
+
+static VALUE
+rb_cpBodyInitializeStatic(VALUE self)
+{
+  cpBody *body = STATICBODY(self);
+  cpBodyInitStatic(body);
+  body->data   = (void *)self;
+  return self;
+}
+
+static VALUE 
+rb_cpStaticBodyNew(VALUE klass) {
+  return rb_cpBodyInitializeStatic(rb_cpBodyAllocStatic(klass));
+}
+
+
 static VALUE
 rb_cpBodyGetMass(VALUE self)
 {
 	return rb_float_new(BODY(self)->m);
 }
 
+static VALUE
+rb_cpBodyGetMassInv(VALUE self)
+{
+  return rb_float_new(BODY(self)->m_inv);
+}
+
 static VALUE
 rb_cpBodyGetMoment(VALUE self)
 {
 	return rb_float_new(BODY(self)->i);
 }
 
+
+static VALUE
+rb_cpBodyGetMomentInv(VALUE self)
+{
+  return rb_float_new(BODY(self)->i_inv);
+}
+
 static VALUE
 rb_cpBodyGetPos(VALUE self)
 {
@@ -90,6 +127,19 @@ rb_cpBodyGetTorque(VALUE self)
 	return rb_float_new(BODY(self)->t);
 }
 
+static VALUE
+rb_cpBodyGetVLimit(VALUE self)
+{
+  return rb_float_new(BODY(self)->v_limit);
+}
+
+static VALUE
+rb_cpBodyGetWLimit(VALUE self)
+{
+  return rb_float_new(BODY(self)->w_limit);
+}
+
+
 static VALUE
 rb_cpBodyGetRot(VALUE self)
 {
@@ -153,6 +203,23 @@ rb_cpBodySetTorque(VALUE self, VALUE val)
 	return val;
 }
 
+
+static VALUE
+rb_cpBodySetVLimit(VALUE self, VALUE val)
+{
+  BODY(self)->v_limit = NUM2DBL(val);
+  return val;
+}
+
+static VALUE
+rb_cpBodySetWLimit(VALUE self, VALUE val)
+{
+  BODY(self)->w_limit = NUM2DBL(val);
+  return val;
+}
+
+
+
 static VALUE
 rb_cpBodyLocal2World(VALUE self, VALUE v)
 {
@@ -169,35 +236,178 @@ static VALUE
 rb_cpBodyResetForces(VALUE self)
 {
 	cpBodyResetForces(BODY(self));
-	return Qnil;
+	return self;
 }
 
 static VALUE
 rb_cpBodyApplyForce(VALUE self, VALUE f, VALUE r)
 {
 	cpBodyApplyForce(BODY(self), *VGET(f), *VGET(r));
-	return Qnil;
+	return self;
 }
 
 static VALUE
 rb_cpBodyApplyImpulse(VALUE self, VALUE j, VALUE r)
 {
 	cpBodyApplyImpulse(BODY(self), *VGET(j), *VGET(r));
-	return Qnil;
+	return self;
 }
 
 static VALUE
 rb_cpBodyUpdateVelocity(VALUE self, VALUE g, VALUE dmp, VALUE dt)
 {
 	cpBodyUpdateVelocity(BODY(self), *VGET(g), NUM2DBL(dmp), NUM2DBL(dt));
-	return Qnil;
+	return self;
 }
 
 static VALUE
 rb_cpBodyUpdatePosition(VALUE self, VALUE dt)
 {
 	cpBodyUpdatePosition(BODY(self), NUM2DBL(dt));
-	return Qnil;
+	return self;
+}
+
+static VALUE rb_cpBodyActivate(VALUE self) {
+  cpBodyActivate(BODY(self));
+  return self;
+}
+
+static cpBody * rb_cpBodySleepValidate(VALUE vbody) {
+  cpBody * body  = BODY(vbody);
+  cpSpace *space = body->space;  
+  if(!space) {
+    rb_raise(rb_eArgError, "Cannot put a body to sleep that has not been added to a space.");
+    return NULL;
+  }
+  if (cpBodyIsStatic(body) && cpBodyIsRogue(body)) { 
+    rb_raise(rb_eArgError, "Rogue AND static bodies cannot be put to sleep.");
+    return NULL;
+  }  
+  if(space->locked) { 
+     rb_raise(rb_eArgError, "Bodies can not be put to sleep during a query or a call to Space#add_collision_func. Put these calls into a post-step callback using Space#add_collision_handler.");
+     return NULL;
+  }
+  return body; 
+}
+
+static VALUE rb_cpBodySleep(VALUE self) {
+  cpBody * body = rb_cpBodySleepValidate(self);
+  cpBodySleep(body);
+  return self;
+}
+
+static VALUE rb_cpBodySleepWithGroup(VALUE self, VALUE vgroup) {
+  cpBody * group = NIL_P(vgroup) ? NULL : rb_cpBodySleepValidate(vgroup);
+  cpBody * body  = rb_cpBodySleepValidate(self);
+  
+  if (!cpBodyIsSleeping(group)) { 
+    rb_raise(rb_eArgError, "Cannot use a non-sleeping body as a group identifier.");
+  }  
+  cpBodySleepWithGroup(body, group);
+  return self;
+}
+
+
+static VALUE rb_cpBodyIsSleeping(VALUE self) {
+  return cpBodyIsSleeping(BODY(self)) ? Qtrue : Qfalse;
+}
+
+static VALUE rb_cpBodyIsStatic(VALUE self) {
+  cpBody * body = BODY(self);
+  cpBool stat   = 0; 
+  // cpBodyInitStatic(body);
+  stat = cpBodyIsStatic(body);  
+  return stat ? Qtrue : Qfalse;
+  // 
+}
+
+static VALUE rb_cpBodyIsRogue(VALUE self) {
+  return cpBodyIsRogue(BODY(self)) ? Qtrue : Qfalse;
+}
+
+ID id_velocity_func;
+ID id_speed_func;
+
+static int
+respondsTo(VALUE obj, ID method) {
+  VALUE value = rb_funcall(obj, rb_intern("respond_to?"), 1, ID2SYM(method));
+  return RTEST(value);
+}
+
+/*
+
+typedef void (*cpBodyVelocityFunc)(struct cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt);
+typedef void (*cpBodyPositionFunc)(struct cpBody *body, cpFloat dt);
+*/
+
+static void
+bodyVelocityCallback(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt) {
+  VALUE vbody     = (VALUE)(body->data); 
+  VALUE block     = rb_iv_get(vbody, "velocity_func");
+  VALUE vgravity  = VNEW(gravity);
+  VALUE vdamping  = rb_float_new(damping);
+  VALUE vdt       = rb_float_new(dt);
+  rb_funcall(block, rb_intern("call"), 4, vbody, vgravity, vdamping, vdt);
+}
+
+static VALUE 
+rb_cpBodySetVelocityFunc(int argc, VALUE *argv, VALUE self)
+{
+  VALUE block;
+  cpBody * body = BODY(self);  
+  rb_scan_args(argc, argv, "&", &block);
+  // Restore defaults if no block
+  if (NIL_P(block)) {
+    body->velocity_func = cpBodyUpdateVelocityDefault;
+    return Qnil;
+  }
+  // set block for use in callback
+  rb_iv_set(self, "velocity_func", block);
+  body->velocity_func = bodyVelocityCallback;
+  return self;
+}
+
+static void
+bodyPositionCallback(cpBody *body, cpFloat dt) {
+  VALUE vbody     = (VALUE)(body->data); 
+  VALUE block     = rb_iv_get(vbody, "position_func");
+  VALUE vdt       = rb_float_new(dt);
+  rb_funcall(block, rb_intern("call"), 2, vbody, vdt);
+}
+
+static VALUE 
+rb_cpBodySetPositionFunc(int argc, VALUE *argv, VALUE self)
+{
+  VALUE block;
+  cpBody * body = BODY(self);  
+  rb_scan_args(argc, argv, "&", &block);
+  // Restore defaults if no block
+  if (NIL_P(block)) {
+    body->velocity_func = cpBodyUpdateVelocityDefault;
+    return Qnil;
+  }
+  // set block for use in callback
+  rb_iv_set(self, "position_func", block);
+  body->position_func = bodyPositionCallback;
+  return self;
+}
+
+static VALUE
+rb_cpBodyGetData(VALUE self) {
+  return rb_iv_get(self, "data");
+}
+
+static VALUE
+rb_cpBodySetData(VALUE self, VALUE val) {
+  rb_iv_set(self, "data", val);
+  return val;
+}
+
+
+static VALUE
+rb_cpBodySlew(VALUE self, VALUE pos, VALUE dt) {
+  cpBodySlew(BODY(self), *VGET(pos), NUM2DBL(dt));
+  return self;
 }
 
 
@@ -207,16 +417,24 @@ 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);
+	
+	c_cpStaticBody = rb_define_class_under(m_Chipmunk, "StaticBody", c_cpBody);  
+  // rb_define_alloc_func will not work here, since superclass defines this.
+  // so, we define new here in stead.
+  rb_define_singleton_method(c_cpStaticBody, "new", rb_cpStaticBodyNew, 0);
+  rb_define_method(c_cpStaticBody, "initialize", rb_cpBodyInitializeStatic, 0);  
+  rb_define_singleton_method(c_cpBody, "new_static",  rb_cpStaticBodyNew, 0);
+
+	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);
@@ -227,6 +445,35 @@ Init_cpBody(void)
 	rb_define_method(c_cpBody, "w=", rb_cpBodySetAVel, 1);
 	rb_define_method(c_cpBody, "t=", rb_cpBodySetTorque, 1);
 	
+	rb_define_method(c_cpBody, "mass" , rb_cpBodyGetMass, 0);
+	rb_define_method(c_cpBody, "moment" , rb_cpBodyGetMoment, 0);	
+	rb_define_method(c_cpBody, "pos" , rb_cpBodyGetPos, 0);
+	rb_define_method(c_cpBody, "vel" , rb_cpBodyGetVel, 0);
+	rb_define_method(c_cpBody, "force" , rb_cpBodyGetForce, 0);
+	rb_define_method(c_cpBody, "angle" , rb_cpBodyGetAngle, 0);
+	rb_define_method(c_cpBody, "ang_vel" , rb_cpBodyGetAVel, 0);
+	rb_define_method(c_cpBody, "torque" , rb_cpBodyGetTorque, 0);
+	rb_define_method(c_cpBody, "rot", rb_cpBodyGetRot, 0);
+  
+  rb_define_method(c_cpBody, "m_inv"       , rb_cpBodyGetMassInv, 0);
+  rb_define_method(c_cpBody, "mass_inv"    , rb_cpBodyGetMassInv, 0);
+  rb_define_method(c_cpBody, "moment_inv"  , rb_cpBodyGetMomentInv, 0);
+  rb_define_method(c_cpBody, "v_limit"     , rb_cpBodyGetVLimit, 0);
+  rb_define_method(c_cpBody, "w_limit"     , rb_cpBodyGetWLimit, 0);
+
+	
+	rb_define_method(c_cpBody, "mass="    , rb_cpBodySetMass, 1);
+	rb_define_method(c_cpBody, "moment="  , rb_cpBodySetMoment, 1);
+	rb_define_method(c_cpBody, "pos="     , rb_cpBodySetPos, 1);
+	rb_define_method(c_cpBody, "vel="     , rb_cpBodySetVel, 1);
+	rb_define_method(c_cpBody, "force="   , rb_cpBodySetForce, 1);
+	rb_define_method(c_cpBody, "angle="   , rb_cpBodySetAngle, 1);
+	rb_define_method(c_cpBody, "ang_vel=" , rb_cpBodySetAVel, 1);
+	rb_define_method(c_cpBody, "torque="  , rb_cpBodySetTorque, 1);
+  rb_define_method(c_cpBody, "v_limit=" , rb_cpBodySetVLimit, 1);
+  rb_define_method(c_cpBody, "w_limit=" , rb_cpBodySetWLimit, 1);
+ 
+	
 	rb_define_method(c_cpBody, "local2world", rb_cpBodyLocal2World, 1);
 	rb_define_method(c_cpBody, "world2local", rb_cpBodyWorld2Local, 1);
 
@@ -236,4 +483,22 @@ Init_cpBody(void)
 	
 	rb_define_method(c_cpBody, "update_velocity", rb_cpBodyUpdateVelocity, 3);
 	rb_define_method(c_cpBody, "update_position", rb_cpBodyUpdatePosition, 1);
+  rb_define_method(c_cpBody, "slew"           , rb_cpBodySlew          , 2); 
+	
+	rb_define_method(c_cpBody, "static?", rb_cpBodyIsStatic, 0);
+	rb_define_method(c_cpBody, "rogue?", rb_cpBodyIsRogue, 0);
+	rb_define_method(c_cpBody, "sleeping?", rb_cpBodyIsSleeping, 0);
+	rb_define_method(c_cpBody, "sleep?", rb_cpBodyIsSleeping, 0);
+  rb_define_method(c_cpBody, "sleep_with_self" , rb_cpBodySleep, 0);
+  rb_define_method(c_cpBody, "sleep_self"      , rb_cpBodySleep, 0);
+  rb_define_method(c_cpBody, "sleep_alone"     , rb_cpBodySleep, 0);  
+	rb_define_method(c_cpBody, "sleep_with_group", rb_cpBodySleepWithGroup, 1);
+	rb_define_method(c_cpBody, "sleep_group"     , rb_cpBodySleepWithGroup, 1);
+	rb_define_method(c_cpBody, "activate"        , rb_cpBodyActivate   , 0);
+	rb_define_method(c_cpBody, "velocity_func"   , rb_cpBodySetVelocityFunc, -1);
+  rb_define_method(c_cpBody, "position_func"   , rb_cpBodySetPositionFunc, -1);
+  
+  rb_define_method(c_cpBody, "object="         , rb_cpBodySetData, 1);
+  rb_define_method(c_cpBody, "object"          , rb_cpBodyGetData, 0);
+	
 }