chipmunk 5.3.4.5 → 6.1.3.0.rc1

data/ext/chipmunk/chipmunk.c

@@ -19,45 +19,42 @@
  * SOFTWARE.
  */
  
-#include <stdlib.h>
 #include <stdio.h>
-#define _USE_MATH_DEFINES
-#include <math.h>
+#include <string.h>
+#include <stdarg.h>
 
-#include "chipmunk.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-	void cpInitCollisionFuncs(void);
-#ifdef __cplusplus
-}
-#endif
+#include "chipmunk_private.h"
 
 void
-cpMessage(const char *message, const char *condition, const char *file, int line, int isError)
+cpMessage(const char *condition, const char *file, int line, cpBool isError, cpBool isHardError, const char *message, ...)
 {
-	fprintf(stderr, (isError ? "Aborting due to Chipmunk error: %s\n" : "Chipmunk warning: %s\n"), message);
+	fprintf(stderr, (isError ? "Aborting due to Chipmunk error: " : "Chipmunk warning: "));
+	
+	va_list vargs;
+	va_start(vargs, message); {
+		vfprintf(stderr, message, vargs);
+		fprintf(stderr, "\n");
+	} va_end(vargs);
+	
 	fprintf(stderr, "\tFailed condition: %s\n", condition);
 	fprintf(stderr, "\tSource:%s:%d\n", file, line);
 	
 	if(isError) abort();
 }
 
+#define STR(s) #s
+#define XSTR(s) STR(s)
 
-const char *cpVersionString = "5.3.4";
+const char *cpVersionString = XSTR(CP_VERSION_MAJOR)"."XSTR(CP_VERSION_MINOR)"."XSTR(CP_VERSION_RELEASE);
 
 void
 cpInitChipmunk(void)
 {
-#ifndef NDEBUG
-	printf("Initializing Chipmunk v%s (Debug Enabled)\n", cpVersionString);
-	printf("Compile with -DNDEBUG defined to disable debug mode and runtime assertion checks\n");
-#endif
-	
-	cpInitCollisionFuncs();
+	cpAssertWarn(cpFalse, "cpInitChipmunk is deprecated and no longer required. It will be removed in the future.");
 }
 
+//MARK: Misc Functions
+
 cpFloat
 cpMomentForCircle(cpFloat m, cpFloat r1, cpFloat r2, cpVect offset)
 {
@@ -67,22 +64,20 @@ cpMomentForCircle(cpFloat m, cpFloat r1, cpFloat r2, cpVect offset)
 cpFloat
 cpAreaForCircle(cpFloat r1, cpFloat r2)
 {
-	return 2.0f*(cpFloat)M_PI*cpfabs(r1*r1 - r2*r2);
+	return (cpFloat)M_PI*cpfabs(r1*r1 - r2*r2);
 }
 
 cpFloat
 cpMomentForSegment(cpFloat m, cpVect a, cpVect b)
 {
-	cpFloat length = cpvlength(cpvsub(b, a));
-	cpVect offset = cpvmult(cpvadd(a, b), 1.0f/2.0f);
-	
-	return m*(length*length/12.0f + cpvlengthsq(offset));
+	cpVect offset = cpvmult(cpvadd(a, b), 0.5f);
+	return m*(cpvdistsq(b, a)/12.0f + cpvlengthsq(offset));
 }
 
 cpFloat
 cpAreaForSegment(cpVect a, cpVect b, cpFloat r)
 {
-	return 2.0f*r*((cpFloat)M_PI*r + cpvdist(a, b));
+	return r*((cpFloat)M_PI*r + 2.0f*cpvdist(a, b));
 }
 
 cpFloat
@@ -112,7 +107,7 @@ cpAreaForPoly(const int numVerts, const cpVect *verts)
 		area += cpvcross(verts[i], verts[(i+1)%numVerts]);
 	}
 	
-	return area/2.0f;
+	return -area/2.0f;
 }
 
 cpVect
@@ -148,4 +143,180 @@ cpMomentForBox(cpFloat m, cpFloat width, cpFloat height)
 	return m*(width*width + height*height)/12.0f;
 }
 
