chipmunk 4.1.0

data/ext/chipmunk/rb_cpSpace.c

@@ -0,0 +1,330 @@
+/* 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"
+
+ID id_call;
+
+
+VALUE c_cpSpace;
+
+static VALUE
+rb_cpSpaceAlloc(VALUE klass)
+{
+	cpSpace *space = cpSpaceAlloc();
+	return Data_Wrap_Struct(klass, NULL, cpSpaceFree, space);
+}
+
+static VALUE
+rb_cpSpaceInitialize(VALUE self)
+{
+	cpSpace *space = SPACE(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, "joints", rb_ary_new());
+	rb_iv_set(self, "blocks", rb_hash_new());
+
+	return self;
+}
+
+static VALUE
+rb_cpSpaceGetIterations(VALUE self)
+{
+	return INT2NUM(SPACE(self)->iterations);
+}
+
+static VALUE
+rb_cpSpaceSetIterations(VALUE self, VALUE val)
+{
+	SPACE(self)->iterations = NUM2INT(val);
+	return val;
+}
+
+static VALUE
+rb_cpSpaceGetElasticIterations(VALUE self)
+{
+	return INT2NUM(SPACE(self)->elasticIterations);
+}
+
+static VALUE
+rb_cpSpaceSetElasticIterations(VALUE self, VALUE val)
+{
+	SPACE(self)->elasticIterations = NUM2INT(val);
+	return val;
+}
+
+static VALUE
+rb_cpSpaceGetDamping(VALUE self)
+{
+	return rb_float_new(SPACE(self)->damping);
+}
+
+static VALUE
+rb_cpSpaceSetDamping(VALUE self, VALUE val)
+{
+	SPACE(self)->damping = NUM2DBL(val);
+	return val;
+}
+
+static VALUE
+rb_cpSpaceGetGravity(VALUE self)
+{
+	return VWRAP(self, &SPACE(self)->gravity);
+}
+
+static VALUE
+rb_cpSpaceSetGravity(VALUE self, VALUE val)
+{
+	SPACE(self)->gravity = *VGET(val);
+	return val;
+}
+
+static int
+collisionCallback(cpShape *a, cpShape *b, cpContact *contacts, int numContacts, cpFloat normal_coef, void *data)
+{
+	VALUE block = (VALUE)data;
+	VALUE shapea = (VALUE)a->data;
+	VALUE shapeb = (VALUE)b->data;
+	
+	return rb_funcall(block, id_call, 2, shapea, shapeb);
+}
+
+static VALUE
+rb_cpSpaceAddCollisionFunc(int argc, VALUE *argv, VALUE self)
+{
+	VALUE a, b, block;
+	rb_scan_args(argc, argv, "20&", &a, &b, &block);
+
+	VALUE id_a = rb_obj_id(a);
+	VALUE id_b = rb_obj_id(b);
+	if(NIL_P(block)) {
+		cpSpaceAddCollisionPairFunc(SPACE(self), NUM2UINT(id_a), NUM2UINT(id_b),
+								    NULL, NULL);
+	} else {
+		cpSpaceAddCollisionPairFunc(SPACE(self), NUM2UINT(id_a), NUM2UINT(id_b),
+									collisionCallback, (void *)block);
+	}
+	
+	VALUE blocks = rb_iv_get(self, "blocks");
+	rb_hash_aset(blocks, rb_ary_new3(2, id_a, id_b), block);
+	
+	return Qnil;
+}
+
+static VALUE
+rb_cpSpaceRemoveCollisionFunc(VALUE self, VALUE a, VALUE b)
+{
+	VALUE id_a = rb_obj_id(a);
+	VALUE id_b = rb_obj_id(b);
+	cpSpaceRemoveCollisionPairFunc(SPACE(self), NUM2UINT(id_a), NUM2UINT(id_b));
+	
+	VALUE blocks = rb_iv_get(self, "blocks");
+	rb_hash_delete(blocks, rb_ary_new3(2, id_a, id_b));
+	
+	return Qnil;
+}
+
+static VALUE
+rb_cpSpaceSetDefaultCollisionFunc(int argc, VALUE *argv, VALUE self)
+{
+	VALUE block;
+	rb_scan_args(argc, argv, "00&", &block);
+	
+	if(NIL_P(block)) {
+		cpSpaceSetDefaultCollisionPairFunc(SPACE(self), NULL, NULL);
+	} else {
+		cpSpaceSetDefaultCollisionPairFunc(SPACE(self), collisionCallback, (void *)block);
+	}
+		
+	rb_hash_aset(rb_iv_get(self, "blocks"), ID2SYM(rb_intern("default")), block);
+	
+	return Qnil;
+}
+
+static VALUE
+rb_cpSpaceAddShape(VALUE self, VALUE shape)
+{
+	cpSpaceAddShape(SPACE(self), SHAPE(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);
+	return shape;
+}
+
+static VALUE
+rb_cpSpaceAddBody(VALUE self, VALUE body)
+{
+	cpSpaceAddBody(SPACE(self), BODY(body));
+	rb_ary_push(rb_iv_get(self, "bodies"), body);
+	return body;
+}
+
+static VALUE
+rb_cpSpaceAddJoint(VALUE self, VALUE joint)
+{
+	cpSpaceAddJoint(SPACE(self), JOINT(joint));
+	rb_ary_push(rb_iv_get(self, "joints"), joint);
+	return joint;
+}
+
+static VALUE
+rb_cpSpaceRemoveShape(VALUE self, VALUE shape)
+{
+	cpSpaceRemoveShape(SPACE(self), SHAPE(shape));
+	return rb_ary_delete(rb_iv_get(self, "active_shapes"), shape);
+}
+
+static VALUE
+rb_cpSpaceRemoveStaticShape(VALUE self, VALUE shape)
+{
+	cpSpaceRemoveStaticShape(SPACE(self), SHAPE(shape));
+	return rb_ary_delete(rb_iv_get(self, "static_shapes"), shape);
+}
+
+static VALUE
+rb_cpSpaceRemoveBody(VALUE self, VALUE body)
+{
+	cpSpaceRemoveBody(SPACE(self), BODY(body));
+	return rb_ary_delete(rb_iv_get(self, "bodies"), body);
+}
+
+static VALUE
+rb_cpSpaceRemoveJoint(VALUE self, VALUE joint)
+{
+	cpSpaceRemoveJoint(SPACE(self), JOINT(joint));
+	return rb_ary_delete(rb_iv_get(self, "joints"), joint);
+}
+
+static VALUE
+rb_cpSpaceResizeStaticHash(VALUE self, VALUE dim, VALUE count)
+{
+	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));
+	return Qnil;
+}
+
+static VALUE
+rb_cpSpaceRehashStatic(VALUE self)
+{
+	cpSpaceRehashStatic(SPACE(self));
+	return Qnil;
+}
+
+static void
+pointQueryHelper(cpShape *shape, void *block)
+{
+	rb_funcall((VALUE)block, id_call, 1, (VALUE)shape->data);
+}
+
+static VALUE
+rb_cpSpaceShapePointQuery(int argc, VALUE *argv, VALUE self)
+{
+	VALUE point, block;
+	rb_scan_args(argc, argv, "10&", &point, &block);
+	
+	cpSpaceShapePointQuery(SPACE(self), *VGET(point), pointQueryHelper, (void *)block);
+	
+	return Qnil;
+}
+
+static VALUE
+rb_cpSpaceStaticShapePointQuery(int argc, VALUE *argv, VALUE self)
+{
+	VALUE point, block;
+	rb_scan_args(argc, argv, "10&", &point, &block);
+	
+	cpSpaceStaticShapePointQuery(SPACE(self), *VGET(point), pointQueryHelper, (void *)block);
+	
+	return Qnil;
+}
+
+static VALUE
+rb_cpSpaceStep(VALUE self, VALUE dt)
+{
+	cpSpaceStep(SPACE(self), NUM2DBL(dt));
+	return Qnil;
+}
+
+
+
+void
+Init_cpSpace(void)
+{
+	id_call = rb_intern("call");
+	
+	c_cpSpace = rb_define_class_under(m_Chipmunk, "Space", rb_cObject);
+	rb_define_alloc_func(c_cpSpace, rb_cpSpaceAlloc);
+	rb_define_method(c_cpSpace, "initialize", rb_cpSpaceInitialize, 0);
+	
+	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);
+
+	rb_define_method(c_cpSpace, "add_collision_func", rb_cpSpaceAddCollisionFunc, -1);
+	rb_define_method(c_cpSpace, "remove_collision_func", rb_cpSpaceRemoveCollisionFunc, 2);
+	rb_define_method(c_cpSpace, "set_default_collision_func", rb_cpSpaceSetDefaultCollisionFunc, -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);
+	rb_define_method(c_cpSpace, "add_joint", rb_cpSpaceAddJoint, 1);
+	
+	rb_define_method(c_cpSpace, "remove_shape", rb_cpSpaceRemoveShape, 1);
+	rb_define_method(c_cpSpace, "remove_static_shape", rb_cpSpaceRemoveStaticShape, 1);
+	rb_define_method(c_cpSpace, "remove_body", rb_cpSpaceRemoveBody, 1);
+	rb_define_method(c_cpSpace, "remove_joint", rb_cpSpaceRemoveJoint, 1);
+	
+	rb_define_method(c_cpSpace, "resize_static_hash", rb_cpSpaceResizeStaticHash, 2);
+	rb_define_method(c_cpSpace, "resize_active_hash", rb_cpSpaceResizeActiveHash, 2);
+	rb_define_method(c_cpSpace, "rehash_static", rb_cpSpaceRehashStatic, 0);
+	
+	rb_define_method(c_cpSpace, "shape_point_query", rb_cpSpaceShapePointQuery, -1);
+	rb_define_method(c_cpSpace, "static_shape_point_query", rb_cpSpaceStaticShapePointQuery, -1);
+	
+	rb_define_method(c_cpSpace, "step", rb_cpSpaceStep, 1);
+}

data/ext/chipmunk/rb_cpVect.c

@@ -0,0 +1,250 @@
+/* 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_cpVect;
+
+static VALUE
+rb_cpVectForAngle(VALUE self, VALUE angle)
+{
+	return VNEW(cpvforangle(NUM2DBL(angle)));
+}
+
+static VALUE
+rb_cpVectAlloc(VALUE klass)
+{
+	cpVect *v = malloc(sizeof(cpVect));
+	return Data_Wrap_Struct(klass, NULL, free, v);
+}
+
+static VALUE
+rb_cpVectInitialize(VALUE self, VALUE x, VALUE y)
+{
+	cpVect *v = VGET(self);
+	v->x = NUM2DBL(x);
+	v->y = NUM2DBL(y);
+	
+	return self;
+}
+
+static VALUE
+rb_cpVectGetX(VALUE self)
+{
+	return rb_float_new(VGET(self)->x);
+}
+
+static VALUE
+rb_cpVectGetY(VALUE self)
+{
+	return rb_float_new(VGET(self)->y);
+}
+
+static VALUE
+rb_cpVectSetX(VALUE self, VALUE x)
+{
+	VGET(self)->x = NUM2DBL(x);
+	return self;
+}
+
+static VALUE
+rb_cpVectSetY(VALUE self, VALUE y)
+{
+	VGET(self)->y = NUM2DBL(y);
+	return self;
+}
+
+static VALUE
+rb_cpVectToString(VALUE self)
+{
+	char str[256];
+	cpVect *v = VGET(self);
+	
+	sprintf(str, "(% .3f, % .3f)", v->x, v->y);
+	
+	return rb_str_new2(str);
+}
+
+static VALUE
+rb_cpVectToArray(VALUE self)
+{
+	cpVect *v = VGET(self);
+	return rb_ary_new3(2, rb_float_new(v->x), rb_float_new(v->y));
+}
+
+static VALUE
+rb_cpVectToAngle(VALUE self)
+{
+	return rb_float_new(cpvtoangle(*VGET(self)));
+}
+	
+
+static VALUE
+rb_cpVectNegate(VALUE self)
+{
+	return VNEW(cpvneg(*VGET(self)));
+}
+
+static VALUE
+rb_cpVectAdd(VALUE self, VALUE v)
+{
+	return VNEW(cpvadd(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectSub(VALUE self, VALUE v)
+{
+	return VNEW(cpvsub(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectSMult(VALUE self, VALUE s)
+{
+	return VNEW(cpvmult(*VGET(self), NUM2DBL(s)));
+}
+
+static VALUE
+rb_cpVectSDiv(VALUE self, VALUE s)
+{
+	cpFloat factor = 1.0f/(float)NUM2DBL(s);
+	return VNEW(cpvmult(*VGET(self), factor));
+}
+
+static VALUE
+rb_cpVectDot(VALUE self, VALUE v)
+{
+	return rb_float_new(cpvdot(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectCross(VALUE self, VALUE v)
+{
+	return rb_float_new(cpvcross(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectLength(VALUE self)
+{
+	cpVect *v;
+	Data_Get_Struct(self, cpVect, v);
+	return rb_float_new(cpvlength(*v));
+}
+
+static VALUE
+rb_cpVectLengthsq(VALUE self)
+{
+	cpVect *v;
+	Data_Get_Struct(self, cpVect, v);
+	return rb_float_new(cpvlengthsq(*v));
+}
+
+static VALUE
+rb_cpVectNorm(VALUE self)
+{
+	return VNEW(cpvnormalize(*VGET(self)));
+}
+
+static VALUE
+rb_cpVectNormBang(VALUE self)
+{
+	cpVect *v = VGET(self);
+	*v = cpvnormalize(*v);
+	return self;
+}
+
+static VALUE
+rb_cpVectPerp(VALUE self)
+{
+	return VNEW(cpvperp(*VGET(self)));
+}
+
+static VALUE
+rb_cpVectProject(VALUE self, VALUE v)
+{
+	return VNEW(cpvproject(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectRotate(VALUE self, VALUE v)
+{
+	return VNEW(cpvrotate(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectUnRotate(VALUE self, VALUE v)
+{
+	return VNEW(cpvunrotate(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectNear(VALUE self, VALUE v, VALUE d)
+{
+	cpFloat dist = NUM2DBL(d);
+	cpVect delta = cpvsub(*VGET(self), *VGET(v));
+	return (cpvdot(delta, delta) <= dist*dist) ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_vec2(VALUE self, VALUE x, VALUE y)
+{
+	return VNEW(cpv(NUM2DBL(x), NUM2DBL(y)));
+}
+
+void
+Init_cpVect(void)
+{
+	c_cpVect = rb_define_class_under(m_Chipmunk, "Vec2", rb_cObject);
+	rb_define_singleton_method(c_cpBB, "for_angle", rb_cpVectForAngle, 1);
+	
+	rb_define_alloc_func(c_cpVect, rb_cpVectAlloc);
+	rb_define_method(c_cpVect, "initialize", rb_cpVectInitialize, 2);
+	
+	rb_define_method(c_cpVect, "x", rb_cpVectGetX, 0);
+	rb_define_method(c_cpVect, "y", rb_cpVectGetY, 0);
+	rb_define_method(c_cpVect, "x=", rb_cpVectSetX, 1);
+	rb_define_method(c_cpVect, "y=", rb_cpVectSetY, 1);
+	
+	rb_define_method(c_cpVect, "to_s", rb_cpVectToString, 0);
+	rb_define_method(c_cpVect, "to_a", rb_cpVectToArray, 0);
+	rb_define_method(c_cpVect, "to_angle", rb_cpVectToAngle, 0);
+	
+	rb_define_method(c_cpVect, "-@", rb_cpVectNegate, 0);
+	rb_define_method(c_cpVect, "+", rb_cpVectAdd, 1);
+	rb_define_method(c_cpVect, "-", rb_cpVectSub, 1);
+	rb_define_method(c_cpVect, "*", rb_cpVectSMult, 1);
+	rb_define_method(c_cpVect, "/", rb_cpVectSDiv, 1);
+	rb_define_method(c_cpVect, "dot", rb_cpVectDot, 1);
+	rb_define_method(c_cpVect, "cross", rb_cpVectCross, 1);
+	rb_define_method(c_cpVect, "length", rb_cpVectLength, 0);
+	rb_define_method(c_cpVect, "lengthsq", rb_cpVectLengthsq, 0);
+	rb_define_method(c_cpVect, "normalize", rb_cpVectNorm, 0);
+	rb_define_method(c_cpVect, "normalize!", rb_cpVectNormBang, 0);
+	rb_define_method(c_cpVect, "perp", rb_cpVectPerp, 0);
+	rb_define_method(c_cpVect, "project", rb_cpVectProject, 1);
+	rb_define_method(c_cpVect, "rotate", rb_cpVectRotate, 1);
+	rb_define_method(c_cpVect, "unrotate", rb_cpVectUnRotate, 1);
+	rb_define_method(c_cpVect, "near?", rb_cpVectNear, 2);
+		
+	rb_define_global_function("vec2", rb_vec2, 2);
+}

data/lib/chipmunk.rb

@@ -0,0 +1,15 @@
+# this redirection script by John Mair (banisterfiend)
+
+require 'rbconfig'
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/1.9/chipmunk.#{dlext}"
+    else
+        require "#{direc}/1.8/chipmunk.#{dlext}"
+    end
+rescue LoadError => e
+    require "#{direc}/chipmunk.#{dlext}"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: chipmunk
+version: !ruby/object:Gem::Version 
+  version: 4.1.0
+platform: ruby
+authors: 
+- Scott Lembcke, Beoran, John Mair (banisterfiend)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-01 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: ruby bindings for the chipmunk physics engine
+email: jrmair@gmail.com
+executables: []
+
+extensions: 
+- ext/chipmunk/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/chipmunk.rb
+- ext/chipmunk/extconf.rb
+- ext/chipmunk/prime.h
+- ext/chipmunk/cpVect.h
+- ext/chipmunk/cpJoint.h
+- ext/chipmunk/cpBB.h
+- ext/chipmunk/rb_chipmunk.h
+- ext/chipmunk/cpBody.h
+- ext/chipmunk/chipmunk.h
+- ext/chipmunk/cpHashSet.h
+- ext/chipmunk/cpShape.h
+- ext/chipmunk/cpSpace.h
+- ext/chipmunk/cpPolyShape.h
+- ext/chipmunk/cpCollision.h
+- ext/chipmunk/cpArray.h
+- ext/chipmunk/cpSpaceHash.h
+- ext/chipmunk/cpArbiter.h
+- ext/chipmunk/cpBB.c
+- ext/chipmunk/cpCollision.c
+- ext/chipmunk/rb_cpBody.c
+- ext/chipmunk/cpArbiter.c
+- ext/chipmunk/cpJoint.c
+- ext/chipmunk/chipmunk.c
+- ext/chipmunk/cpHashSet.c
+- ext/chipmunk/cpSpace.c
+- ext/chipmunk/cpShape.c
+- ext/chipmunk/cpBody.c
+- ext/chipmunk/rb_cpBB.c
+- ext/chipmunk/cpArray.c
+- ext/chipmunk/rb_cpJoint.c
+- ext/chipmunk/rb_cpVect.c
+- ext/chipmunk/rb_cpSpace.c
+- ext/chipmunk/cpSpaceHash.c
+- ext/chipmunk/cpVect.c
+- ext/chipmunk/rb_cpShape.c
+- ext/chipmunk/rb_chipmunk.c
+- ext/chipmunk/cpPolyShape.c
+has_rdoc: true
+homepage: http://code.google.com/p/chipmunk-physics/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ruby bindings for the chipmunk physics engine
+test_files: []
+