chipmunk 5.3.4.0-x86-mingw32

data/ext/chipmunk/rb_chipmunk.h

@@ -0,0 +1,105 @@
+/* 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_cpConstraint;
+extern VALUE c_cpSpace;
+extern VALUE c_cpArbiter;
+extern VALUE c_cpStaticBody;
+extern VALUE c_cpSegmentQueryInfo;
+
+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, type)\
+static inline type *\
+func_name(VALUE 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 , 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_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

@@ -0,0 +1,210 @@
+/* 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 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)
+{
+	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 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
+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);
+}
+
+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)
+{
+	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);
+  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, "merge"     , rb_cpBBmerge, 1);
+  rb_define_method(c_cpBB, "expand"    , rb_cpBBexpand, 1);
+   
+	
+	rb_define_method(c_cpBB, "to_s", rb_cpBBToString, 0);
+}