+cpFloat
+cpMomentForBox2(cpFloat m, cpBB box)
+{
+	cpFloat width = box.r - box.l;
+	cpFloat height = box.t - box.b;
+	cpVect offset = cpvmult(cpv(box.l + box.r, box.b + box.t), 0.5f);
+	
+	// TODO NaN when offset is 0 and m is INFINITY
+	return cpMomentForBox(m, width, height) + m*cpvlengthsq(offset);
+}
+
+//MARK: Quick Hull
+
+void
+cpLoopIndexes(cpVect *verts, int count, int *start, int *end)
+{
+	(*start) = (*end) = 0;
+	cpVect min = verts[0];
+	cpVect max = min;
+	
+  for(int i=1; i<count; i++){
+    cpVect v = verts[i];
+		
+    if(v.x < min.x || (v.x == min.x && v.y < min.y)){
+      min = v;
+      (*start) = i;
+    } else if(v.x > max.x || (v.x == max.x && v.y > max.y)){
+			max = v;
+			(*end) = i;
+		}
+	}
+}
+
+#define SWAP(__A__, __B__) {cpVect __TMP__ = __A__; __A__ = __B__; __B__ = __TMP__;}
+
+static int
+QHullPartition(cpVect *verts, int count, cpVect a, cpVect b, cpFloat tol)
+{
+	if(count == 0) return 0;
+	
+	cpFloat max = 0;
+	int pivot = 0;
+	
+	cpVect delta = cpvsub(b, a);
+	cpFloat valueTol = tol*cpvlength(delta);
+	
+	int head = 0;
+	for(int tail = count-1; head <= tail;){
+		cpFloat value = cpvcross(delta, cpvsub(verts[head], a));
+		if(value > valueTol){
+			if(value > max){
+				max = value;
+				pivot = head;
+			}
+			
+			head++;
+		} else {
+			SWAP(verts[head], verts[tail]);
+			tail--;
+		}
+	}
+	
+	// move the new pivot to the front if it's not already there.
+	if(pivot != 0) SWAP(verts[0], verts[pivot]);
+	return head;
+}
+
+static int
+QHullReduce(cpFloat tol, cpVect *verts, int count, cpVect a, cpVect pivot, cpVect b, cpVect *result)
+{
+	if(count < 0){
+		return 0;
+	} else if(count == 0) {
+		result[0] = pivot;
+		return 1;
+	} else {
+		int left_count = QHullPartition(verts, count, a, pivot, tol);
+		int index = QHullReduce(tol, verts + 1, left_count - 1, a, verts[0], pivot, result);
+		
+		result[index++] = pivot;
+		
+		int right_count = QHullPartition(verts + left_count, count - left_count, pivot, b, tol);
+		return index + QHullReduce(tol, verts + left_count + 1, right_count - 1, pivot, verts[left_count], b, result + index);
+	}
+}
+
+// QuickHull seemed like a neat algorithm, and efficient-ish for large input sets.
+// My implementation performs an in place reduction using the result array as scratch space.
+int
+cpConvexHull(int count, cpVect *verts, cpVect *result, int *first, cpFloat tol)
+{
+	if(result){
+		// Copy the line vertexes into the empty part of the result polyline to use as a scratch buffer.
+		memcpy(result, verts, count*sizeof(cpVect));
+	} else {
+		// If a result array was not specified, reduce the input instead.
+		result = verts;
+	}
+	
+	// Degenerate case, all poins are the same.
+	int start, end;
+	cpLoopIndexes(verts, count, &start, &end);
+	if(start == end){
+		if(first) (*first) = 0;
+		return 1;
+	}
+	
+	SWAP(result[0], result[start]);
+	SWAP(result[1], result[end == 0 ? start : end]);
+	
+	cpVect a = result[0];
+	cpVect b = result[1];
+	
+	if(first) (*first) = start;
+	int resultCount = QHullReduce(tol, result + 2, count - 2, a, b, a, result + 1) + 1;
+	cpAssertSoft(cpPolyValidate(result, resultCount),
+		"Internal error: cpConvexHull() and cpPolyValidate() did not agree."
+		"Please report this error with as much info as you can.");
+	return resultCount;
+}
+
+//MARK: Alternate Block Iterators
+
+#if defined(__has_extension)
+#if __has_extension(blocks)
+
+static void IteratorFunc(void *ptr, void (^block)(void *ptr)){block(ptr);}
+
+void cpSpaceEachBody_b(cpSpace *space, void (^block)(cpBody *body)){
+	cpSpaceEachBody(space, (cpSpaceBodyIteratorFunc)IteratorFunc, block);
+}
+
+void cpSpaceEachShape_b(cpSpace *space, void (^block)(cpShape *shape)){
+	cpSpaceEachShape(space, (cpSpaceShapeIteratorFunc)IteratorFunc, block);
+}
+
+void cpSpaceEachConstraint_b(cpSpace *space, void (^block)(cpConstraint *constraint)){
+	cpSpaceEachConstraint(space, (cpSpaceConstraintIteratorFunc)IteratorFunc, block);
+}
+
+static void BodyIteratorFunc(cpBody *body, void *ptr, void (^block)(void *ptr)){block(ptr);}
+
+void cpBodyEachShape_b(cpBody *body, void (^block)(cpShape *shape)){
+	cpBodyEachShape(body, (cpBodyShapeIteratorFunc)BodyIteratorFunc, block);
+}
+
+void cpBodyEachConstraint_b(cpBody *body, void (^block)(cpConstraint *constraint)){
+	cpBodyEachConstraint(body, (cpBodyConstraintIteratorFunc)BodyIteratorFunc, block);
+}
+
+void cpBodyEachArbiter_b(cpBody *body, void (^block)(cpArbiter *arbiter)){
+	cpBodyEachArbiter(body, (cpBodyArbiterIteratorFunc)BodyIteratorFunc, block);
+}
+
+static void NearestPointQueryIteratorFunc(cpShape *shape, cpFloat distance, cpVect point, cpSpaceNearestPointQueryBlock block){block(shape, distance, point);}
+void cpSpaceNearestPointQuery_b(cpSpace *space, cpVect point, cpFloat maxDistance, cpLayers layers, cpGroup group, cpSpaceNearestPointQueryBlock block){
+	cpSpaceNearestPointQuery(space, point, maxDistance, layers, group, (cpSpaceNearestPointQueryFunc)NearestPointQueryIteratorFunc, block);
+}
+
+static void SegmentQueryIteratorFunc(cpShape *shape, cpFloat t, cpVect n, cpSpaceSegmentQueryBlock block){block(shape, t, n);}
+void cpSpaceSegmentQuery_b(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSpaceSegmentQueryBlock block){
+	cpSpaceSegmentQuery(space, start, end, layers, group, (cpSpaceSegmentQueryFunc)SegmentQueryIteratorFunc, block);
+}
+
+void cpSpaceBBQuery_b(cpSpace *space, cpBB bb, cpLayers layers, cpGroup group, cpSpaceBBQueryBlock block){
+	cpSpaceBBQuery(space, bb, layers, group, (cpSpaceBBQueryFunc)IteratorFunc, block);
+}
+
+static void ShapeQueryIteratorFunc(cpShape *shape, cpContactPointSet *points, cpSpaceShapeQueryBlock block){block(shape, points);}
+cpBool cpSpaceShapeQuery_b(cpSpace *space, cpShape *shape, cpSpaceShapeQueryBlock block){
+	return cpSpaceShapeQuery(space, shape, (cpSpaceShapeQueryFunc)ShapeQueryIteratorFunc, block);
+}
+
+#endif
+#endif
+
 #include "chipmunk_ffi.h"

