chipmunk 4.1.0 → 5.2.0

data/ext/chipmunk/cpVect.c

@@ -19,39 +19,47 @@
  * SOFTWARE.
  */
  
-#include "stdio.h"
-#include "math.h"
+#include <stdio.h>
+#include <math.h>
 
 #include "chipmunk.h"
 
 cpFloat
 cpvlength(const cpVect v)
 {
-	return sqrtf( cpvdot(v, v) );
+	return cpfsqrt( cpvdot(v, v) );
 }
 
-cpFloat
-cpvlengthsq(const cpVect v)
+inline cpVect
+cpvslerp(const cpVect v1, const cpVect v2, const cpFloat t)
 {
-	return cpvdot(v, v);
+	cpFloat omega = cpfacos(cpvdot(v1, v2));
+	
+	if(omega){
+		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
-cpvnormalize(const cpVect v)
+cpvslerpconst(const cpVect v1, const cpVect v2, const cpFloat a)
 {
-	return cpvmult( v, 1.0f/cpvlength(v) );
+	cpFloat angle = cpfacos(cpvdot(v1, v2));
+	return cpvslerp(v1, v2, cpfmin(a, angle)/angle);
 }
 
 cpVect
 cpvforangle(const cpFloat a)
 {
-	return cpv(cos(a), sin(a));
+	return cpv(cpfcos(a), cpfsin(a));
 }
 
 cpFloat
 cpvtoangle(const cpVect v)
 {
-	return atan2(v.y, v.x);
+	return cpfatan2(v.y, v.x);
 }
 
 char*

data/ext/chipmunk/extconf.rb

@@ -1,4 +1,34 @@
-require 'mkmf'
-
-$CFLAGS += ' -std=gnu99 -ffast-math'
-create_makefile('chipmunk')
+require 'mkmf'
+
+#dir_config('chipmunk')          
+
+# CHIPMUNK_HEADER   = 'chipmunk.h'
+# CHIPMUNK_NAME     = 'chipmunk'
+# CHIPMUNK_FUNCTION = 'cpMomentForPoly'
+# CHIPMUNK_INCLUDE  = ['/usr/include', 
+#                      '/usr/local/include', 
+#                      '/usr/include/chipmunk',
+#                      '/usr/local/include/chipmunk'
+#                     ]
+# CHIPMUNK_LIBDIR   = ['/usr/lib', '/usr/local/lib']
+
+# find_header(CHIPMUNK_HEADER, *CHIPMUNK_INCLUDE)
+# find_library(CHIPMUNK_NAME, CHIPMUNK_FUNCTION, *CHIPMUNK_LIBDIR)
+
+=begin
+unless have_library('chipmunk', 'cpMomentForPoly')
+  raise "Could not link to Chipmunk library!" 
+end
+
+have_header('chipmunk.h', include_dirs)
+=end
+ 
+if ARGV[0] == "macosx"
+    $CFLAGS += ' -arch ppc -arch i386 -arch x86_64'
+    $LDFLAGS += ' -arch x86_64 -arch i386 -arch ppc'
+end
+ 
+$CFLAGS += ' -std=gnu99 -ffast-math'
+$CFLAGS += ' -Iinclude/chipmunk/'
+create_makefile('chipmunk')
+

data/ext/chipmunk/{chipmunk.h → include/chipmunk/chipmunk.h}

@@ -25,8 +25,21 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	
-typedef double cpFloat;
+
+void cpMessage(char *message, char *condition, char *file, int line, int isError);
+#ifdef NDEBUG
+	#define	cpAssertWarn(condition, message)
+#else
+	#define cpAssertWarn(condition, message) if(!(condition)) cpMessage(message, #condition, __FILE__, __LINE__, 0)
+#endif
+
+#ifdef NDEBUG
+	#define	cpAssert(condition, message)
+#else
+	#define cpAssert(condition, message) if(!(condition)) cpMessage(message, #condition, __FILE__, __LINE__, 1)
+#endif
+
+#include "chipmunk_types.h"
 	
 static inline cpFloat
 cpfmax(cpFloat a, cpFloat b)
@@ -41,10 +54,29 @@ cpfmin(cpFloat a, cpFloat b)
 }
 
 static inline cpFloat
-cpfclamp(cpFloat f, cpFloat min, cpFloat max){
+cpfabs(cpFloat n)
+{
+	return (n < 0) ? -n : n;
+}
+
+static inline cpFloat
+cpfclamp(cpFloat f, cpFloat min, cpFloat max)
+{
 	return cpfmin(cpfmax(f, min), max);
 }
 
+static inline cpFloat
+cpflerp(cpFloat f1, cpFloat f2, cpFloat t)
+{
+	return f1*(1.0f - t) + f2*t;
+}
+
+static inline cpFloat
+cpflerpconst(cpFloat f1, cpFloat f2, cpFloat d)
+{
+	return f1 + cpfclamp(f2 - f1, -d, d);
+}
+
 #ifndef INFINITY
 	#ifdef _MSC_VER
 		union MSVC_EVIL_FLOAT_HACK
@@ -54,11 +86,25 @@ cpfclamp(cpFloat f, cpFloat min, cpFloat max){
 		};
 		static union MSVC_EVIL_FLOAT_HACK INFINITY_HACK = {{0x00, 0x00, 0x80, 0x7F}};
 		#define INFINITY (INFINITY_HACK.Value)
-	#else
+	#endif
+	
+	#ifdef __GNUC__
+		#define INFINITY (__builtin_inf())
+	#endif
+	
+	#ifndef INFINITY
 		#define INFINITY (1e1000)
 	#endif
 #endif
 
+// Maximum allocated size for various Chipmunk buffer sizes
+#define CP_BUFFER_BYTES (32*1024)
+
+#define cpmalloc malloc
+#define cpcalloc calloc
+#define cprealloc realloc
+#define cpfree free
+
 #include "cpVect.h"
 #include "cpBB.h"
 #include "cpBody.h"
@@ -72,18 +118,29 @@ cpfclamp(cpFloat f, cpFloat min, cpFloat max){
 #include "cpArbiter.h"
 #include "cpCollision.h"
 	
-#include "cpJoint.h"
+#include "constraints/cpConstraint.h"
 
 #include "cpSpace.h"
 
 #define CP_HASH_COEF (3344921057ul)
-#define CP_HASH_PAIR(A, B) ((unsigned int)(A)*CP_HASH_COEF ^ (unsigned int)(B)*CP_HASH_COEF)
+#define CP_HASH_PAIR(A, B) ((cpHashValue)(A)*CP_HASH_COEF ^ (cpHashValue)(B)*CP_HASH_COEF)
 
+extern char *cpVersionString;
 void cpInitChipmunk(void);
 
+// Calculate the moment of inertia for a circle, r1 and r2 are the inner and outer diameters.
+// (A solid circle has an inner diameter of 0)
 cpFloat cpMomentForCircle(cpFloat m, cpFloat r1, cpFloat r2, cpVect offset);
+
+// Calculate the moment of inertia for a line segment. (beveling radius not supported)
+cpFloat cpMomentForSegment(cpFloat m, cpVect a, cpVect b);
+
+// Calculate the moment of inertia for a solid polygon shape.
 cpFloat cpMomentForPoly(cpFloat m, int numVerts, cpVect *verts, cpVect offset);
 
+// Calculate the moment of inertia for a solid box.
+cpFloat cpMomentForBox(cpFloat m, cpFloat width, cpFloat height);
+
 #ifdef __cplusplus
 }
 #endif

data/ext/chipmunk/include/chipmunk/chipmunk_ffi.h

@@ -0,0 +1,42 @@
+// Create non static inlined copies of Chipmunk functions, useful for working with dynamic FFIs
+// This file should only be included in chipmunk.c
+
+#define MAKE_REF(name) __typeof__(name) *_##name = name
+
+MAKE_REF(cpv); // makes a variable named _cpv that contains the function pointer for cpv()
+MAKE_REF(cpvadd);
+MAKE_REF(cpvneg);
+MAKE_REF(cpvsub);
+MAKE_REF(cpvmult);
+MAKE_REF(cpvdot);
+MAKE_REF(cpvcross);
+MAKE_REF(cpvperp);
+MAKE_REF(cpvrperp);
+MAKE_REF(cpvproject);
+MAKE_REF(cpvrotate);
+MAKE_REF(cpvunrotate);
+MAKE_REF(cpvlengthsq);
+MAKE_REF(cpvlerp);
+MAKE_REF(cpvnormalize);
+MAKE_REF(cpvnormalize_safe);
+MAKE_REF(cpvclamp);
+MAKE_REF(cpvlerpconst);
+MAKE_REF(cpvdist);
+MAKE_REF(cpvnear);
+MAKE_REF(cpvdistsq);
+
+MAKE_REF(cpBBNew);
+MAKE_REF(cpBBintersects);
+MAKE_REF(cpBBcontainsBB);
+MAKE_REF(cpBBcontainsVect);
+MAKE_REF(cpBBmerge);
+MAKE_REF(cpBBexpand);
+
+MAKE_REF(cpBodyWorld2Local);
+MAKE_REF(cpBodyLocal2World);
+MAKE_REF(cpBodyApplyImpulse);
+
+MAKE_REF(cpArbiterIsFirstContact);
+MAKE_REF(cpArbiterGetShapes);
+MAKE_REF(cpArbiterGetNormal);
+MAKE_REF(cpArbiterGetPoint);

data/ext/chipmunk/include/chipmunk/chipmunk_types.h

@@ -0,0 +1,80 @@
+#ifdef __APPLE__
+   #import "TargetConditionals.h"
+#endif
+
+// Use single precision floats on the iPhone.
+#if TARGET_OS_IPHONE==1
+	#define CP_USE_DOUBLES 0
+#else
+	// use doubles by default for higher precision
+	#define CP_USE_DOUBLES 1
+#endif
+
+#if CP_USE_DOUBLES
+	typedef double cpFloat;
+	#define cpfsqrt sqrt
+	#define cpfsin sin
+	#define cpfcos cos
+	#define cpfacos acos
+	#define cpfatan2 atan2
+	#define cpfmod fmod
+	#define cpfexp exp
+	#define cpfpow pow
+	#define cpffloor floor
+	#define cpfceil ceil
+#else
+	typedef float cpFloat;
+	#define cpfsqrt sqrtf
+	#define cpfsin sinf
+	#define cpfcos cosf
+	#define cpfacos acosf
+	#define cpfatan2 atan2f
+	#define cpfmod fmodf
+	#define cpfexp expf
+	#define cpfpow powf
+	#define cpffloor floorf
+	#define cpfceil ceilf
+#endif
+
+#if TARGET_OS_IPHONE
+	// CGPoints are structurally the same, and allow
+	// easy interoperability with other iPhone libraries
+	#import <CoreGraphics/CGGeometry.h>
+	typedef CGPoint cpVect;
+#else
+	typedef struct cpVect{cpFloat x,y;} cpVect;
+#endif
+
+typedef unsigned int cpHashValue;
+
+#ifdef CP_DATA_POINTER_TYPE
+	typedef CP_DATA_POINTER_TYPE cpDataPointer;
+#else
+	typedef void * cpDataPointer;
+#endif
+
+#ifdef CP_COLLISION_TYPE_TYPE
+	typedef CP_COLLISION_TYPE_TYPE cpCollisionType;
+#else
+	typedef unsigned int cpCollisionType;
+#endif
+
+#ifdef CP_GROUP_TYPE
+	typedef CP_GROUP_TYPE cpGroup;
+#else
+	typedef unsigned int cpGroup;
+#endif
+
+#ifdef CP_LAYERS_TYPE
+	typedef CP_GROUP_TYPE cpLayers;
+#else
+	typedef unsigned int cpLayers;
+#endif
+
+#ifndef CP_NO_GROUP
+	#define CP_NO_GROUP ((cpGroup)0)
+#endif
+
+#ifndef CP_ALL_LAYERS
+	#define CP_ALL_LAYERS (~(cpLayers)0)
+#endif

data/ext/chipmunk/include/chipmunk/chipmunk_unsafe.h

@@ -0,0 +1,54 @@
+/* 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.
+ */
+
+
+
+/* This header defines a number of "unsafe" operations on Chipmunk objects.
+ * In this case "unsafe" is referring to operations which may reduce the
+ * physical accuracy or numerical stability of the simulation, but will not
+ * cause crashes.
+ *
+ * The prime example is mutating collision shapes. Chipmunk does not support
+ * this directly. Mutating shapes using this API will caused objects in contact
+ * to be pushed apart using Chipmunk's overlap solver, but not using real
+ * persistent velocities. Probably not what you meant, but perhaps close enough.
+ */
+
+#ifndef CHIPMUNK_UNSAFE_HEADER
+#define CHIPMUNK_UNSAFE_HEADER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void cpCircleShapeSetRadius(cpShape *shape, cpFloat radius);
+void cpCircleShapeSetOffset(cpShape *shape, cpVect offset);
+
+void cpSegmentShapeSetEndpoints(cpShape *shape, cpVect a, cpVect b);
+void cpSegmentShapeSetRadius(cpShape *shape, cpFloat radius);
+
+void cpPolyShapeSetVerts(cpShape *shape, int numVerts, cpVect *verts, cpVect offset);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/chipmunk/include/chipmunk/constraints/cpConstraint.h

@@ -0,0 +1,92 @@
+/* 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.
+ */
+
+// TODO: Comment me!
+	
+extern cpFloat cp_constraint_bias_coef;
+
+struct cpConstraintClass;
+struct cpConstraint;
+
+typedef void (*cpConstraintPreStepFunction)(struct cpConstraint *constraint, cpFloat dt, cpFloat dt_inv);
+typedef void (*cpConstraintApplyImpulseFunction)(struct cpConstraint *constraint);
+typedef cpFloat (*cpConstraintGetImpulseFunction)(struct cpConstraint *constraint);
+
+typedef struct cpConstraintClass {
+	cpConstraintPreStepFunction preStep;
+	cpConstraintApplyImpulseFunction applyImpulse;
+	cpConstraintGetImpulseFunction getImpulse;
+} cpConstraintClass;
+
+
+
+typedef struct cpConstraint {
+	const cpConstraintClass *klass;
+	
+	cpBody *a, *b;
+	cpFloat maxForce;
+	cpFloat biasCoef;
+	cpFloat maxBias;
+	
+	cpDataPointer data;
+} cpConstraint;
+
+#ifdef CP_USE_DEPRECATED_API_4
+typedef cpConstraint cpJoint;
+#endif
+
+void cpConstraintDestroy(cpConstraint *constraint);
+void cpConstraintFree(cpConstraint *constraint);
+
+
+#define cpConstraintCheckCast(constraint, struct) \
+	cpAssert(constraint->klass == struct##GetClass(), "Constraint is not a "#struct);
+
+
+#define CP_DefineConstraintGetter(struct, type, member, name) \
+static inline type \
+struct##Get##name(cpConstraint *constraint){ \
+	cpConstraintCheckCast(constraint, struct); \
+	return ((struct *)constraint)->member; \
+} \
+
+#define CP_DefineConstraintSetter(struct, type, member, name) \
+static inline void \
+struct##Set##name(cpConstraint *constraint, type value){ \
+	cpConstraintCheckCast(constraint, struct); \
+	((struct *)constraint)->member = value; \
+} \
+
+#define CP_DefineConstraintProperty(struct, type, member, name) \
+CP_DefineConstraintGetter(struct, type, member, name) \
+CP_DefineConstraintSetter(struct, type, member, name)
+
+// Built in Joint types
+#include "cpPinJoint.h"
+#include "cpSlideJoint.h"
+#include "cpPivotJoint.h"
+#include "cpGrooveJoint.h"
+#include "cpDampedSpring.h"
+#include "cpDampedRotarySpring.h"
+#include "cpRotaryLimitJoint.h"
+#include "cpRatchetJoint.h"
+#include "cpGearJoint.h"
+#include "cpSimpleMotor.h"