chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/cpVect.c

@@ -20,46 +20,31 @@
  */
  
 #include <stdio.h>
-#include <math.h>
 
-#include "chipmunk.h"
-
-cpFloat
-cpvlength(const cpVect v)
-{
-	return cpfsqrt( cpvdot(v, v) );
-}
+#include "chipmunk_private.h"
 
 inline cpVect
 cpvslerp(const cpVect v1, const cpVect v2, const cpFloat t)
 {
-	cpFloat omega = cpfacos(cpvdot(v1, v2));
+	cpFloat dot = cpvdot(cpvnormalize(v1), cpvnormalize(v2));
+	cpFloat omega = cpfacos(cpfclamp(dot, -1.0f, 1.0f));
 	
-	if(omega){
+	if(omega < 1e-3){
+		// If the angle between two vectors is very small, lerp instead to avoid precision issues.
+		return cpvlerp(v1, v2, t);
+	} else {
 		cpFloat denom = 1.0f/cpfsin(omega);
 		return cpvadd(cpvmult(v1, cpfsin((1.0f - t)*omega)*denom), cpvmult(v2, cpfsin(t*omega)*denom));
-	} else {
-		return v1;
 	}
 }
 
 cpVect
 cpvslerpconst(const cpVect v1, const cpVect v2, const cpFloat a)
 {
-	cpFloat angle = cpfacos(cpvdot(v1, v2));
-	return cpvslerp(v1, v2, cpfmin(a, angle)/angle);
-}
-
-cpVect
-cpvforangle(const cpFloat a)
-{
-	return cpv(cpfcos(a), cpfsin(a));
-}
-
-cpFloat
-cpvtoangle(const cpVect v)
-{
-	return cpfatan2(v.y, v.x);
+	cpFloat dot = cpvdot(cpvnormalize(v1), cpvnormalize(v2));
+	cpFloat omega = cpfacos(cpfclamp(dot, -1.0f, 1.0f));
+	
+	return cpvslerp(v1, v2, cpfmin(a, omega)/omega);
 }
 
 char*

data/ext/chipmunk/cpVect.h

@@ -19,189 +19,194 @@
  * SOFTWARE.
  */
 
+/// @defgroup cpVect cpVect
+/// Chipmunk's 2D vector type along with a handy 2D vector math lib.
+/// @{
+
 /// Constant for the zero vector.
 static const cpVect cpvzero = {0.0f,0.0f};
 
 /// Convenience constructor for cpVect structs.
-static inline cpVect
-cpv(const cpFloat x, const cpFloat y)
+static inline cpVect cpv(const cpFloat x, const cpFloat y)
 {
 	cpVect v = {x, y};
 	return v;
 }
 
-// non-inlined functions
-
-/// Returns the length of v.
-cpFloat cpvlength(const cpVect v);
-
 /// Spherical linearly interpolate between v1 and v2.
 cpVect cpvslerp(const cpVect v1, const cpVect v2, const cpFloat t);
 
 /// Spherical linearly interpolate between v1 towards v2 by no more than angle a radians
 cpVect cpvslerpconst(const cpVect v1, const cpVect v2, const cpFloat a);
 
-/// Returns the unit length vector for the given angle (in radians).
-cpVect cpvforangle(const cpFloat a);
-
-/// Returns the angular direction v is pointing in (in radians).
-cpFloat cpvtoangle(const cpVect v);
-
-/**
-	Returns a string representation of v. Intended mostly for debugging purposes and not production use.
-	
-	@attention The string points to a static local and is reset every time the function is called.
-	If you want to print more than one vector you will have to split up your printing onto separate lines.
-*/
-char *cpvstr(const cpVect v);
+///	Returns a string representation of v. Intended mostly for debugging purposes and not production use.
+///	@attention The string points to a static local and is reset every time the function is called.
+///	If you want to print more than one vector you will have to split up your printing onto separate lines.
+char* cpvstr(const cpVect v);
 
 /// Check if two vectors are equal. (Be careful when comparing floating point numbers!)
-static inline cpBool
-cpveql(const cpVect v1, const cpVect v2)
+static inline cpBool cpveql(const cpVect v1, const cpVect v2)
 {
 	return (v1.x == v2.x && v1.y == v2.y);
 }
 
 /// Add two vectors
-static inline cpVect
-cpvadd(const cpVect v1, const cpVect v2)
+static inline cpVect cpvadd(const cpVect v1, const cpVect v2)
 {
 	return cpv(v1.x + v2.x, v1.y + v2.y);
 }
 
-/// Negate a vector.
-static inline cpVect
-cpvneg(const cpVect v)
+/// Subtract two vectors.
+static inline cpVect cpvsub(const cpVect v1, const cpVect v2)
 {
-	return cpv(-v.x, -v.y);
+	return cpv(v1.x - v2.x, v1.y - v2.y);
 }
 
-/// Subtract two vectors.
-static inline cpVect
-cpvsub(const cpVect v1, const cpVect v2)
+/// Negate a vector.
+static inline cpVect cpvneg(const cpVect v)
 {
-	return cpv(v1.x - v2.x, v1.y - v2.y);
+	return cpv(-v.x, -v.y);
 }
 
 /// Scalar multiplication.
-static inline cpVect
-cpvmult(const cpVect v, const cpFloat s)
+static inline cpVect cpvmult(const cpVect v, const cpFloat s)
 {
 	return cpv(v.x*s, v.y*s);
 }
 
 /// Vector dot product.
-static inline cpFloat
-cpvdot(const cpVect v1, const cpVect v2)
+static inline cpFloat cpvdot(const cpVect v1, const cpVect v2)
 {
 	return v1.x*v2.x + v1.y*v2.y;
 }
 
-/**
-	2D vector cross product analog.
-	The cross product of 2D vectors results in a 3D vector with only a z component.
-	This function returns the magnitude of the z value.
-*/
-static inline cpFloat
-cpvcross(const cpVect v1, const cpVect v2)
+/// 2D vector cross product analog.
+/// The cross product of 2D vectors results in a 3D vector with only a z component.
+/// This function returns the magnitude of the z value.
+static inline cpFloat cpvcross(const cpVect v1, const cpVect v2)
 {
 	return v1.x*v2.y - v1.y*v2.x;
 }
 
 /// Returns a perpendicular vector. (90 degree rotation)
-static inline cpVect
-cpvperp(const cpVect v)
+static inline cpVect cpvperp(const cpVect v)
 {
 	return cpv(-v.y, v.x);
 }
 
 /// Returns a perpendicular vector. (-90 degree rotation)
-static inline cpVect
-cpvrperp(const cpVect v)
+static inline cpVect cpvrperp(const cpVect v)
 {
 	return cpv(v.y, -v.x);
 }
 
 /// Returns the vector projection of v1 onto v2.
-static inline cpVect
-cpvproject(const cpVect v1, const cpVect v2)
+static inline cpVect cpvproject(const cpVect v1, const cpVect v2)
 {
 	return cpvmult(v2, cpvdot(v1, v2)/cpvdot(v2, v2));
 }
 
+/// Returns the unit length vector for the given angle (in radians).
+static inline cpVect cpvforangle(const cpFloat a)
+{
+	return cpv(cpfcos(a), cpfsin(a));
+}
+
+/// Returns the angular direction v is pointing in (in radians).
+static inline cpFloat cpvtoangle(const cpVect v)
+{
+	return cpfatan2(v.y, v.x);
+}
+
 /// Uses complex number multiplication to rotate v1 by v2. Scaling will occur if v1 is not a unit vector.
-static inline cpVect
-cpvrotate(const cpVect v1, const cpVect v2)
+static inline cpVect cpvrotate(const cpVect v1, const cpVect v2)
 {
 	return cpv(v1.x*v2.x - v1.y*v2.y, v1.x*v2.y + v1.y*v2.x);
 }
 
 /// Inverse of cpvrotate().
-static inline cpVect
-cpvunrotate(const cpVect v1, const cpVect v2)
+static inline cpVect cpvunrotate(const cpVect v1, const cpVect v2)
 {
 	return cpv(v1.x*v2.x + v1.y*v2.y, v1.y*v2.x - v1.x*v2.y);
 }
 
 /// Returns the squared length of v. Faster than cpvlength() when you only need to compare lengths.
-static inline cpFloat
-cpvlengthsq(const cpVect v)
+static inline cpFloat cpvlengthsq(const cpVect v)
 {
 	return cpvdot(v, v);
 }
 
+/// Returns the length of v.
+static inline cpFloat cpvlength(const cpVect v)
+{
+	return cpfsqrt(cpvdot(v, v));
+}
+
 /// Linearly interpolate between v1 and v2.
-static inline cpVect
-cpvlerp(const cpVect v1, const cpVect v2, const cpFloat t)
+static inline cpVect cpvlerp(const cpVect v1, const cpVect v2, const cpFloat t)
 {
 	return cpvadd(cpvmult(v1, 1.0f - t), cpvmult(v2, t));
 }
 
 /// Returns a normalized copy of v.
-static inline cpVect
-cpvnormalize(const cpVect v)
+static inline cpVect cpvnormalize(const cpVect v)
 {
 	return cpvmult(v, 1.0f/cpvlength(v));
 }
 
 /// Returns a normalized copy of v or cpvzero if v was already cpvzero. Protects against divide by zero errors.
-static inline cpVect
-cpvnormalize_safe(const cpVect v)
+static inline cpVect cpvnormalize_safe(const cpVect v)
 {
 	return (v.x == 0.0f && v.y == 0.0f ? cpvzero : cpvnormalize(v));
 }
 
 /// Clamp v to length len.
-static inline cpVect
-cpvclamp(const cpVect v, const cpFloat len)
+static inline cpVect cpvclamp(const cpVect v, const cpFloat len)
 {
 	return (cpvdot(v,v) > len*len) ? cpvmult(cpvnormalize(v), len) : v;
 }
 
 /// Linearly interpolate between v1 towards v2 by distance d.
-static inline cpVect
-cpvlerpconst(cpVect v1, cpVect v2, cpFloat d)
+static inline cpVect cpvlerpconst(cpVect v1, cpVect v2, cpFloat d)
 {
 	return cpvadd(v1, cpvclamp(cpvsub(v2, v1), d));
 }
 
 /// Returns the distance between v1 and v2.
-static inline cpFloat
-cpvdist(const cpVect v1, const cpVect v2)
+static inline cpFloat cpvdist(const cpVect v1, const cpVect v2)
 {
 	return cpvlength(cpvsub(v1, v2));
 }
 
 /// Returns the squared distance between v1 and v2. Faster than cpvdist() when you only need to compare distances.
-static inline cpFloat
-cpvdistsq(const cpVect v1, const cpVect v2)
+static inline cpFloat cpvdistsq(const cpVect v1, const cpVect v2)
 {
 	return cpvlengthsq(cpvsub(v1, v2));
 }
 
 /// Returns true if the distance between v1 and v2 is less than dist.
-static inline cpBool
-cpvnear(const cpVect v1, const cpVect v2, const cpFloat dist)
+static inline cpBool cpvnear(const cpVect v1, const cpVect v2, const cpFloat dist)
 {
 	return cpvdistsq(v1, v2) < dist*dist;
 }
+
+/// @}
+
+/// @defgroup cpMat2x2 cpMat2x2
+/// 2x2 matrix type used for tensors and such.
+/// @{
+
+static inline cpMat2x2
+cpMat2x2New(cpFloat a, cpFloat b, cpFloat c, cpFloat d)
+{
+	cpMat2x2 m = {a, b, c, d};
+	return m;
+}
+
+static inline cpVect
+cpMat2x2Transform(cpMat2x2 m, cpVect v)
+{
+	return cpv(v.x*m.a + v.y*m.b, v.x*m.c + v.y*m.d);
+}
+
+///@}

data/ext/chipmunk/extconf.rb

@@ -5,47 +5,20 @@ RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 if ARGV.member?('--help') || ARGV.member?('-?')
   puts "ruby extconf.rb:"
   puts "Options for the Ruby bindings to Chipmunk: "
-#  puts "--disable-vendor    Disables vendoring Chipmunk."
-#  puts "--enable-vendor     Enables vendoring Chipmunk."
   puts "--enable-macosx     Enables compiling for OS-X."
   puts "--enable-64         Enables compiling to 64 bits targets."
   puts
   exit
 end
 
-p "pwd", Dir.pwd
-
 dir_config('chipmunk')
-
-# VENDORED_CHIPMUNK     = 'chipmunk-5.3.4'
-# VENDORED_SRC_DIR      =  File.join($srcdir, 'vendor', VENDORED_CHIPMUNK, 'src')
-# VENDORED_SRC_DIR2     =  File.join($srcdir, 'vendor', VENDORED_CHIPMUNK, 'src',
-#                                   'constraints')
-# VENDORED_INCLUDE_DIR  =  File.join($srcdir, 'vendor', VENDORED_CHIPMUNK, 'include'
-#                                'chipmunk')
-
-MINGW = '/usr/i586-mingw32msvc'
-CHIPMUNK_HEADER   = 'chipmunk.h'
-CHIPMUNK_NAME     = 'chipmunk'
-CHIPMUNK_FUNCTION = 'cpMomentForPoly'
-CHIPMUNK_INCLUDE  = [ '/usr/include',
-                      File.join(MINGW, 'include'),
-                      File.join(MINGW, 'include', 'chipmunk'),
-                     '/usr/local/include',
-                     '/usr/include/chipmunk',
-                     '/usr/local/include/chipmunk'
-                    ]
-CHIPMUNK_LIBDIR   = ['/usr/lib', File.join(MINGW, 'lib'), '/usr/local/lib']
-
-# This is a bit of a trick to cleanly vendor the chipmunk C library.
-# sources           = Dir.glob(File.join($srcdir, 'rb_*.c')).to_a
-# normally, we need the rb_xxx files...
-
 have_header('chipmunk.h')
 
 if enable_config("macosx", false)
-    $CFLAGS += ' -arch ppc -arch i386 -arch x86_64'
-    $LDFLAGS += ' -arch x86_64 -arch i386 -arch ppc'
+    # $CFLAGS += ' -arch ppc -arch i386 -arch x86_64'
+    # $LDFLAGS += ' -arch x86_64 -arch i386 -arch ppc'
+    # $CFLAGS += ' -arch x86_64 -arch i386'
+    # $LDFLAGS += ' -arch x86_64 -arch i386'
 end
 
 if enable_config("64", false)

data/ext/chipmunk/prime.h

@@ -61,7 +61,7 @@ next_prime(int n)
 	int i = 0;
 	while(n > primes[i]){
 		i++;
-		cpAssert(primes[i], "Tried to resize a hash table to a size greater than 1610612741 O_o"); // realistically this should never happen
+		cpAssertHard(primes[i], "Tried to resize a hash table to a size greater than 1610612741 O_o"); // realistically this should never happen
 	}
 	
 	return primes[i];

data/ext/chipmunk/rb_chipmunk.c

@@ -29,38 +29,23 @@
 VALUE m_Chipmunk;
 
 ID id_parent;
+VALUE cpObjectToIntHash;
 
-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;
-}
+int
+CP_OBJ2INT(VALUE object) {
+  VALUE intValue = rb_hash_aref(cpObjectToIntHash, object);
+  int nextInt = 0;
 
-static VALUE
-rb_get_cp_collision_slop(VALUE self) {
-  return rb_float_new(cp_collision_slop);
-}
+  if(NIL_P(intValue)) {
+    if (RHASH(cpObjectToIntHash)->ntbl) {
+      nextInt = RHASH(cpObjectToIntHash)->ntbl->num_entries;
+    }
+    rb_hash_aset(cpObjectToIntHash, object, INT2NUM(nextInt));
+  } else {
+    nextInt = NUM2INT(intValue);
+  }
 
-static VALUE
-rb_set_cp_collision_slop(VALUE self, VALUE num) {
-  cp_collision_slop = NUM2DBL(num);
-  return num;
-}
-
-static VALUE
-rb_set_cp_contact_persistence(VALUE self, VALUE num) {
-  cp_contact_persistence = NUM2UINT(num);
-  return num;
-}
-
-static VALUE
-rb_get_cp_contact_persistence(VALUE self) {
-  return UINT2NUM(cp_contact_persistence);
+  return nextInt;
 }
 
 
@@ -79,7 +64,8 @@ rb_cpMomentForSegment(VALUE self, VALUE m, VALUE v1, VALUE v2) {
 static VALUE
 rb_cpMomentForPoly(VALUE self, VALUE m, VALUE arr, VALUE offset) {
   Check_Type(arr, T_ARRAY);
-  long numVerts    = RARRAY_LEN(arr);
+  // TODO do not cast... use stdint.h in chipmunk
+  int numVerts    = (int)RARRAY_LEN(arr);
   VALUE *ary_ptr  = RARRAY_PTR(arr);
   cpVect verts[numVerts];
 
@@ -111,13 +97,14 @@ rb_cpAreaForSegment(VALUE self, VALUE v1, VALUE v2, VALUE r) {
 static VALUE
 rb_cpAreaForPoly(VALUE self, VALUE arr) {
   Check_Type(arr, T_ARRAY);
-  long numVerts   = RARRAY_LEN(arr);
+  // TODO do not cast... use stdint.h in chipmunk
+  int numVerts   = (int)RARRAY_LEN(arr);
   VALUE *ary_ptr = RARRAY_PTR(arr);
   cpVect verts[numVerts];
 
-  for(long i = 0; i < numVerts; i++)
+  for(int i = 0; i < numVerts; i++) { 
     verts[i] = *VGET(ary_ptr[i]);
-
+  }
   cpFloat area   = cpAreaForPoly(numVerts, verts);
   return rb_float_new(area);
 }
@@ -150,7 +137,8 @@ rb_cpflerpconst(VALUE self, VALUE f1, VALUE f2, VALUE d) {
 static VALUE
 rb_cpCentroidForPoly(VALUE self,  VALUE arr) {
   Check_Type(arr, T_ARRAY);
-  long numVerts   = RARRAY_LEN(arr);
+  // TODO do not cast... use stdint.h in chipmunk
+  int numVerts   = (int)RARRAY_LEN(arr);
   VALUE *ary_ptr = RARRAY_PTR(arr);
   cpVect verts[numVerts];
 
@@ -163,7 +151,8 @@ rb_cpCentroidForPoly(VALUE self,  VALUE arr) {
 static VALUE
 rb_cpRecenterPoly(VALUE self,  VALUE arr) {
   Check_Type(arr, T_ARRAY);
-  long numVerts   = RARRAY_LEN(arr);
+  // TODO do not cast... use stdint.h in chipmunk
+  int numVerts   = (int)RARRAY_LEN(arr);
   VALUE *ary_ptr = RARRAY_PTR(arr);
   cpVect verts[numVerts];
 
@@ -177,6 +166,15 @@ rb_cpRecenterPoly(VALUE self,  VALUE arr) {
   return arr;
 }
 
+// We need this as rb_obj_method_arity is not in 1.8.7
+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);
+}
+
+
 
 
 
@@ -185,18 +183,11 @@ 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, "contact_persistence", rb_get_cp_contact_persistence, 0);
-  rb_define_module_function(m_Chipmunk, "contact_persistence=", rb_set_cp_contact_persistence, 1);
-
 
+  cpObjectToIntHash = rb_hash_new();
+  /* rb_gv_set("$__cpObj", cpObjectToIntHash);  */
+  rb_gc_register_mark_object(cpObjectToIntHash);
 
   rb_define_module_function(m_Chipmunk, "clamp", rb_cpfclamp, 3);
   rb_define_module_function(m_Chipmunk, "flerp", rb_cpflerp, 3);