chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/rb_cpShape.c

@@ -22,6 +22,8 @@
 #include <stdlib.h>
 #include "chipmunk.h"
 #include "chipmunk_unsafe.h"
+// looks like certain functions I exposed are supposed to be private? 
+// #include "chipmunk_private.h"
 
 #include "ruby.h"
 #include "rb_chipmunk.h"
@@ -34,6 +36,7 @@ VALUE c_cpSegmentShape;
 VALUE c_cpPolyShape;
 
 VALUE c_cpSegmentQueryInfo;
+VALUE c_cpNearestPointQueryInfo;
 
 //Helper that allocates and initializes a SegmenQueryInfo struct
 VALUE
@@ -41,6 +44,11 @@ rb_cpSegmentQueryInfoNew(VALUE shape, VALUE t, VALUE n) {
   return rb_struct_new(c_cpSegmentQueryInfo, shape, t, n);
 }
 
+VALUE
+rb_cpNearestPointQueryInfoNew(VALUE shape, VALUE p, VALUE d) {
+  return rb_struct_new(c_cpNearestPointQueryInfo, shape, p, d);
+}
+
 
 
 static VALUE
@@ -101,16 +109,15 @@ rb_cpShapeGetSelf(VALUE self) {
 
 static VALUE
 rb_cpShapeGetGroup(VALUE self) {
-  return rb_iv_get(self, "group");
+  return rb_iv_get(self, "@group");
 }
 
 static VALUE
-rb_cpShapeSetGroup(VALUE self, VALUE val) {
-  VALUE col_type = rb_obj_id(val);
-  rb_iv_set(self, "group", val);
-  SHAPE(self)->group = NUM2UINT(col_type);
+rb_cpShapeSetGroup(VALUE self, VALUE groupValue) {
+  rb_iv_set(self, "@group", groupValue);
+  SHAPE(self)->group = CP_OBJ2INT(groupValue);
 
-  return val;
+  return groupValue;
 }
 
 static VALUE
@@ -186,6 +193,16 @@ rb_cpShapePointQuery(VALUE self, VALUE point) {
   return res ? Qtrue : Qfalse;
 }
 
+static VALUE
+rb_cpShapeNearestPointQuery(VALUE self, VALUE point) {
+  cpNearestPointQueryInfo info;
+  cpShapeNearestPointQuery(SHAPE(self), *VGET(point), &info);
+  if(info.shape) {
+    return rb_cpNearestPointQueryInfoNew((VALUE)info.shape->data, VNEW(info.p), rb_float_new(info.d));
+  }
+  return Qnil;
+}
+
 
 static VALUE
 rb_cpShapeSegmentQuery(VALUE self, VALUE a, VALUE b) {
@@ -198,13 +215,6 @@ rb_cpShapeSegmentQuery(VALUE self, VALUE a, VALUE b) {
 }
 
 
-
-//cpCircle
-static void
-rb_cpCircleMark(void * data) {
-  cpCircleShape *circle = (cpCircleShape *) data;
-}
-
 static VALUE
 rb_cpCircleAlloc(VALUE klass) {
   cpCircleShape *circle = cpCircleShapeAlloc();
@@ -260,10 +270,11 @@ rb_cpSegmentInitialize(VALUE self, VALUE body, VALUE a, VALUE b, VALUE r) {
 
 // Syntactic macro to handle fetching the vertices from a ruby array
 // to a C array.
+// TODO get rid of this cast by using stdint.h
 #define RBCP_ARRAY_POINTS(ARR, NUM, VERTS) \
   Check_Type(ARR, T_ARRAY);                \
   VALUE *__rbcp_ptr = RARRAY_PTR(ARR);     \
-  long NUM           = RARRAY_LEN(ARR);    \
+  int NUM           = (int)RARRAY_LEN(ARR);    \
   cpVect VERTS[NUM];                       \
   for(long i = 0; i < NUM; i++)            \
     VERTS[i] = *VGET(__rbcp_ptr[i]);
@@ -283,6 +294,30 @@ rb_cpPolyAlloc(VALUE klass) {
   return Data_Wrap_Struct(klass, NULL, cpShapeFree, poly);
 }
 
+static VALUE
+rb_cpShapeBoxInitialize(int argc, VALUE * argv, VALUE self) {
+  VALUE body, widthOrBB, height;
+  rb_scan_args(argc, argv, "21", &body, &widthOrBB, &height);
+
+  VALUE newPoly = rb_cpPolyAlloc(c_cpPolyShape);
+  cpPolyShape *poly = (cpPolyShape *)SHAPE(newPoly);
+
+  if(NIL_P(height)) {
+    // takes bb
+    cpBoxShapeInit2(poly, BODY(body), *BBGET(widthOrBB));
+  } else {
+    // takes w / h
+    cpBoxShapeInit(poly, BODY(body), NUM2DBL(widthOrBB), NUM2DBL(height));
+  }
+
+  poly->shape.data           = (void *)self;
+  poly->shape.collision_type = Qnil;
+
+  rb_ivar_set(newPoly, id_body, body);
+
+  return newPoly;
+}
+
 static VALUE
 rb_cpPolyInitialize(int argc, VALUE * argv, VALUE self) {
   VALUE body, arr, offset;
@@ -392,51 +427,6 @@ rb_cpPolyShapeSetVerts(VALUE self, VALUE arr, VALUE offset) {
   return self;
 }
 
-/* extra inline functions  from the headers */
-// Returns the minimum distance of the polygon to the axis.
-static VALUE
-rb_cpPolyShapeValueOnAxis(VALUE self, VALUE n, VALUE d) {
-  cpPolyShape * poly = (cpPolyShape *) SHAPE(self);
-  return DBL2NUM(cpPolyShapeValueOnAxis(poly, *VGET(n), NUM2DBL(d)));
-}
-
-// Returns true if the polygon contains the vertex.
-static VALUE
-rb_cpPolyShapeContainsVert(VALUE self, VALUE v) {
-  cpPolyShape * poly = (cpPolyShape *) SHAPE(self);
-  return CP_INT_BOOL(cpPolyShapeContainsVert(poly, *VGET(v)));
-}
-
-// Same as cpPolyShapeContainsVert() but ignores faces pointing away from the normal.
-static VALUE
-rb_cpPolyShapeContainsVertPartial(VALUE self, VALUE v, VALUE n) {
-  cpPolyShape * poly = (cpPolyShape *) SHAPE(self);
-  return CP_INT_BOOL(cpPolyShapeContainsVertPartial(poly, *VGET(v), *VGET(n)));
-}
-
-
-/* collision.h */
-static VALUE
-rb_cpCollideShapes(VALUE self, VALUE other) {
-  cpContact points[CP_MAX_CONTACTS_PER_ARBITER];
-  int size     = cpCollideShapes(SHAPE(self), SHAPE(other), points);
-  VALUE result = rb_ary_new();
-  for(int index = 0; index < size; index++) {
-    VALUE point   = VNEW(points[index].p);
-    VALUE normal  = VNEW(points[index].n);
-    VALUE dist    = DBL2NUM(points[index].dist);
-    VALUE contact = rb_cpContactPointNew(point, normal, dist);
-    rb_ary_push(result, contact);
-  }
-  return result;
-}
-
-
-
-
-
-
-
 void
 Init_cpShape(void) {
   id_body   = rb_intern("body");
@@ -454,6 +444,19 @@ Init_cpShape(void) {
   rb_define_method(m_cpShape, "collision_type", rb_cpShapeGetCollType, 0);
   rb_define_method(m_cpShape, "collision_type=", rb_cpShapeSetCollType, 1);
 
+  rb_define_method(m_cpShape, "bb", rb_cpShapeCacheBB, 0);
+  rb_define_method(m_cpShape, "cache_bb", rb_cpShapeCacheBB, 0);
+  rb_define_method(m_cpShape, "raw_bb", rb_cpShapeGetBB, 0);
+
+  rb_define_method(m_cpShape, "e", rb_cpShapeGetElasticity, 0);
+  rb_define_method(m_cpShape, "e=", rb_cpShapeSetElasticity, 1);
+
+  rb_define_method(m_cpShape, "u", rb_cpShapeGetFriction, 0);
+  rb_define_method(m_cpShape, "u=", rb_cpShapeSetFriction, 1);
+
+  rb_define_method(m_cpShape, "surface_v", rb_cpShapeGetSurfaceV, 0);
+  rb_define_method(m_cpShape, "surface_v=", rb_cpShapeSetSurfaceV, 1);
+
   // this method only exists for Chipmunk-FFI compatibility as it seems useless
   // to me.
   rb_define_method(m_cpShape, "data", rb_cpShapeGetSelf, 0);
@@ -461,26 +464,15 @@ Init_cpShape(void) {
   rb_define_method(m_cpShape, "object", rb_cpShapeGetData, 0);
   rb_define_method(m_cpShape, "object=", rb_cpShapeSetData, 1);
 
+
   rb_define_method(m_cpShape, "group", rb_cpShapeGetGroup, 0);
   rb_define_method(m_cpShape, "group=", rb_cpShapeSetGroup, 1);
 
   rb_define_method(m_cpShape, "layers", rb_cpShapeGetLayers, 0);
   rb_define_method(m_cpShape, "layers=", rb_cpShapeSetLayers, 1);
 
-  rb_define_method(m_cpShape, "bb", rb_cpShapeCacheBB, 0);
-  rb_define_method(m_cpShape, "cache_bb", rb_cpShapeCacheBB, 0);
-  rb_define_method(m_cpShape, "raw_bb", rb_cpShapeGetBB, 0);
-
-  rb_define_method(m_cpShape, "e", rb_cpShapeGetElasticity, 0);
-  rb_define_method(m_cpShape, "u", rb_cpShapeGetFriction, 0);
-
-  rb_define_method(m_cpShape, "e=", rb_cpShapeSetElasticity, 1);
-  rb_define_method(m_cpShape, "u=", rb_cpShapeSetFriction, 1);
-
-  rb_define_method(m_cpShape, "surface_v", rb_cpShapeGetSurfaceV, 0);
-  rb_define_method(m_cpShape, "surface_v=", rb_cpShapeSetSurfaceV, 1);
-
   rb_define_method(m_cpShape, "point_query", rb_cpShapePointQuery, 1);
+  rb_define_method(m_cpShape, "nearest_point_query", rb_cpShapeNearestPointQuery, 1);
   rb_define_method(m_cpShape, "segment_query", rb_cpShapeSegmentQuery, 2);
 
 
@@ -503,6 +495,7 @@ Init_cpShape(void) {
   rb_include_module(c_cpPolyShape, m_cpShape);
   rb_define_alloc_func(c_cpPolyShape, rb_cpPolyAlloc);
   rb_define_singleton_method(c_cpPolyShape, "valid?", rb_cpPolyValidate, 1);
+  rb_define_singleton_method(c_cpPolyShape, "box", rb_cpShapeBoxInitialize, -1);
 
   rb_define_method(c_cpPolyShape, "initialize", rb_cpPolyInitialize, -1);
 
@@ -523,15 +516,15 @@ Init_cpShape(void) {
   rb_define_method(c_cpPolyShape, "length", rb_cpPolyShapeGetNumVerts, 0);
   rb_define_method(c_cpPolyShape, "size", rb_cpPolyShapeGetNumVerts, 0);
   rb_define_method(c_cpPolyShape, "[]", rb_cpPolyShapeGetVert, 1);
-  // Not in API yet:
-  rb_define_method(c_cpPolyShape, "value_on_axis", rb_cpPolyShapeValueOnAxis, 2);
-  rb_define_method(c_cpPolyShape, "contains?", rb_cpPolyShapeContainsVert, 1);
-  rb_define_method(c_cpPolyShape, "contains_partial?", rb_cpPolyShapeContainsVertPartial, 2);
 
   /* Use a struct for this small class. More efficient. */
   c_cpSegmentQueryInfo = rb_struct_define("SegmentQueryInfo",
                                           "shape", "t", "n", NULL);
   rb_define_const(m_Chipmunk, "SegmentQueryInfo", c_cpSegmentQueryInfo);
+  c_cpNearestPointQueryInfo = rb_struct_define("NearestPointQueryInfo",
+                                          "shape", "p", "d", NULL);
+  rb_define_const(m_Chipmunk, "NearestPointQueryInfo", c_cpNearestPointQueryInfo);
+
   /*"unsafe" API. */
   rb_define_method(c_cpCircleShape, "set_radius!", rb_cpCircleShapeSetRadius, 1);
   rb_define_method(c_cpCircleShape, "set_offset!", rb_cpCircleShapeSetOffset, 1);
@@ -540,7 +533,5 @@ Init_cpShape(void) {
 
   rb_define_method(c_cpPolyShape, "set_verts!", rb_cpPolyShapeSetVerts, 2);
 
-  rb_define_method(m_cpShape, "collide!", rb_cpCollideShapes, 1);
-
 }
 //

data/ext/chipmunk/rb_cpSpace.c

@@ -34,11 +34,25 @@ static ID id_separate;
 
 VALUE c_cpSpace;
 
+#define SPACE_GETSET_FUNCS(member)                                \
+  static VALUE rb_cpSpace_get_ ## member(VALUE self)              \
+  { return rb_float_new(SPACE(self)->member);}                    \
+  static VALUE rb_cpSpace_set_ ## member(VALUE self, VALUE value) \
+  { SPACE(self)->member = NUM2DBL(value); return value;}
+
+
+SPACE_GETSET_FUNCS(collisionBias)
+SPACE_GETSET_FUNCS(collisionSlop)
+
+// TODO this needs to be uint not float
+SPACE_GETSET_FUNCS(collisionPersistence)
 
 static VALUE
 rb_cpSpaceAlloc(VALUE klass) {
   cpSpace *space = cpSpaceAlloc();
-  return Data_Wrap_Struct(klass, NULL, cpSpaceFree, space);
+  VALUE rbSpace = Data_Wrap_Struct(klass, NULL, cpSpaceFree, space);
+  space->data = (void*)rbSpace;
+  return rbSpace;
 }
 
 static VALUE
@@ -47,20 +61,16 @@ rb_cpSpaceInitialize(VALUE self) {
   cpSpaceInit(space);
 
   // These might as well be in one shared hash.
-  rb_iv_set(self, "static_shapes", rb_ary_new());
-  rb_iv_set(self, "active_shapes", rb_ary_new());
-  rb_iv_set(self, "bodies", rb_ary_new());
-  rb_iv_set(self, "constraints", rb_ary_new());
-  rb_iv_set(self, "blocks", rb_hash_new());
+  rb_iv_set(self, "@static_shapes", rb_ary_new());
+  rb_iv_set(self, "@active_shapes", rb_ary_new());
+  rb_iv_set(self, "@bodies", rb_ary_new());
+  rb_iv_set(self, "@constraints", rb_ary_new());
+  rb_iv_set(self, "@blocks", rb_hash_new());
+  rb_iv_set(self, "@post_step_blocks", rb_hash_new());
 
   return self;
 }
 
-static VALUE
-SPACEWRAP(cpSpace * space) {
-  return Data_Wrap_Struct(c_cpSpace, NULL, cpSpaceFree, space);
-}
-
 static VALUE
 rb_cpSpaceGetSleepTimeThreshold(VALUE self) {
   return INT2NUM(SPACE(self)->sleepTimeThreshold);
@@ -68,13 +78,13 @@ rb_cpSpaceGetSleepTimeThreshold(VALUE self) {
 
 static VALUE
 rb_cpSpaceSetSleepTimeThreshold(VALUE self, VALUE val) {
-  SPACE(self)->sleepTimeThreshold = NUM2INT(val);
+  SPACE(self)->sleepTimeThreshold = NUM2UINT(val);
   return val;
 }
 
 static VALUE
 rb_cpSpaceGetIdleSpeedThreshold(VALUE self) {
-  return INT2NUM(SPACE(self)->idleSpeedThreshold);
+  return UINT2NUM(SPACE(self)->idleSpeedThreshold);
 }
 
 static VALUE
@@ -97,27 +107,28 @@ rb_cpSpaceSetIterations(VALUE self, VALUE val) {
 }
 
 static VALUE
-rb_cpSpaceGetElasticIterations(VALUE self) {
-  return INT2NUM(SPACE(self)->elasticIterations);
+rb_cpSpaceGetDamping(VALUE self) {
+  return rb_float_new(SPACE(self)->damping);
 }
 
 static VALUE
-rb_cpSpaceSetElasticIterations(VALUE self, VALUE val) {
-  SPACE(self)->elasticIterations = NUM2INT(val);
+rb_cpSpaceSetDamping(VALUE self, VALUE val) {
+  SPACE(self)->damping = NUM2DBL(val);
   return val;
 }
 
 static VALUE
-rb_cpSpaceGetDamping(VALUE self) {
-  return rb_float_new(SPACE(self)->damping);
+rb_cpSpaceGetContactGraphEnabled(VALUE self) {
+  return CP_INT_BOOL(SPACE(self)->enableContactGraph);
 }
 
 static VALUE
-rb_cpSpaceSetDamping(VALUE self, VALUE val) {
-  SPACE(self)->damping = NUM2DBL(val);
+rb_cpSpaceSetContactGraphEnabled(VALUE self, VALUE val) {
+  SPACE(self)->enableContactGraph = CP_BOOL_INT(val);
   return val;
 }
 
+
 static VALUE
 rb_cpSpaceGetGravity(VALUE self) {
   return VWRAP(self, &SPACE(self)->gravity);
@@ -134,16 +145,6 @@ doNothingCallback(cpArbiter *arb, cpSpace *space, void *data) {
   return 0;
 }
 
-// We need this as rb_obj_method_arity is not in 1.8.7
-static int
-cp_rb_obj_method_arity(VALUE self, ID id) {
-  VALUE metho = rb_funcall(self, rb_intern("method"), 1, ID2SYM(id));
-  VALUE arity = rb_funcall(metho, rb_intern("arity"), 0, 0);
-  return NUM2INT(arity);
-}
-
-
-
 // This callback function centralizes all collision callbacks.
 // it also adds flexibility by changing theway the callback is called on the
 // arity of the callback block or method. With arity0, no args are pased,
@@ -171,6 +172,7 @@ do_callback(void * data, ID method, cpArbiter *arb) {
     return CP_BOOL_INT(rb_funcall(object, method, 3, va, vb, varb));
   }
   // we never get here
+  return res;
 }
 
 
@@ -206,11 +208,6 @@ respondsTo(VALUE obj, ID method) {
   return RTEST(value);
 }
 
-static int
-isBlock(VALUE obj) {
-  return respondsTo(obj, id_call);
-}
-
 static VALUE
 rb_cpSpaceAddCollisionHandler(int argc, VALUE *argv, VALUE self) {
   VALUE a, b, obj, block;
@@ -219,7 +216,7 @@ rb_cpSpaceAddCollisionHandler(int argc, VALUE *argv, VALUE self) {
 
   VALUE id_a   = rb_obj_id(a);
   VALUE id_b   = rb_obj_id(b);
-  VALUE blocks = rb_iv_get(self, "blocks");
+  VALUE blocks = rb_iv_get(self, "@blocks");
 
   if(RTEST(obj) && RTEST(block)) {
     rb_raise(rb_eArgError, "Cannot specify both a handler object and a block.");
@@ -261,7 +258,7 @@ rb_cpSpaceRemoveCollisionHandler(VALUE self, VALUE a, VALUE b) {
   VALUE id_b   = rb_obj_id(b);
   cpSpaceRemoveCollisionHandler(SPACE(self), NUM2UINT(id_a), NUM2UINT(id_b));
 
-  VALUE blocks = rb_iv_get(self, "blocks");
+  VALUE blocks = rb_iv_get(self, "@blocks");
   rb_hash_delete(blocks, rb_ary_new3(2, id_a, id_b));
 
   return Qnil;
@@ -284,7 +281,7 @@ rb_cpSpaceSetDefaultCollisionHandler(int argc, VALUE *argv, VALUE self) {
       (void *)block
       );
 
-    rb_hash_aset(rb_iv_get(self, "blocks"), ID2SYM(rb_intern("default")), block);
+    rb_hash_aset(rb_iv_get(self, "@blocks"), ID2SYM(rb_intern("default")), block);
   } else if(RTEST(obj)) {
     cpSpaceSetDefaultCollisionHandler(
       SPACE(self),
@@ -295,7 +292,7 @@ rb_cpSpaceSetDefaultCollisionHandler(int argc, VALUE *argv, VALUE self) {
       (void *)obj
       );
 
-    rb_hash_aset(rb_iv_get(self, "blocks"), ID2SYM(rb_intern("default")), obj);
+    rb_hash_aset(rb_iv_get(self, "@blocks"), ID2SYM(rb_intern("default")), obj);
   } else {
     cpSpaceSetDefaultCollisionHandler(
       SPACE(self), NULL, doNothingCallback, NULL, NULL, NULL
@@ -307,96 +304,114 @@ rb_cpSpaceSetDefaultCollisionHandler(int argc, VALUE *argv, VALUE self) {
 
 static void
 poststepCallback(cpSpace *space, void *obj, void *data) {
-  rb_funcall((VALUE)data, id_call, 2, SPACEWRAP(space), (VALUE)obj);
+  rb_funcall((VALUE)data, id_call, 2, (VALUE)space->data, (VALUE)obj);
 }
 
 
 static VALUE
 rb_cpSpaceAddPostStepCallback(int argc, VALUE *argv, VALUE self) {
   VALUE obj, block;
+  VALUE blocks = rb_iv_get(self, "@post_step_blocks");
+
   rb_scan_args(argc, argv, "10&", &obj, &block);
+  if(!RTEST(block)) {
+    rb_raise(rb_eArgError, "Cannot omit the block.");
+  }
+
+  rb_hash_aset(blocks, obj, block);
+
   cpSpaceAddPostStepCallback(SPACE(self),
                              poststepCallback, (void *) obj, (void *) block);
+
   return self;
 }
 
 static VALUE
 rb_cpSpaceAddShape(VALUE self, VALUE shape) {
   cpSpaceAddShape(SPACE(self), SHAPE(shape));
-  rb_ary_push(rb_iv_get(self, "active_shapes"), shape);
+  rb_ary_push(rb_iv_get(self, "@active_shapes"), shape);
   return shape;
 }
 
 static VALUE
 rb_cpSpaceAddStaticShape(VALUE self, VALUE shape) {
   cpSpaceAddStaticShape(SPACE(self), SHAPE(shape));
-  rb_ary_push(rb_iv_get(self, "static_shapes"), shape);
+  rb_ary_push(rb_iv_get(self, "@static_shapes"), shape);
   return shape;
 }
 
 static VALUE
 rb_cpSpaceAddBody(VALUE self, VALUE body) {
   cpSpaceAddBody(SPACE(self), BODY(body));
-  rb_ary_push(rb_iv_get(self, "bodies"), body);
+  rb_ary_push(rb_iv_get(self, "@bodies"), body);
   return body;
 }
 
 static VALUE
 rb_cpSpaceAddConstraint(VALUE self, VALUE constraint) {
   cpSpaceAddConstraint(SPACE(self), CONSTRAINT(constraint));
-  rb_ary_push(rb_iv_get(self, "constraints"), constraint);
+  rb_ary_push(rb_iv_get(self, "@constraints"), constraint);
   return constraint;
 }
 
 static VALUE
 rb_cpSpaceRemoveShape(VALUE self, VALUE shape) {
-  VALUE ok = rb_ary_delete(rb_iv_get(self, "active_shapes"), shape);
+  VALUE ok = rb_ary_delete(rb_iv_get(self, "@active_shapes"), shape);
   if(!(NIL_P(ok))) cpSpaceRemoveShape(SPACE(self), SHAPE(shape));
   return ok;
 }
 
 static VALUE
 rb_cpSpaceRemoveStaticShape(VALUE self, VALUE shape) {
-  VALUE ok = rb_ary_delete(rb_iv_get(self, "static_shapes"), shape);
+  VALUE ok = rb_ary_delete(rb_iv_get(self, "@static_shapes"), shape);
   if(!(NIL_P(ok))) cpSpaceRemoveStaticShape(SPACE(self), SHAPE(shape));
   return ok;
 }
 
 static VALUE
 rb_cpSpaceRemoveBody(VALUE self, VALUE body) {
-  VALUE ok = rb_ary_delete(rb_iv_get(self, "bodies"), body);
+  VALUE ok = rb_ary_delete(rb_iv_get(self, "@bodies"), body);
   if(!(NIL_P(ok))) cpSpaceRemoveBody(SPACE(self), BODY(body));
   return ok;
 }
 
 static VALUE
 rb_cpSpaceRemoveConstraint(VALUE self, VALUE constraint) {
-  VALUE ok = rb_ary_delete(rb_iv_get(self, "constraints"), constraint);
+  VALUE ok = rb_ary_delete(rb_iv_get(self, "@constraints"), constraint);
   if(!(NIL_P(ok))) cpSpaceRemoveConstraint(SPACE(self), CONSTRAINT(constraint));
   return ok;
 }
 
 static VALUE
 rb_cpSpaceResizeStaticHash(VALUE self, VALUE dim, VALUE count) {
+  rb_raise(rb_eArgError, "resize_static_hash is obsolete");
+  return Qnil;
+  /*
   cpSpaceResizeStaticHash(SPACE(self), NUM2DBL(dim), NUM2INT(count));
   return Qnil;
+  */
 }
 
 static VALUE
 rb_cpSpaceResizeActiveHash(VALUE self, VALUE dim, VALUE count) {
-  cpSpaceResizeActiveHash(SPACE(self), NUM2DBL(dim), NUM2INT(count));
+  rb_raise(rb_eArgError, "resize_active_hash is obsolete");
   return Qnil;
+  /* cpSpaceResizeActiveHash(SPACE(self), NUM2DBL(dim), NUM2INT(count));  
+  return Qnil;
+  */
 }
 
 static VALUE
 rb_cpSpaceRehashStatic(VALUE self) {
-  cpSpaceRehashStatic(SPACE(self));
+  rb_raise(rb_eArgError, "rehash_static is obsolete");
+  /* cpSpaceRehashStatic(SPACE(self)); */
   return Qnil;
 }
 
 static VALUE
 rb_cpSpaceRehashShape(VALUE self, VALUE shape) {
-  cpSpaceRehashShape(SPACE(self), SHAPE(shape));
+  rb_raise(rb_eArgError, "rehash_shape is obsolete");
+  /* cpSpaceRehashShape(SPACE(self), SHAPE(shape)); */
   return Qnil;
 }
 
@@ -528,21 +543,10 @@ rb_cpSpaceShapeQuery(int argc, VALUE *argv, VALUE self) {
 static VALUE
 rb_cpSpaceStep(VALUE self, VALUE dt) {
   cpSpaceStep(SPACE(self), NUM2DBL(dt));
+  rb_iv_set(self, "@post_step_blocks", rb_hash_new());
   return Qnil;
 }
 
-static VALUE
-rb_cpSpaceGetData(VALUE self) {
-  return rb_iv_get(self, "data");
-}
-
-static VALUE
-rb_cpSpaceSetData(VALUE self, VALUE val) {
-  rb_iv_set(self, "data", val);
-  return val;
-}
-
-
 static VALUE
 rb_cpSpaceActivateShapesTouchingShape(VALUE self, VALUE shape) {
   cpSpaceActivateShapesTouchingShape(SPACE(self), SHAPE(shape));
@@ -575,12 +579,6 @@ Init_cpSpace(void) {
   rb_define_method(c_cpSpace, "iterations", rb_cpSpaceGetIterations, 0);
   rb_define_method(c_cpSpace, "iterations=", rb_cpSpaceSetIterations, 1);
 
-  rb_define_method(c_cpSpace, "elastic_iterations", rb_cpSpaceGetElasticIterations, 0);
-  rb_define_method(c_cpSpace, "elastic_iterations=", rb_cpSpaceSetElasticIterations, 1);
-
-  rb_define_method(c_cpSpace, "damping", rb_cpSpaceGetDamping, 0);
-  rb_define_method(c_cpSpace, "damping=", rb_cpSpaceSetDamping, 1);
-
   rb_define_method(c_cpSpace, "gravity", rb_cpSpaceGetGravity, 0);
   rb_define_method(c_cpSpace, "gravity=", rb_cpSpaceSetGravity, 1);
 
@@ -613,9 +611,13 @@ Init_cpSpace(void) {
   rb_define_method(c_cpSpace, "on_post_step",
                    rb_cpSpaceAddPostStepCallback, -1);
 
-
-
-
+  rb_define_method(c_cpSpace, "collision_bias", rb_cpSpace_get_collisionBias, 0);
+  rb_define_method(c_cpSpace, "collision_bias=", rb_cpSpace_set_collisionBias, 1);
+  rb_define_method(c_cpSpace, "collision_slop", rb_cpSpace_get_collisionSlop, 0);
+  rb_define_method(c_cpSpace, "collision_slop=", rb_cpSpace_set_collisionSlop, 1);
+  rb_define_method(c_cpSpace, "collision_persistence", rb_cpSpace_get_collisionPersistence, 0);
+  rb_define_method(c_cpSpace, "collision_persistence=", rb_cpSpace_set_collisionPersistence, 1);
+  
   rb_define_method(c_cpSpace, "add_shape", rb_cpSpaceAddShape, 1);
   rb_define_method(c_cpSpace, "add_static_shape", rb_cpSpaceAddStaticShape, 1);
   rb_define_method(c_cpSpace, "add_body", rb_cpSpaceAddBody, 1);
@@ -645,9 +647,6 @@ Init_cpSpace(void) {
 
   rb_define_method(c_cpSpace, "step", rb_cpSpaceStep, 1);
 
-  rb_define_method(c_cpSpace, "object", rb_cpSpaceGetData, 0);
-  rb_define_method(c_cpSpace, "object=", rb_cpSpaceSetData, 1);
-
   rb_define_method(c_cpSpace, "sleep_time_threshold=",
                    rb_cpSpaceSetSleepTimeThreshold, 1);
   rb_define_method(c_cpSpace, "sleep_time_threshold",
@@ -667,6 +666,12 @@ Init_cpSpace(void) {
   rb_define_method(c_cpSpace, "idle_speed",
                    rb_cpSpaceGetIdleSpeedThreshold, 0);
 
+  rb_define_method(c_cpSpace, "damping", rb_cpSpaceGetDamping, 0);
+  rb_define_method(c_cpSpace, "damping=", rb_cpSpaceSetDamping, 1);
+
+  rb_define_method(c_cpSpace, "contact_graph_enabled", rb_cpSpaceGetContactGraphEnabled, 0);
+  rb_define_method(c_cpSpace, "contact_graph_enabled=", rb_cpSpaceSetContactGraphEnabled, 1);
+
   rb_define_method(c_cpSpace, "activate_shapes_touching_shape",
                    rb_cpSpaceActivateShapesTouchingShape, 1);