data/ext/chipmunk/chipmunk.h

@@ -22,12 +22,15 @@
 #ifndef CHIPMUNK_HEADER
 #define CHIPMUNK_HEADER
 
+#include <stdlib.h>
+#include <math.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #ifndef CP_ALLOW_PRIVATE_ACCESS
-	#define CP_ALLOW_PRIVATE_ACCESS 1
+	#define CP_ALLOW_PRIVATE_ACCESS 0
 #endif
 
 #if CP_ALLOW_PRIVATE_ACCESS == 1
@@ -36,119 +39,172 @@ extern "C" {
 	#define CP_PRIVATE(symbol) symbol##_private
 #endif
 
-void cpMessage(const char *message, const char *condition, const char *file, int line, int isError);
+void cpMessage(const char *condition, const char *file, int line, int isError, int isHardError, const char *message, ...);
 #ifdef NDEBUG
-	#define	cpAssertWarn(condition, message)
+	#define	cpAssertWarn(condition, ...)
 #else
-	#define cpAssertWarn(condition, message) if(!(condition)) cpMessage(message, #condition, __FILE__, __LINE__, 0)
+	#define cpAssertWarn(condition, ...) if(!(condition)) cpMessage(#condition, __FILE__, __LINE__, 0, 0, __VA_ARGS__)
 #endif
 
 #ifdef NDEBUG
-	#define	cpAssert(condition, message)
+	#define	cpAssertSoft(condition, ...)
 #else
-	#define cpAssert(condition, message) if(!(condition)) cpMessage(message, #condition, __FILE__, __LINE__, 1)
+	#define cpAssertSoft(condition, ...) if(!(condition)) cpMessage(#condition, __FILE__, __LINE__, 1, 0, __VA_ARGS__)
 #endif
 
+// Hard assertions are important and cheap to execute. They are not disabled by compiling as debug.
+#define cpAssertHard(condition, ...) if(!(condition)) cpMessage(#condition, __FILE__, __LINE__, 1, 1, __VA_ARGS__)
+
+
 #include "chipmunk_types.h"
 	
-#ifndef INFINITY
-	#ifdef _MSC_VER
-		union MSVC_EVIL_FLOAT_HACK
-		{
-			unsigned __int8 Bytes[4];
-			float Value;
-		};
-		static union MSVC_EVIL_FLOAT_HACK INFINITY_HACK = {{0x00, 0x00, 0x80, 0x7F}};
-		#define INFINITY (INFINITY_HACK.Value)
-	#endif
-	
-	#ifdef __GNUC__
-		#define INFINITY (__builtin_inf())
-	#endif
-	
-	#ifndef INFINITY
-		#define INFINITY (1e1000)
-	#endif
+/// @defgroup misc Misc
+/// @{
+
+/// Allocated size for various Chipmunk buffers
+#ifndef CP_BUFFER_BYTES
+	#define CP_BUFFER_BYTES (32*1024)
+#endif
+
+#ifndef cpcalloc
+	/// Chipmunk calloc() alias.
+	#define cpcalloc calloc
+#endif
+
+#ifndef cprealloc
+	/// Chipmunk realloc() alias.
+	#define cprealloc realloc
+#endif
+
+#ifndef cpfree
+	/// Chipmunk free() alias.
+	#define cpfree free
 #endif
 
-// Maximum allocated size for various Chipmunk buffers
-#define CP_BUFFER_BYTES (32*1024)
+typedef struct cpArray cpArray;
+typedef struct cpHashSet cpHashSet;
+
+typedef struct cpBody cpBody;
+typedef struct cpShape cpShape;
+typedef struct cpConstraint cpConstraint;
+
+typedef struct cpCollisionHandler cpCollisionHandler;
+typedef struct cpArbiter cpArbiter;
 
-#define cpmalloc malloc
-#define cpcalloc calloc
-#define cprealloc realloc
-#define cpfree free
+typedef struct cpSpace cpSpace;
 
 #include "cpVect.h"
 #include "cpBB.h"
-#include "cpArray.h"
-#include "cpHashSet.h"
-#include "cpSpaceHash.h"
+#include "cpSpatialIndex.h"
 
 #include "cpBody.h"
 #include "cpShape.h"
 #include "cpPolyShape.h"
 
-#include "cpArbiter.h"
-#include "cpCollision.h"
-	
+#include "cpArbiter.h"	
 #include "constraints/cpConstraint.h"
 
 #include "cpSpace.h"
 
-#define CP_HASH_COEF (3344921057ul)
-#define CP_HASH_PAIR(A, B) ((cpHashValue)(A)*CP_HASH_COEF ^ (cpHashValue)(B)*CP_HASH_COEF)
+// Chipmunk 6.1.3
+#define CP_VERSION_MAJOR 6
+#define CP_VERSION_MINOR 1
+#define CP_VERSION_RELEASE 3
 
+/// Version string.
 extern const char *cpVersionString;
+
+/// @deprecated
 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.
-*/
+/// Enables segment to segment shape collisions.
+void cpEnableSegmentToSegmentCollisions(void);
+
+
+/// Calculate the moment of inertia for a circle.
+/// @c r1 and @c 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 area of a hollow circle.
-*/
+/// Calculate area of a hollow circle.
+/// @c r1 and @c r2 are the inner and outer diameters. A solid circle has an inner diameter of 0.
 cpFloat cpAreaForCircle(cpFloat r1, cpFloat r2);
 
-/**
-	Calculate the moment of inertia for a line segment.
-	Beveling radius is not supported.
-*/
+/// Calculate the moment of inertia for a line segment.
+/// Beveling radius is not supported.
 cpFloat cpMomentForSegment(cpFloat m, cpVect a, cpVect b);
 
-/**
-	Calculate the area of a fattened (capsule shaped) line segment.
-*/
+/// Calculate the area of a fattened (capsule shaped) line segment.
 cpFloat cpAreaForSegment(cpVect a, cpVect b, cpFloat r);
 
-/**
-	Calculate the moment of inertia for a solid polygon shape assuming it's center of gravity is at it's centroid. The offset is added to each vertex.
-*/
+/// Calculate the moment of inertia for a solid polygon shape assuming it's center of gravity is at it's centroid. The offset is added to each vertex.
 cpFloat cpMomentForPoly(cpFloat m, int numVerts, const cpVect *verts, cpVect offset);
 
-/**
-	Calculate the signed area of a polygon.
-*/
+/// Calculate the signed area of a polygon. A Clockwise winding gives positive area.
+/// This is probably backwards from what you expect, but matches Chipmunk's the winding for poly shapes.
 cpFloat cpAreaForPoly(const int numVerts, const cpVect *verts);
 
-/**
-	Calculate the natural centroid of a polygon.
-*/
+/// Calculate the natural centroid of a polygon.
 cpVect cpCentroidForPoly(const int numVerts, const cpVect *verts);
 
-/**
-	Center the polygon on the origin. (Subtracts the centroid of the polygon from each vertex)
-*/
+/// Center the polygon on the origin. (Subtracts the centroid of the polygon from each vertex)
 void cpRecenterPoly(const int numVerts, cpVect *verts);
 
-/**
-	Calculate the moment of inertia for a solid box.
-*/
+/// Calculate the moment of inertia for a solid box.
 cpFloat cpMomentForBox(cpFloat m, cpFloat width, cpFloat height);
 
+/// Calculate the moment of inertia for a solid box.
+cpFloat cpMomentForBox2(cpFloat m, cpBB box);
+
+/// Calculate the convex hull of a given set of points. Returns the count of points in the hull.
+/// @c result must be a pointer to a @c cpVect array with at least @c count elements. If @c result is @c NULL, then @c verts will be reduced instead.
+/// @c first is an optional pointer to an integer to store where the first vertex in the hull came from (i.e. verts[first] == result[0])
+/// @c tol is the allowed amount to shrink the hull when simplifying it. A tolerance of 0.0 creates an exact hull.
+int cpConvexHull(int count, cpVect *verts, cpVect *result, int *first, cpFloat tol);
+
+#ifdef _MSC_VER
+#include "malloc.h"
+#endif
+
+/// Convenience macro to work with cpConvexHull.
+/// @c count and @c verts is the input array passed to cpConvexHull().
+/// @c count_var and @c verts_var are the names of the variables the macro creates to store the result.
+/// The output vertex array is allocated on the stack using alloca() so it will be freed automatically, but cannot be returned from the current scope.
+#define CP_CONVEX_HULL(__count__, __verts__, __count_var__, __verts_var__) \
+cpVect *__verts_var__ = (cpVect *)alloca(__count__*sizeof(cpVect)); \
+int __count_var__ = cpConvexHull(__count__, __verts__, __verts_var__, NULL, 0.0); \
+
+#if defined(__has_extension)
+#if __has_extension(blocks)
+// Define alternate block based alternatives for a few of the callback heavy functions.
+// Collision handlers are post-step callbacks are not included to avoid memory management issues.
+// If you want to use blocks for those and are aware of how to correctly manage the memory, the implementation is trivial. 
+
+void cpSpaceEachBody_b(cpSpace *space, void (^block)(cpBody *body));
+void cpSpaceEachShape_b(cpSpace *space, void (^block)(cpShape *shape));
+void cpSpaceEachConstraint_b(cpSpace *space, void (^block)(cpConstraint *constraint));
+
+void cpBodyEachShape_b(cpBody *body, void (^block)(cpShape *shape));
+void cpBodyEachConstraint_b(cpBody *body, void (^block)(cpConstraint *constraint));
+void cpBodyEachArbiter_b(cpBody *body, void (^block)(cpArbiter *arbiter));
+
+typedef void (^cpSpaceNearestPointQueryBlock)(cpShape *shape, cpFloat distance, cpVect point);
+void cpSpaceNearestPointQuery_b(cpSpace *space, cpVect point, cpFloat maxDistance, cpLayers layers, cpGroup group, cpSpaceNearestPointQueryBlock block);
+
+typedef void (^cpSpaceSegmentQueryBlock)(cpShape *shape, cpFloat t, cpVect n);
+void cpSpaceSegmentQuery_b(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSpaceSegmentQueryBlock block);
+
+typedef void (^cpSpaceBBQueryBlock)(cpShape *shape);
+void cpSpaceBBQuery_b(cpSpace *space, cpBB bb, cpLayers layers, cpGroup group, cpSpaceBBQueryBlock block);
+
+typedef void (^cpSpaceShapeQueryBlock)(cpShape *shape, cpContactPointSet *points);
+cpBool cpSpaceShapeQuery_b(cpSpace *space, cpShape *shape, cpSpaceShapeQueryBlock block);
+
+#endif
+#endif
+
+
+//@}
+
 #ifdef __cplusplus
 }
 
@@ -159,5 +215,4 @@ static inline cpBool operator ==(const cpVect v1, const cpVect v2){return cpveql
 static inline cpVect operator -(const cpVect v){return cpvneg(v);}
 
 #endif
-
 #endif