Major chipmunk update.

bananas/hellochipmunk/chipmunkdebugger.monkey2

@@ -0,0 +1,100 @@
+
+#Import "<std>"
+#Import "<mojo>"
+#Import "<chipmunk>"
+
+Using std..
+Using mojo..
+Using chipmunk..
+
+Class ChipmunkDebugger
+
+	Method New()
+		_options.drawCircle=DrawCircle
+		_options.drawSegment=DrawSegment
+		_options.drawFatSegment=DrawFatSegment
+		_options.drawPolygon=DrawPolygon
+		_options.drawDot=DrawDot
+		_options.colorForShape=ColorForShape
+		_options.flags=CP_SPACE_DEBUG_DRAW_SHAPES '|CP_SPACE_DEBUG_DRAW_CONSTRAINTS|CP_SPACE_DEBUG_DRAW_COLLISION_POINTS
+	End
+	
+	Method DebugDraw( canvas:Canvas,space:cpSpace )
+	
+		_canvas=canvas
+	
+		cpSpaceDebugDraw( space,_options )
+	End
+	
+	Protected
+	
+	Method DrawCircle( pos:cpVect,angle:cpFloat,radius:cpFloat,outlineColor:cpSpaceDebugColor,fillColor:cpSpaceDebugColor,data:cpDataPointer )
+	
+		_canvas.Color=New Color( fillColor.r,fillColor.g,fillColor.b,fillColor.a )
+		
+		_canvas.DrawCircle( pos.x,pos.y,radius )
+	End
+	
+	Method DrawSegment( a:cpVect,b:cpVect,color:cpSpaceDebugColor,data:cpDataPointer )
+
+		_canvas.Color=New Color( color.r,color.g,color.b,color.a )
+
+		_canvas.LineWidth=1
+				
+		_canvas.DrawLine( a.x,a.y,b.x,b.y )
+	End
+	
+	Method DrawFatSegment( a:cpVect,b:cpVect,radius:cpFloat,outlineColor:cpSpaceDebugColor,fillColor:cpSpaceDebugColor,data:cpDataPointer )
+
+		_canvas.Color=New Color( fillColor.r,fillColor.g,fillColor.b,fillColor.a )
+
+		_canvas.LineWidth=radius
+		
+		_canvas.DrawLine( a.x,a.y,b.x,b.y )
+	End
+	
+	Method DrawPolygon( count:Int,verts:cpVect Ptr,radius:cpFloat,outlineColor:cpSpaceDebugColor,fillColor:cpSpaceDebugColor,data:cpDataPointer )
+	
+		Local vs:=New Float[count*2]
+		For Local i:=0 Until count
+			vs[i*2]=verts[i].x
+			vs[i*2+1]=verts[i].y
+		Next
+
+		_canvas.Color=New Color( fillColor.r,fillColor.g,fillColor.b,fillColor.a )
+		
+		_canvas.DrawPolys( count,1,vs )
+	End
+	
+	Method DrawDot( size:cpFloat,pos:cpVect,color:cpSpaceDebugColor,data:cpDataPointer )
+
+		_canvas.Color=New Color( color.r,color.g,color.b,color.a )
+
+		_canvas.PointSize=size
+		
+		_canvas.DrawPoint( pos.x,pos.y )
+	End
+	
+	Method ColorForShape:cpSpaceDebugColor( shape:cpShape,data:cpDataPointer )
+	
+		Local color:=_colors[shape]
+		If color.a Return color
+		
+		color.r=Rnd( 1 )
+		color.g=Rnd( 1-color.r )
+		color.b=Rnd( 1-color.r-color.g )
+		color.a=1
+		
+		_colors[shape]=color
+		Return color
+	End
+	
+	Private
+	
+	Field _options:=New cpSpaceDebugDrawOptions
+	
+	Field _colors:=New Map<cpShape,cpSpaceDebugColor>
+
+	Field _canvas:Canvas
+	
+End

bananas/hellochipmunk/hellochimpmunk.monkey2

@@ -3,31 +3,38 @@
 #Import "<mojo>"
 #Import "<chipmunk>"
 
+#Import "chipmunkdebugger"
+
 Using std..
 Using mojo..
 Using chipmunk..
 
 Class HelloChipmunk Extends Window
 
-	Field space:cpSpace Ptr
-	Field ground:cpShape Ptr
-	Field ballBody:cpBody ptr
-	Field ballShape:cpShape Ptr
+	Field space:cpSpace
+	Field ground:cpShape
+	Field ballBody:cpBody
+	Field ballShape:cpShape
+	
+	Field debugger:=New ChipmunkDebugger
 	
 	Method New()
 	
 		ClearColor=Color.Black
-	
-		'Create an empty space.
-		space=cpSpaceNew()
-		cpSpaceSetGravity( space,cpv( 0,100 ) )
 
+		'Create a new space and set its gravity to 100
+		'		
+		space=cpSpaceNew()
+		space.Gravity=cpv( 0,100 )
+		
 		'Add a static line segment shape for the ground.
 		'We'll make it slightly tilted so the ball will roll off.
 		'We attach it to space->staticBody to tell Chipmunk it shouldn't be movable.
-		ground=cpSegmentShapeNew( cpSpaceGetStaticBody( space ),cpv( -100,15 ), cpv( 100,-15 ),0 )
-		cpShapeSetFriction( ground,1 )
-		cpSpaceAddShape( space,ground )
+		'
+		ground=cpSegmentShapeNew( space.StaticBody,cpv( -100,15 ),cpv( 100,-15 ),0 )
+		ground.Friction=1
+		ground.CollisionType=1
+		space.AddShape( ground )
 		
 		'Now let's make a ball that falls onto the line and rolls off.
 		'First we need to make a cpBody to hold the physical properties of the object.
@@ -43,17 +50,32 @@ Class HelloChipmunk Extends Window
 		
 		'The cpSpaceAdd*() functions return the thing that you are adding.
 		'It's convenient to create and add an object in one line.
-		ballBody=cpSpaceAddBody( space,cpBodyNew( mass,moment ) )
-		cpBodySetPosition( ballBody,cpv( 0,-100 ) )
+		ballBody=space.AddBody( cpBodyNew( mass,moment ) )
+		ballBody.Position=cpv( 0,-100 )
 		
 		'Now we create the collision shape for the ball.
 		'You can create multiple collision shapes that point to the same body.
 		'They will all be attached to the body and move around to follow it.
-		ballShape=cpSpaceAddShape( space,cpCircleShapeNew( ballBody,radius,cpvzero ) )
-		cpShapeSetFriction( ballShape,0.7 )
-	
+		ballShape=space.AddShape( cpCircleShapeNew( ballBody,radius,cpvzero ) )
+		ballShape.Friction=0.7
+		ballShape.CollisionType=2
+		
+		Local handler:=space.AddDefaultCollisionHandler()
+		
+		handler.beginFunc=CollBegin
 	End
+
+	Method CollBegin:cpBool( arbiter:cpArbiter,space:cpSpace,data:cpDataPointer )
 	
+		Local a:cpShape,b:cpShape
+		
+		arbiter.GetShapes( Varptr a,Varptr b )
+		
+		Print "Collision! a="+a.CollisionType+", b="+b.CollisionType
+		
+		Return true
+	End
+
 	Method OnRender( canvas:Canvas ) Override
 	
 		App.RequestRender()
@@ -61,12 +83,12 @@ Class HelloChipmunk Extends Window
 		'It is *highly* recommended to use a fixed size time step.
 		Local timeStep:=1.0/60.0
 		
-		cpSpaceStep( space,timeStep )
-		
-		Local rot:=cpBodyGetRotation( ballBody )
-		Local pos:=cpBodyGetPosition( ballBody )
-		Local vel:=cpBodyGetVelocity( ballBody )
+		space.StepTime( timeStep )
 		
+		Local rot:=ballBody.Rotation
+		Local pos:=ballBody.Position
+		Local vel:=ballBody.Velocity
+
 		Print "ball rot="+ATan2( rot.y,rot.x )+", pos.x="+pos.x+", pos.y="+pos.y+", vel.x="+vel.x+", vel.y="+vel.y
 		
 		canvas.Translate( Width/2,Height/2 )
@@ -78,6 +100,8 @@ Class HelloChipmunk Extends Window
 		
 		canvas.Color=Color.Blue
 		canvas.DrawLine( -100,15,100,-15 )
+
+		debugger.DebugDraw( canvas,space )
 	End
 	
 	Method Cleanup()	'Yeah, right!

modules/chipmunk/arbiter.monkey2

@@ -0,0 +1,82 @@
+
+Namespace chipmunk
+
+#Import "chipmunk_glue.h"
+
+Extern
+
+Class cpArbiter Extends Void
+
+	Property Restitution:cpFloat() Extension="cpArbiterGetRestitution"
+	Setter( restitution:cpFloat ) Extension="cpArbiterSetRestitution"
+
+	Property Friction:cpFloat() Extension="cpArbiterGetFriction"
+	Setter( friction:cpFloat ) Extension="cpArbiterSetFriction"
+
+	Property SurfaceVelocity:cpVect() Extension="cpArbiterGetSurfaceVelocity"
+	Setter( vr:cpVect ) Extension="cpArbiterSetSurfaceVelocity"
+	
+	Property UserData:cpDataPointer() Extension="cpArbiterGetUserData"
+	Setter( userData:cpDataPointer ) Extension="cpArbiterSetUserData"
+
+	Property TotalImpulse:cpVect() Extension="cpArbiterTotalImpulse"
+
+	Property TotalKE:cpFloat() Extension="cpArbiterTotalKE"
+
+	Property Ignore:cpBool() Extension="cpArbiterIgnore"
+
+	Property IsFirstContact:cpBool() Extension="cpArbiterIsFirstContact"
+	
+	Property IsRemoval:cpBool() Extension="cpArbiterIsRemoval"
+	
+	Property Normal:cpVect( arb:cpArbiter ) Extension="cpArbiterGetNormal"
+	
+	Method GetShapes:Void( a:cpShape Ptr, b:cpShape Ptr ) Extension="cpArbiterGetShapes"
+	
+	Method GetBodies:Void( a:cpBody Ptr, b:cpBody Ptr ) Extension="cpArbiterGetBodies"
+	
+	Method GetCount:Int() Extension="cpArbiterGetCount"
+	
+	Method GetPointA:cpVect( i:Int ) Extension="cpArbiterGetPointA"
+
+	Method GetPointB:cpVect( i:Int ) Extension="cpArbiterGetPointB"
+
+	Method GetDepth:cpFloat( i:Int ) Extension="cpArbiterGetDepth"
+	
+End
+
+Struct cpContactPointSet
+	Field count:Int
+	Field normal:cpVect
+End
+
+Function cpArbiterGetRestitution:cpFloat( arb:cpArbiter )
+Function cpArbiterSetRestitution:Void( arb:cpArbiter, restitution:cpFloat )
+Function cpArbiterGetFriction:cpFloat( arb:cpArbiter )
+Function cpArbiterSetFriction:Void( arb:cpArbiter, friction:cpFloat )
+Function cpArbiterGetSurfaceVelocity:cpVect( arb:cpArbiter )
+Function cpArbiterSetSurfaceVelocity:Void( arb:cpArbiter, vr:cpVect )
+Function cpArbiterGetUserData:cpDataPointer( arb:cpArbiter )
+Function cpArbiterSetUserData:Void( arb:cpArbiter, userData:cpDataPointer )
+Function cpArbiterTotalImpulse:cpVect( arb:cpArbiter )
+Function cpArbiterTotalKE:cpFloat( arb:cpArbiter )
+Function cpArbiterIgnore:cpBool( arb:cpArbiter )
+Function cpArbiterGetShapes:Void( arb:cpArbiter, a:cpShape Ptr Ptr, b:cpShape Ptr Ptr )
+Function cpArbiterGetBodies:Void( arb:cpArbiter, a:cpBody Ptr Ptr, b:cpBody Ptr Ptr )
+Function cpArbiterGetContactPointSet:cpContactPointSet( arb:cpArbiter )
+Function cpArbiterSetContactPointSet:Void( arb:cpArbiter, set:cpContactPointSet Ptr )
+Function cpArbiterIsFirstContact:cpBool( arb:cpArbiter )
+Function cpArbiterIsRemoval:cpBool( arb:cpArbiter )
+Function cpArbiterGetCount:Int( arb:cpArbiter )
+Function cpArbiterGetNormal:cpVect( arb:cpArbiter )
+Function cpArbiterGetPointA:cpVect( arb:cpArbiter, i:Int )
+Function cpArbiterGetPointB:cpVect( arb:cpArbiter, i:Int )
+Function cpArbiterGetDepth:cpFloat( arb:cpArbiter, i:Int )
+Function cpArbiterCallWildcardBeginA:cpBool( arb:cpArbiter, space:cpSpace Ptr )
+Function cpArbiterCallWildcardBeginB:cpBool( arb:cpArbiter, space:cpSpace Ptr )
+Function cpArbiterCallWildcardPreSolveA:cpBool( arb:cpArbiter, space:cpSpace Ptr )
+Function cpArbiterCallWildcardPreSolveB:cpBool( arb:cpArbiter, space:cpSpace Ptr )
+Function cpArbiterCallWildcardPostSolveA:Void( arb:cpArbiter, space:cpSpace Ptr )
+Function cpArbiterCallWildcardPostSolveB:Void( arb:cpArbiter, space:cpSpace Ptr )
+Function cpArbiterCallWildcardSeparateA:Void( arb:cpArbiter, space:cpSpace Ptr )
+Function cpArbiterCallWildcardSeparateB:Void( arb:cpArbiter, space:cpSpace Ptr )

modules/chipmunk/body.monkey2

@@ -0,0 +1,145 @@
+
+Namespace chipmunk
+
+#Import "chipmunk_glue.h"
+
+Extern
+
+Enum cpBodyType
+End
+Const CP_BODY_TYPE_DYNAMIC:cpBodyType
+Const CP_BODY_TYPE_KINEMATIC:cpBodyType
+Const CP_BODY_TYPE_STATIC:cpBodyType
+
+Alias cpBodyVelocityFunc:Void( cpBody, cpVect, cpFloat, cpFloat )
+Alias cpBodyPositionFunc:Void( cpBody, cpFloat )
+
+Alias cpBodyShapeIteratorFunc:Void( cpBody, cpShape, Void Ptr )
+Alias cpBodyConstraintIteratorFunc:Void( cpBody, cpConstraint Ptr, Void Ptr )
+Alias cpBodyArbiterIteratorFunc:Void( cpBody, cpArbiter Ptr, Void Ptr )
+
+Function cpBodyAlloc:cpBody(  )
+Function cpBodyInit:cpBody( body:cpBody, mass:cpFloat, moment:cpFloat )
+Function cpBodyNew:cpBody( mass:cpFloat, moment:cpFloat )
+Function cpBodyNewKinematic:cpBody(  )
+Function cpBodyNewStatic:cpBody(  )
+Function cpBodyDestroy:Void( body:cpBody )
+Function cpBodyFree:Void( body:cpBody )
+Function cpBodyActivate:Void( body:cpBody )
+Function cpBodyActivateStatic:Void( body:cpBody, filter:cpShape )
+Function cpBodySleep:Void( body:cpBody )
+Function cpBodySleepWithGroup:Void( body:cpBody, group:cpBody )
+Function cpBodyIsSleeping:cpBool( body:cpBody )
+Function cpBodyGetType:cpBodyType( body:cpBody )
+Function cpBodySetType:Void( body:cpBody, type:cpBodyType )
+Function cpBodyGetSpace:cpSpace( body:cpBody )
+Function cpBodyGetMass:cpFloat( body:cpBody )
+Function cpBodySetMass:Void( body:cpBody, m:cpFloat )
+Function cpBodyGetMoment:cpFloat( body:cpBody )
+Function cpBodySetMoment:Void( body:cpBody, i:cpFloat )
+Function cpBodyGetPosition:cpVect( body:cpBody )
+Function cpBodySetPosition:Void( body:cpBody, pos:cpVect )
+Function cpBodyGetCenterOfGravity:cpVect( body:cpBody )
+Function cpBodySetCenterOfGravity:Void( body:cpBody, cog:cpVect )
+Function cpBodyGetVelocity:cpVect( body:cpBody )
+Function cpBodySetVelocity:Void( body:cpBody, velocity:cpVect )
+Function cpBodyGetForce:cpVect( body:cpBody )
+Function cpBodySetForce:Void( body:cpBody, force:cpVect )
+Function cpBodyGetAngle:cpFloat( body:cpBody )
+Function cpBodySetAngle:Void( body:cpBody, a:cpFloat )
+Function cpBodyGetAngularVelocity:cpFloat( body:cpBody )
+Function cpBodySetAngularVelocity:Void( body:cpBody, angularVelocity:cpFloat )
+Function cpBodyGetTorque:cpFloat( body:cpBody )
+Function cpBodySetTorque:Void( body:cpBody, torque:cpFloat )
+Function cpBodyGetRotation:cpVect( body:cpBody )
+Function cpBodyGetUserData:cpDataPointer( body:cpBody )
+Function cpBodySetUserData:Void( body:cpBody, userData:cpDataPointer )
+Function cpBodySetVelocityUpdateFunc:Void( body:cpBody, velocityFunc:cpBodyVelocityFunc )
+Function cpBodySetPositionUpdateFunc:Void( body:cpBody, positionFunc:cpBodyPositionFunc )
+Function cpBodyUpdateVelocity:Void( body:cpBody, gravity:cpVect, damping:cpFloat, dt:cpFloat )
+Function cpBodyUpdatePosition:Void( body:cpBody, dt:cpFloat )
+Function cpBodyLocalToWorld:cpVect( body:cpBody, point:cpVect )
+Function cpBodyWorldToLocal:cpVect( body:cpBody, point:cpVect )
+Function cpBodyApplyForceAtWorldPoint:Void( body:cpBody, force:cpVect, point:cpVect )
+Function cpBodyApplyForceAtLocalPoint:Void( body:cpBody, force:cpVect, point:cpVect )
+Function cpBodyApplyImpulseAtWorldPoint:Void( body:cpBody, impulse:cpVect, point:cpVect )
+Function cpBodyApplyImpulseAtLocalPoint:Void( body:cpBody, impulse:cpVect, point:cpVect )
+Function cpBodyGetVelocityAtWorldPoint:cpVect( body:cpBody, point:cpVect )
+Function cpBodyGetVelocityAtLocalPoint:cpVect( body:cpBody, point:cpVect )
+Function cpBodyKineticEnergy:cpFloat( body:cpBody )
+Function cpBodyEachShape:Void( body:cpBody, func:cpBodyShapeIteratorFunc, data:Void Ptr )
+Function cpBodyEachConstraint:Void( body:cpBody, func:cpBodyConstraintIteratorFunc, data:Void Ptr )
+Function cpBodyEachArbiter:Void( body:cpBody, func:cpBodyArbiterIteratorFunc, data:Void Ptr )
+
+Class cpBody Extends Void
+
+	Property Type:cpBodyType() Extension="cpBodyGetType"
+	Setter( type:cpBodyType ) Extension="cpBodySetType"
+	
+	Property Mass:cpFloat() Extension="cpBodyGetMass"
+	Setter( m:cpFloat ) Extension="cpBodySetMass"
+	
+	Property Moment:cpFloat() Extension="cpBodyGetMoment"
+	Setter( i:cpFloat ) Extension="cpBodySetMoment"
+	
+	Property Position:cpVect() Extension="cpBodyGetPosition"
+	Setter( pos:cpVect ) Extension="cpBodySetPosition"
+	
+	Property CenterOfGravity:cpVect() Extension="cpBodyGetCenterOfGravity"
+	Setter( cog:cpVect ) Extension="cpBodySetCenterOfGravity"
+	
+	Property Velocity:cpVect() Extension="cpBodyGetVelocity"
+	Setter( velocity:cpVect ) Extension="cpBodySetVelocity"
+	
+	Property Force:cpVect() Extension="cpBodyGetForce"
+	Setter( force:cpVect ) Extension="cpBodySetForce"
+	
+	Property Angle:cpFloat() Extension="cpBodyGetAngle"
+	Setter( a:cpFloat ) Extension="cpBodySetAngle"
+	
+	Property AngularVelocity:cpFloat() Extension="cpBodyGetAngularVelocity"
+	Setter( angularVelocity:cpFloat ) Extension="cpBodySetAngularVelocity"
+	
+	Property Torque:cpFloat() Extension="cpBodyGetTorque"
+	Setter( torque:cpFloat ) Extension="cpBodySetTorque"
+	
+	Property UserData:cpDataPointer() Extension="cpBodyGetUserData"
+	Setter( userData:cpDataPointer ) Extension="cpBodySetUserData"
+		
+	Property KineticEnergy:cpFloat() Extension="cpBodyKineticEnergy"
+	
+	Property Rotation:cpVect() Extension="cpBodyGetRotation"
+	
+	Property Space:cpSpace() Extension="cpBodyGetSpace"
+	
+	Property IsSleeping:cpBool() Extension="cpBodyIsSleeping"
+	
+	Method Activate:Void() Extension="cpBodyActivate"
+	
+	Method ActivateStatic:Void( filter:cpShape ) Extension="cpBodyActivateStatic"
+	
+	Method Sleep:Void() Extension="cpBodySleep"
+	
+	Method SleepWithGroup:Void( group:cpBody ) Extension="SleepWithGroup"
+	
+	Method UpdateVelocity:Void( gravity:cpVect, damping:cpFloat, dt:cpFloat ) Extension="cpBodyUpdateVelocity"
+	
+	Method UpdatePosition:Void( dt:cpFloat ) Extension="cpBodyUpdatePosition"
+	
+	Method LocalToWorld:cpVect( point:cpVect ) Extension="cpBodyLocalToWorld"
+	
+	Method WorldToLocal:cpVect( point:cpVect ) Extension="cpBodyWorldToLocal"
+	
+	Method ApplyForceAtWorldPoint:Void( force:cpVect, point:cpVect ) Extension="cpBodyApplyForceAtWorldPoint"
+		
+	Method ApplyForceAtLocalPoint:Void( force:cpVect, point:cpVect ) Extension="cpBodyApplyForceAtLocalPoint"
+	
+	Method ApplyImpulseAtWorldPoint:Void( impulse:cpVect, point:cpVect ) Extension="cpBodyApplyImpulseAtWorldPoint"
+	
+	Method ApplyImpulseAtLocalPoint:Void( impulse:cpVect, point:cpVect ) Extension="cpBodyApplyImpulseAtLocalPoint"
+	
+	Method GetVelocityAtWorldPoint:cpVect( point:cpVect ) Extension="cpBodyGetVelocityAtWorldPoint"
+	
+	Method GetVelocityAtLocalPoint:cpVect( point:cpVect ) Extension="cpBodyGetVelocityAtLocalPoint"
+
+End

modules/chipmunk/chipmunk.monkey2

@@ -1,7 +1,16 @@
 
 Namespace chipmunk
 
-#Import "chipmunk_extern"
+#Import "<libc>"
+
+#Import "Chipmunk7/include/*.h"
+
+#Import "space"
+#Import "shape"
+#Import "body"
+#Import "arbiter"
+#Import "constraint"
+#Import "types"
 
 #Import "Chipmunk7/src/chipmunk.c"
 #Import "Chipmunk7/src/cpArbiter.c"
@@ -36,3 +45,4 @@ Namespace chipmunk
 #Import "Chipmunk7/src/cpSpatialIndex.c"
 #Import "Chipmunk7/src/cpSweep1D.c"
 
+#Import "chipmunk_glue.cpp"

modules/chipmunk/chipmunk_extern.h

@@ -1,26 +0,0 @@
-
-#ifndef BB_CHIPMUNK_EXTERN_H
-#define BB_CHIPMUNK_EXTERN_H
-
-#include <chipmunk/chipmunk.h>
-
-struct bb_cpSpaceDebugDrawOptions{
-	cpSpaceDebugDrawCircleImpl  drawCircle;
-	cpSpaceDebugDrawSegmentImpl drawSegment;
-	cpSpaceDebugDrawFatSegmentImpl drawFatSegment;
-	cpSpaceDebugDrawPolygonImpl drawPolygon;
-	cpSpaceDebugDrawDotImpl drawDot;
-	cpSpaceDebugDrawFlags flags;
-	cpSpaceDebugColor shapeOutlineColor;
-	cpSpaceDebugDrawColorForShapeImpl colorForShape;
-	cpSpaceDebugColor constraintColor;
-	cpSpaceDebugColor collisionPointColor;
-	cpDataPointer data;
-};
-
-inline void bb_cpSpaceDebugDraw( cpSpace *space,bb_cpSpaceDebugDrawOptions *options ){
-	cpSpaceDebugDrawOptions opts=*(cpSpaceDebugDrawOptions*)options;
-	cpSpaceDebugDraw( space,&opts );
-};
-
-#endif

modules/chipmunk/chipmunk_extern.monkey2

@@ -11,6 +11,7 @@ Namespace chipmunk
 
 Extern
 
+
 '***** File: Chipmunk7/include/chipmunk/chipmunk.h *****
 
 Function cpMessage:Void( condition:CString, file:CString, line:Int, isError:Int, isHardError:Int, message:CString )
@@ -29,7 +30,7 @@ Alias cpHashValue:libc.uintptr_t
 Alias cpCollisionID:libc.uint32_t
 Alias cpBool:UByte
 Alias cpDataPointer:Void Ptr
-Alias cpCollisionType:libc.uintptr_t
+Alias cpCollisionType:Int'libc.uintptr_t
 Alias cpGroup:libc.uintptr_t
 Alias cpBitmask:UInt
 Alias cpTimestamp:UInt
@@ -618,18 +619,18 @@ Struct cpSpaceDebugColor
 	Field b:Float
 	Field a:Float
 End
-Alias cpSpaceDebugDrawCircleImpl:Void( cpVect, cpFloat, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, cpDataPointer )
-Alias cpSpaceDebugDrawSegmentImpl:Void( cpVect, cpVect, cpSpaceDebugColor, cpDataPointer )
-Alias cpSpaceDebugDrawFatSegmentImpl:Void( cpVect, cpVect, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, cpDataPointer )
-Alias cpSpaceDebugDrawPolygonImpl:Void( Int, cpVect Ptr, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, cpDataPointer )
-Alias cpSpaceDebugDrawDotImpl:Void( cpFloat, cpVect, cpSpaceDebugColor, cpDataPointer )
-Alias cpSpaceDebugDrawColorForShapeImpl:cpSpaceDebugColor( cpShape Ptr, cpDataPointer )
+Alias cpSpaceDebugDrawCircleImpl:Void( cpVect, cpFloat, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, Object )
+Alias cpSpaceDebugDrawSegmentImpl:Void( cpVect, cpVect, cpSpaceDebugColor, Object )
+Alias cpSpaceDebugDrawFatSegmentImpl:Void( cpVect, cpVect, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, Object )
+Alias cpSpaceDebugDrawPolygonImpl:Void( Int, cpVect Ptr, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, Object )
+Alias cpSpaceDebugDrawDotImpl:Void( cpFloat, cpVect, cpSpaceDebugColor, Object )
+Alias cpSpaceDebugDrawColorForShapeImpl:cpSpaceDebugColor( cpShape Ptr, Object )
 Enum cpSpaceDebugDrawFlags
 End
 Const CP_SPACE_DEBUG_DRAW_SHAPES:cpSpaceDebugDrawFlags
 Const CP_SPACE_DEBUG_DRAW_CONSTRAINTS:cpSpaceDebugDrawFlags
 Const CP_SPACE_DEBUG_DRAW_COLLISION_POINTS:cpSpaceDebugDrawFlags
-Struct cpSpaceDebugDrawOptions="bb_cpSpaceDebugDrawOptions"
+Class cpSpaceDebugDrawOptions="bb_cpSpaceDebugDrawOptions"
 	Field drawCircle:cpSpaceDebugDrawCircleImpl
 	Field drawSegment:cpSpaceDebugDrawSegmentImpl
 	Field drawFatSegment:cpSpaceDebugDrawFatSegmentImpl
@@ -642,7 +643,7 @@ Struct cpSpaceDebugDrawOptions="bb_cpSpaceDebugDrawOptions"
 	Field collisionPointColor:cpSpaceDebugColor
 	Field data:cpDataPointer
 End
-Function cpSpaceDebugDraw:Void( space:cpSpace Ptr, options:cpSpaceDebugDrawOptions Ptr )="bb_cpSpaceDebugDraw"
+Function cpSpaceDebugDraw:Void( space:cpSpace Ptr, options:cpSpaceDebugDrawOptions )="bb_cpSpaceDebugDraw"
 
 '***** File: Chipmunk7/include/chipmunk/chipmunk.h *****
 

modules/chipmunk/chipmunk_glue.cpp

@@ -0,0 +1,151 @@
+
+#include "chipmunk_glue.h"
+
+// ***** cpCollisionHandler *****
+
+namespace{
+
+	cpBool collisionTrueFunc( cpArbiter *arbiter,cpSpace *space,cpDataPointer data ){
+		return true;
+	}
+
+	void collisionVoidFunc( cpArbiter *arbiter,cpSpace *space,cpDataPointer data ){
+	}
+
+	cpBool collisionBeginFunc( cpArbiter *arbiter,cpSpace *space,cpDataPointer data ){
+		bb_cpCollisionHandler *handler=(bb_cpCollisionHandler*)data;
+		
+		return handler->beginFunc( arbiter,space,handler->userData );
+	}
+
+	cpBool collisionPreSolveFunc( cpArbiter *arbiter,cpSpace *space,cpDataPointer data ){
+		bb_cpCollisionHandler *handler=(bb_cpCollisionHandler*)data;
+		
+		return handler->preSolveFunc( arbiter,space,handler->userData );
+	}
+
+	void collisionPostSolveFunc( cpArbiter *arbiter,cpSpace *space,cpDataPointer data ){
+		bb_cpCollisionHandler *handler=(bb_cpCollisionHandler*)data;
+		
+		handler->postSolveFunc( arbiter,space,handler->userData );
+	}
+
+	void collisionSeparateFunc( cpArbiter *arbiter,cpSpace *space,cpDataPointer data ){
+		bb_cpCollisionHandler *handler=(bb_cpCollisionHandler*)data;
+		
+		handler->separateFunc( arbiter,space,handler->userData );
+	}
+	
+	bb_cpCollisionHandler *bbHandler( cpCollisionHandler *handler ){
+	
+		bb_cpCollisionHandler *bbhandler=(bb_cpCollisionHandler*)handler->userData;
+		if( bbhandler ) return bbhandler;
+		
+		bbhandler=new bb_cpCollisionHandler;	//FIXME: GC leak!
+		bbhandler->typeA=handler->typeA;		//assume these are const-ish?
+		bbhandler->typeB=handler->typeB;
+		bbhandler->beginFunc=bbMakefunc( collisionTrueFunc );
+		bbhandler->preSolveFunc=bbMakefunc( collisionTrueFunc );
+		bbhandler->postSolveFunc=bbMakefunc( collisionVoidFunc );
+		bbhandler->separateFunc=bbMakefunc( collisionVoidFunc );
+			
+		handler->beginFunc=collisionBeginFunc;
+		handler->preSolveFunc=collisionPreSolveFunc;
+		handler->postSolveFunc=collisionPostSolveFunc;
+		handler->separateFunc=collisionSeparateFunc;
+		handler->userData=bbhandler;
+
+		return bbhandler;
+	}
+}
+
+void bb_cpCollisionHandler::gcMark(){
+	bbGCMark( beginFunc );
+	bbGCMark( preSolveFunc );
+	bbGCMark( postSolveFunc );
+	bbGCMark( separateFunc );
+}
+
+bb_cpCollisionHandler *bb_cpSpaceAddDefaultCollisionHandler( cpSpace *space ){
+	cpCollisionHandler *handler=cpSpaceAddDefaultCollisionHandler( space );
+	return bbHandler( handler );
+}
+
+bb_cpCollisionHandler *bb_cpSpaceAddCollisionHandler( cpSpace *space,cpCollisionType a,cpCollisionType b ){
+	cpCollisionHandler *handler=cpSpaceAddCollisionHandler( space,a,b );
+	return bbHandler( handler );	
+}
+
+bb_cpCollisionHandler *bb_cpSpaceAddWildcardHandler( cpSpace *space,cpCollisionType t ){
+	cpCollisionHandler *handler=cpSpaceAddWildcardHandler( space,t );
+	return bbHandler( handler );	
+}
+
+// ***** cpSpaceDebugDraw *****
+
+namespace{
+
+	void debugDrawCircle(cpVect pos, cpFloat angle, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer data ){
+		bb_cpSpaceDebugDrawOptions *opts=(bb_cpSpaceDebugDrawOptions*)data;
+		
+		opts->drawCircle( pos,angle,radius,outlineColor,fillColor,opts->userData );
+	}
+	
+	void debugDrawSegment(cpVect a, cpVect b, cpSpaceDebugColor color, cpDataPointer data){
+		bb_cpSpaceDebugDrawOptions *opts=(bb_cpSpaceDebugDrawOptions*)data;
+		
+		opts->drawSegment( a,b,color,opts->userData );
+	}
+	
+	void debugDrawFatSegment(cpVect a, cpVect b, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer data){
+		bb_cpSpaceDebugDrawOptions *opts=(bb_cpSpaceDebugDrawOptions*)data;
+		
+		opts->drawFatSegment( a,b,radius,outlineColor,fillColor,opts->userData );
+	}
+	
+	void debugDrawPolygon(int count, const cpVect *verts, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer data){
+		bb_cpSpaceDebugDrawOptions *opts=(bb_cpSpaceDebugDrawOptions*)data;
+		
+		opts->drawPolygon( count,(cpVect*)verts,radius,outlineColor,fillColor,opts->userData );
+	}
+	
+	void debugDrawDot(cpFloat size, cpVect pos, cpSpaceDebugColor color, cpDataPointer data){
+		bb_cpSpaceDebugDrawOptions *opts=(bb_cpSpaceDebugDrawOptions*)data;
+		
+		opts->drawDot( size,pos,color,opts->userData );
+	}
+	
+	cpSpaceDebugColor debugDrawColorForShape(cpShape *shape, cpDataPointer data){
+		bb_cpSpaceDebugDrawOptions *opts=(bb_cpSpaceDebugDrawOptions*)data;
+		
+		return opts->colorForShape( shape,opts->userData );
+	}
+}
+
+void bb_cpSpaceDebugDrawOptions::gcMark(){
+
+	bbGCMark( drawCircle );
+	bbGCMark( drawSegment );
+	bbGCMark( drawFatSegment );
+	bbGCMark( drawPolygon );
+	bbGCMark( colorForShape );
+}
+
+void bb_cpSpaceDebugDraw( cpSpace *space,bb_cpSpaceDebugDrawOptions *options ){
+
+	cpSpaceDebugDrawOptions opts;
+	
+	opts.drawCircle=debugDrawCircle;
+	opts.drawSegment=debugDrawSegment;
+	opts.drawFatSegment=debugDrawFatSegment;
+	opts.drawPolygon=debugDrawPolygon;
+	opts.drawDot=debugDrawDot;
+	opts.flags=options->flags;
+	opts.shapeOutlineColor=options->shapeOutlineColor;
+	opts.colorForShape=debugDrawColorForShape;
+	opts.constraintColor=options->constraintColor;
+	opts.collisionPointColor=options->collisionPointColor;
+	opts.data=options;
+	
+	cpSpaceDebugDraw( space,&opts );
+}

modules/chipmunk/chipmunk_glue.h

@@ -0,0 +1,61 @@
+
+#ifndef BB_CHIPMUNK_GLUE_H
+#define BB_CHIPMUNK_GLUE_H
+
+#include <chipmunk/chipmunk.h>
+
+#include <bbmonkey.h>
+
+// ***** cpCollisionHandler *****
+
+typedef bbFunction<cpBool(cpArbiter*,cpSpace*,cpDataPointer)> bb_cpCollisionBeginFunc;
+typedef bbFunction<cpBool(cpArbiter*,cpSpace*,cpDataPointer)> bb_cpCollisionPreSolveFunc;
+typedef bbFunction<void(cpArbiter*,cpSpace*,cpDataPointer)> bb_cpCollisionPostSolveFunc;
+typedef bbFunction<void(cpArbiter*,cpSpace*,cpDataPointer)> bb_cpCollisionSeparateFunc;
+
+struct bb_cpCollisionHandler : public bbObject{
+
+	cpCollisionType typeA;
+	cpCollisionType typeB;
+	bb_cpCollisionBeginFunc beginFunc;
+	bb_cpCollisionPreSolveFunc preSolveFunc;
+	bb_cpCollisionPostSolveFunc postSolveFunc;
+	bb_cpCollisionSeparateFunc separateFunc;
+	cpDataPointer userData;
+	
+	void gcMark();
+};
+
+bb_cpCollisionHandler *bb_cpSpaceAddDefaultCollisionHandler( cpSpace* );
+bb_cpCollisionHandler *bb_cpSpaceAddCollisionHandler( cpSpace*,cpCollisionType,cpCollisionType );
+bb_cpCollisionHandler *bb_cpSpaceAddWildcardHandler( cpSpace*,cpCollisionType );
+
+// ***** cpSpaceDebugDraw *****
+
+typedef bbFunction<void(cpVect,cpFloat,cpFloat,cpSpaceDebugColor,cpSpaceDebugColor,cpDataPointer)> bb_cpSpaceDebugDrawCircleImpl;
+typedef bbFunction<void(cpVect,cpVect,cpSpaceDebugColor,cpDataPointer)> bb_cpSpaceDebugDrawSegmentImpl;
+typedef bbFunction<void(cpVect,cpVect,cpFloat,cpSpaceDebugColor,cpSpaceDebugColor,cpDataPointer)> bb_cpSpaceDebugDrawFatSegmentImpl;
+typedef bbFunction<void(int,cpVect*,cpFloat,cpSpaceDebugColor,cpSpaceDebugColor,cpDataPointer)> bb_cpSpaceDebugDrawPolygonImpl;
+typedef bbFunction<void(cpFloat,cpVect,cpSpaceDebugColor,cpDataPointer)> bb_cpSpaceDebugDrawDotImpl;
+typedef bbFunction<cpSpaceDebugColor(cpShape*,cpDataPointer)> bb_cpSpaceDebugDrawColorForShapeImpl;
+
+struct bb_cpSpaceDebugDrawOptions : public bbObject{
+
+	bb_cpSpaceDebugDrawCircleImpl drawCircle;
+	bb_cpSpaceDebugDrawSegmentImpl drawSegment;
+	bb_cpSpaceDebugDrawFatSegmentImpl drawFatSegment;
+	bb_cpSpaceDebugDrawPolygonImpl drawPolygon;
+	bb_cpSpaceDebugDrawDotImpl drawDot;
+	cpSpaceDebugDrawFlags flags;
+	cpSpaceDebugColor shapeOutlineColor;
+	bb_cpSpaceDebugDrawColorForShapeImpl colorForShape;
+	cpSpaceDebugColor constraintColor;
+	cpSpaceDebugColor collisionPointColor;
+	cpDataPointer userData;
+	
+	void gcMark();
+};
+
+void bb_cpSpaceDebugDraw( cpSpace *space,bb_cpSpaceDebugDrawOptions *options );
+
+#endif

modules/chipmunk/constraint.monkey2

@@ -0,0 +1,336 @@
+
+Namespace chipmunk
+
+#Import "chipmunk_glue.h"
+
+Extern
+
+'***** File: Chipmunk7/include/chipmunk/cpConstraint.h *****
+
+Alias cpConstraintPreSolveFunc:Void( cpConstraint, cpSpace )
+Alias cpConstraintPostSolveFunc:Void( cpConstraint, cpSpace )
+
+Function cpConstraintDestroy:Void( constraint:cpConstraint )
+Function cpConstraintFree:Void( constraint:cpConstraint )
+Function cpConstraintGetSpace:cpSpace( constraint:cpConstraint )
+Function cpConstraintGetBodyA:cpBody( constraint:cpConstraint )
+Function cpConstraintGetBodyB:cpBody( constraint:cpConstraint )
+Function cpConstraintGetMaxForce:cpFloat( constraint:cpConstraint )
+Function cpConstraintSetMaxForce:Void( constraint:cpConstraint, maxForce:cpFloat )
+Function cpConstraintGetErrorBias:cpFloat( constraint:cpConstraint )
+Function cpConstraintSetErrorBias:Void( constraint:cpConstraint, errorBias:cpFloat )
+Function cpConstraintGetMaxBias:cpFloat( constraint:cpConstraint )
+Function cpConstraintSetMaxBias:Void( constraint:cpConstraint, maxBias:cpFloat )
+Function cpConstraintGetCollideBodies:cpBool( constraint:cpConstraint )
+Function cpConstraintSetCollideBodies:Void( constraint:cpConstraint, collideBodies:cpBool )
+Function cpConstraintGetPreSolveFunc:cpConstraintPreSolveFunc( constraint:cpConstraint )
+Function cpConstraintSetPreSolveFunc:Void( constraint:cpConstraint, preSolveFunc:cpConstraintPreSolveFunc )
+Function cpConstraintGetPostSolveFunc:cpConstraintPostSolveFunc( constraint:cpConstraint )
+Function cpConstraintSetPostSolveFunc:Void( constraint:cpConstraint, postSolveFunc:cpConstraintPostSolveFunc )
+Function cpConstraintGetUserData:cpDataPointer( constraint:cpConstraint )
+Function cpConstraintSetUserData:Void( constraint:cpConstraint, userData:cpDataPointer )
+Function cpConstraintGetImpulse:cpFloat( constraint:cpConstraint )
+
+'***** File: Chipmunk7/include/chipmunk/cpPinJoint.h *****
+
+Function cpConstraintIsPinJoint:cpBool( constraint:cpConstraint )
+Function cpPinJointAlloc:cpPinJoint(  )
+Function cpPinJointInit:cpPinJoint( joint:cpPinJoint, a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect )
+Function cpPinJointNew:cpConstraint( a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect )
+Function cpPinJointGetAnchorA:cpVect( constraint:cpConstraint )
+Function cpPinJointSetAnchorA:Void( constraint:cpConstraint, anchorA:cpVect )
+Function cpPinJointGetAnchorB:cpVect( constraint:cpConstraint )
+Function cpPinJointSetAnchorB:Void( constraint:cpConstraint, anchorB:cpVect )
+Function cpPinJointGetDist:cpFloat( constraint:cpConstraint )
+Function cpPinJointSetDist:Void( constraint:cpConstraint, dist:cpFloat )
+
+'***** File: Chipmunk7/include/chipmunk/cpSlideJoint.h *****
+
+Function cpConstraintIsSlideJoint:cpBool( constraint:cpConstraint )
+Function cpSlideJointAlloc:cpSlideJoint(  )
+Function cpSlideJointInit:cpSlideJoint( joint:cpSlideJoint, a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect, min:cpFloat, max:cpFloat )
+Function cpSlideJointNew:cpConstraint( a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect, min:cpFloat, max:cpFloat )
+Function cpSlideJointGetAnchorA:cpVect( constraint:cpConstraint )
+Function cpSlideJointSetAnchorA:Void( constraint:cpConstraint, anchorA:cpVect )
+Function cpSlideJointGetAnchorB:cpVect( constraint:cpConstraint )
+Function cpSlideJointSetAnchorB:Void( constraint:cpConstraint, anchorB:cpVect )
+Function cpSlideJointGetMin:cpFloat( constraint:cpConstraint )
+Function cpSlideJointSetMin:Void( constraint:cpConstraint, min:cpFloat )
+Function cpSlideJointGetMax:cpFloat( constraint:cpConstraint )
+Function cpSlideJointSetMax:Void( constraint:cpConstraint, max:cpFloat )
+
+'***** File: Chipmunk7/include/chipmunk/cpPivotJoint.h *****
+
+Function cpConstraintIsPivotJoint:cpBool( constraint:cpConstraint )
+Function cpPivotJointAlloc:cpPivotJoint(  )
+Function cpPivotJointInit:cpPivotJoint( joint:cpPivotJoint, a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect )
+Function cpPivotJointNew:cpConstraint( a:cpBody, b:cpBody, pivot:cpVect )
+Function cpPivotJointNew2:cpConstraint( a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect )
+Function cpPivotJointGetAnchorA:cpVect( constraint:cpConstraint )
+Function cpPivotJointSetAnchorA:Void( constraint:cpConstraint, anchorA:cpVect )
+Function cpPivotJointGetAnchorB:cpVect( constraint:cpConstraint )
+Function cpPivotJointSetAnchorB:Void( constraint:cpConstraint, anchorB:cpVect )
+
+'***** File: Chipmunk7/include/chipmunk/cpGrooveJoint.h *****
+
+Function cpConstraintIsGrooveJoint:cpBool( constraint:cpConstraint )
+Function cpGrooveJointAlloc:cpGrooveJoint(  )
+Function cpGrooveJointInit:cpGrooveJoint( joint:cpGrooveJoint, a:cpBody, b:cpBody, groove_a:cpVect, groove_b:cpVect, anchorB:cpVect )
+Function cpGrooveJointNew:cpConstraint( a:cpBody, b:cpBody, groove_a:cpVect, groove_b:cpVect, anchorB:cpVect )
+Function cpGrooveJointGetGrooveA:cpVect( constraint:cpConstraint )
+Function cpGrooveJointSetGrooveA:Void( constraint:cpConstraint, grooveA:cpVect )
+Function cpGrooveJointGetGrooveB:cpVect( constraint:cpConstraint )
+Function cpGrooveJointSetGrooveB:Void( constraint:cpConstraint, grooveB:cpVect )
+Function cpGrooveJointGetAnchorB:cpVect( constraint:cpConstraint )
+Function cpGrooveJointSetAnchorB:Void( constraint:cpConstraint, anchorB:cpVect )
+
+'***** File: Chipmunk7/include/chipmunk/cpDampedSpring.h *****
+
+Function cpConstraintIsDampedSpring:cpBool( constraint:cpConstraint )
+Alias cpDampedSpringForceFunc:cpFloat( cpConstraint, cpFloat )
+Function cpDampedSpringAlloc:cpDampedSpring Ptr(  )
+Function cpDampedSpringInit:cpDampedSpring Ptr( joint:cpDampedSpring Ptr, a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect, restLength:cpFloat, stiffness:cpFloat, damping:cpFloat )
+Function cpDampedSpringNew:cpConstraint( a:cpBody, b:cpBody, anchorA:cpVect, anchorB:cpVect, restLength:cpFloat, stiffness:cpFloat, damping:cpFloat )
+Function cpDampedSpringGetAnchorA:cpVect( constraint:cpConstraint )
+Function cpDampedSpringSetAnchorA:Void( constraint:cpConstraint, anchorA:cpVect )
+Function cpDampedSpringGetAnchorB:cpVect( constraint:cpConstraint )
+Function cpDampedSpringSetAnchorB:Void( constraint:cpConstraint, anchorB:cpVect )
+Function cpDampedSpringGetRestLength:cpFloat( constraint:cpConstraint )
+Function cpDampedSpringSetRestLength:Void( constraint:cpConstraint, restLength:cpFloat )
+Function cpDampedSpringGetStiffness:cpFloat( constraint:cpConstraint )
+Function cpDampedSpringSetStiffness:Void( constraint:cpConstraint, stiffness:cpFloat )
+Function cpDampedSpringGetDamping:cpFloat( constraint:cpConstraint )
+Function cpDampedSpringSetDamping:Void( constraint:cpConstraint, damping:cpFloat )
+Function cpDampedSpringGetSpringForceFunc:cpDampedSpringForceFunc( constraint:cpConstraint )
+Function cpDampedSpringSetSpringForceFunc:Void( constraint:cpConstraint, springForceFunc:cpDampedSpringForceFunc )
+
+'***** File: Chipmunk7/include/chipmunk/cpDampedRotarySpring.h *****
+
+Function cpConstraintIsDampedRotarySpring:cpBool( constraint:cpConstraint )
+Alias cpDampedRotarySpringTorqueFunc:cpFloat( cpConstraint, cpFloat )
+Function cpDampedRotarySpringAlloc:cpDampedRotarySpring Ptr(  )
+Function cpDampedRotarySpringInit:cpDampedRotarySpring Ptr( joint:cpDampedRotarySpring Ptr, a:cpBody, b:cpBody, restAngle:cpFloat, stiffness:cpFloat, damping:cpFloat )
+Function cpDampedRotarySpringNew:cpConstraint( a:cpBody, b:cpBody, restAngle:cpFloat, stiffness:cpFloat, damping:cpFloat )
+Function cpDampedRotarySpringGetRestAngle:cpFloat( constraint:cpConstraint )
+Function cpDampedRotarySpringSetRestAngle:Void( constraint:cpConstraint, restAngle:cpFloat )
+Function cpDampedRotarySpringGetStiffness:cpFloat( constraint:cpConstraint )
+Function cpDampedRotarySpringSetStiffness:Void( constraint:cpConstraint, stiffness:cpFloat )
+Function cpDampedRotarySpringGetDamping:cpFloat( constraint:cpConstraint )
+Function cpDampedRotarySpringSetDamping:Void( constraint:cpConstraint, damping:cpFloat )
+Function cpDampedRotarySpringGetSpringTorqueFunc:cpDampedRotarySpringTorqueFunc( constraint:cpConstraint )
+Function cpDampedRotarySpringSetSpringTorqueFunc:Void( constraint:cpConstraint, springTorqueFunc:cpDampedRotarySpringTorqueFunc )
+
+'***** File: Chipmunk7/include/chipmunk/cpRotaryLimitJoint.h *****
+
+Function cpConstraintIsRotaryLimitJoint:cpBool( constraint:cpConstraint )
+Function cpRotaryLimitJointAlloc:cpRotaryLimitJoint(  )
+Function cpRotaryLimitJointInit:cpRotaryLimitJoint( joint:cpRotaryLimitJoint, a:cpBody, b:cpBody, min:cpFloat, max:cpFloat )
+Function cpRotaryLimitJointNew:cpConstraint( a:cpBody, b:cpBody, min:cpFloat, max:cpFloat )
+Function cpRotaryLimitJointGetMin:cpFloat( constraint:cpConstraint )
+Function cpRotaryLimitJointSetMin:Void( constraint:cpConstraint, min:cpFloat )
+Function cpRotaryLimitJointGetMax:cpFloat( constraint:cpConstraint )
+Function cpRotaryLimitJointSetMax:Void( constraint:cpConstraint, max:cpFloat )
+
+'***** File: Chipmunk7/include/chipmunk/cpRatchetJoint.h *****
+
+Function cpConstraintIsRatchetJoint:cpBool( constraint:cpConstraint )
+Function cpRatchetJointAlloc:cpRatchetJoint(  )
+Function cpRatchetJointInit:cpRatchetJoint( joint:cpRatchetJoint, a:cpBody, b:cpBody, phase:cpFloat, ratchet:cpFloat )
+Function cpRatchetJointNew:cpConstraint( a:cpBody, b:cpBody, phase:cpFloat, ratchet:cpFloat )
+Function cpRatchetJointGetAngle:cpFloat( constraint:cpConstraint )
+Function cpRatchetJointSetAngle:Void( constraint:cpConstraint, angle:cpFloat )
+Function cpRatchetJointGetPhase:cpFloat( constraint:cpConstraint )
+Function cpRatchetJointSetPhase:Void( constraint:cpConstraint, phase:cpFloat )
+Function cpRatchetJointGetRatchet:cpFloat( constraint:cpConstraint )
+Function cpRatchetJointSetRatchet:Void( constraint:cpConstraint, ratchet:cpFloat )
+
+'***** File: Chipmunk7/include/chipmunk/cpGearJoint.h *****
+
+Function cpConstraintIsGearJoint:cpBool( constraint:cpConstraint )
+Function cpGearJointAlloc:cpGearJoint(  )
+Function cpGearJointInit:cpGearJoint( joint:cpGearJoint, a:cpBody, b:cpBody, phase:cpFloat, ratio:cpFloat )
+Function cpGearJointNew:cpConstraint( a:cpBody, b:cpBody, phase:cpFloat, ratio:cpFloat )
+Function cpGearJointGetPhase:cpFloat( constraint:cpConstraint )
+Function cpGearJointSetPhase:Void( constraint:cpConstraint, phase:cpFloat )
+Function cpGearJointGetRatio:cpFloat( constraint:cpConstraint )
+Function cpGearJointSetRatio:Void( constraint:cpConstraint, ratio:cpFloat )
+
+'***** File: Chipmunk7/include/chipmunk/cpSimpleMotor.h *****
+
+Function cpConstraintIsSimpleMotor:cpBool( constraint:cpConstraint )
+Function cpSimpleMotorAlloc:cpSimpleMotor Ptr(  )
+Function cpSimpleMotorInit:cpSimpleMotor Ptr( joint:cpSimpleMotor Ptr, a:cpBody, b:cpBody, rate:cpFloat )
+Function cpSimpleMotorNew:cpConstraint( a:cpBody, b:cpBody, rate:cpFloat )
+Function cpSimpleMotorGetRate:cpFloat( constraint:cpConstraint )
+Function cpSimpleMotorSetRate:Void( constraint:cpConstraint, rate:cpFloat )
+
+Class cpConstraint Extends Void
+
+	Property Space:cpSpace() Extension="cpConstraintGetSpace"
+	
+	Property BodyA:cpBody() Extension="cpConstraintGetBodyA"
+	
+	Property BodyB:cpBody() Extension="cpConstraintGetBodyB"
+	
+	Property MaxForce:cpFloat() Extension="cpConstraintGetMaxForce"
+	Setter( maxForce:cpFloat ) Extension="cpConstraintSetMaxForce"
+	
+	Property ErrorBias:cpFloat() Extension="cpConstraintGetErrorBias"
+	Setter( errorBias:cpFloat ) Extension="cpConstraintSetErrorBias"
+	
+	Property MaxBias:cpFloat() Extension="cpConstraintGetMaxBias"
+	Setter( maxBias:cpFloat ) Extension="cpConstraintSetMaxBias"
+	
+	Property CollideBodies:cpBool() Extension="cpConstraintGetCollideBodies"
+	Setter( collideBodies:cpBool ) Extension="cpConstraintSetCollideBodies"
+	
+	Property UserData:cpDataPointer() Extension="cpConstraintGetUserData"
+	Setter( userData:cpDataPointer ) Extension="cpConstraintSetUserData"
+	
+	Property Impulse:cpFloat() Extension="cpConstraintGetImpulse"
+	
+	'pin joint
+	Property IsPinJoint:cpBool() Extension="cpConstraintIsPinJoint"
+	
+	Property PinJointAnchorA:cpVect() Extension="cpPinJointGetAnchorA"
+	Setter( anchorA:cpVect ) Extension="cpPinJointSetAnchorA"
+	
+	Property PinJointAnchorB:cpVect() Extension="cpPinJointGetAnchorB"
+	Setter( anchorB:cpVect ) Extension="cpPinJointSetAnchorB"
+	
+	Property PinJointDist:cpFloat() Extension="cpPinJointGetDist"
+	Setter( dist:cpFloat ) Extension="cpPinJointSetDist"
+	
+	'slide joint
+	Property IsSlideJoint:cpBool() Extension="cpConstraintIsSliceJoint"
+
+	Property SlideJointAnchorA:cpVect() Extension="cpSlideJointGetAnchorA"
+	Setter( anchorA:cpVect ) Extension="cpSlideJointSetAnchorA"
+	
+	Property SlideJointAnchorB:cpVect() Extension="cpSlideJointGetAnchorB"
+	Setter( anchorB:cpVect ) Extension="cpSlideJointSetAnchorB"
+	
+	Property SlideJointMin:cpFloat() Extension="cpSlideJointGetMin"
+	Setter( min:cpFloat ) Extension="cpSlideJointSetMin"
+	
+	Property SlideJointMax:cpFloat() Extension="cpSlideJointGetMax"
+	Setter( max:cpFloat ) Extension="cpSlideJointSetMax"
+	
+	'pivot joint
+	Property IsPivotJoint:cpBool() Extension="cpConstraintIsPivotJoint"
+	
+	Property PivotJointAnchorA:cpVect() Extension="cpPivotJointGetAnchorA"
+	Setter( anchorA:cpVect ) Extension="cpPivotJointSetAnchorA"
+	
+	Property PivotJointAnchorB:cpVect() Extension="cpPivotJointGetAnchorB"
+	Setter( anchorB:cpVect ) Extension="cpPivotJointSetAnchorB"
+
+	'groove joint	
+	Property IsGrooveJoint:cpBool() Extension="cpConstraintIsGrooveJoint"
+
+	Property GrooveJointGrooveA:cpVect() Extension="cpGrooveJointGetGrooveA"
+	Setter( GrooveA:cpVect ) Extension="cpGrooveJointSetGrooveA"
+	
+	Property GrooveJointGrooveB:cpVect() Extension="cpGrooveJointGetGrooveB"
+	Setter( GrooveB:cpVect ) Extension="cpGrooveJointSetGrooveB"
+
+	Property GrooveJointAnchorB:cpVect() Extension="cpGrooveJointGetAnchorB"
+	Setter( anchorB:cpVect ) Extension="cpGrooveJointSetAnchorB"
+
+	'damped spring
+	Property IsDampedSpring:cpBool() Extension="cpConstraintIsDampedSpring"
+
+	Property DampedSpringAnchorA:cpVect() Extension="cpDampedSpringGetAnchorA"
+	Setter( anchorA:cpVect ) Extension="cpDampedSpringSetAnchorA"
+	
+	Property DampedSpringAnchorB:cpVect() Extension="cpDampedSpringGetAnchorB"
+	Setter( anchorB:cpVect ) Extension="cpDampedSpringSetAnchorB"
+
+	Property DampedSpringRestLength:cpFloat() Extension="cpDampedSpringGetRestLength"
+	Setter( restLength:cpFloat ) Extension="cpDampedSpringSetRestLength"
+	
+	Property DampedSpringStiffness:cpFloat() Extension="cpDampedSpringGetStiffness"
+	Setter( stiffness:cpFloat ) Extension="cpDampedSpringSetStiffness"
+	
+	Property DampedSpringDamping:cpFloat() Extension="cpDampedSpringGetDamping"
+	Setter( damping:cpFloat ) Extension="cpDampedSpringSetDamping"
+	
+	'damped rotary spring
+	Property IsDampedRotarySpring:cpBool() Extension="cpConstraintIsDampedRotarySpring"
+
+	Property DampedRotarySpringRestAngle:cpFloat() Extension="cpDampedRotarySpringGetRestAngle"
+	Setter( restAngle:cpFloat ) Extension="cpDampedRotarySpringSetRestAngle"
+	
+	Property DampedRotarySpringStiffness:cpFloat() Extension="cpDampedRotarySpringGetStiffness"
+	Setter( stiffness:cpFloat ) Extension="cpDampedRotarySpringSetStiffness"
+	
+	Property DampedRotarySpringDamping:cpFloat() Extension="cpDampedRotarySpringGetDamping"
+	Setter( damping:cpFloat ) Extension="cpDampedRotarySpringSetDamping"
+
+	'rotary limit joint
+	Property IsRotaryLimitJoint:cpBool() Extension="cpConstraintIsRotaryLimitJoint"
+	
+	Property RotaryLimitJointMin:cpFloat() Extension="cpRotaryLimitJointGetMin"
+	Setter( min:cpFloat ) Extension="cpRotaryLimitJointSetMin"
+	
+	Property RotaryLimitJointMax:cpFloat() Extension="cpRotaryLimitJointGetMax"
+	Setter( max:cpFloat ) Extension="cpRotaryLimitJointSetMax"
+
+	'ratchet joint
+	Property IsRatchetJoint:cpBool() Extension="cpConstraintIsRatchetJoint"
+
+	Property RatchetJointAngle:cpFloat() Extension="cpRatchetJointGetAngle"
+	Setter( angle:cpFloat ) Extension="cpRatchetJointSetAngle"
+
+	Property RatchetJointPhase:cpFloat() Extension="cpRatchetJointGetPhase"
+	Setter( phase:cpFloat ) Extension="cpRatchetJointSetPhase"
+
+	Property RatchetJointRatchet:cpFloat() Extension="cpRatchetJointGetRatchet"
+	Setter( ratchet:cpFloat ) Extension="cpRatchetJointSetRatchet"
+
+	'gear joint
+	Property IsGearJoint:cpBool() Extension="cpConstraintIsGearJoint"
+
+	Property GearJointPhase:cpFloat() Extension="cpGearJointGetPhase"
+	Setter( phase:cpFloat ) Extension="cpGearJointSetPhase"
+	
+	Property GearJointRatio:cpFloat() Extension="cpGearJointGetRatio"
+	Setter( ratio:cpFloat ) Extension="cpGearJointSetRatio"
+	
+	'simple motor
+	Property IsSimpleMotor:cpBool() Extension="cpConstraintIsSimpleMotor"
+
+	Property SimpleMotorRate:cpFloat() Extension="cpSimpleMotorGetRate"
+	Setter( rate:cpFloat ) Extension="cpSimpleMotorSetRate"
+			
+End
+
+Class cpPinJoint Extends Void
+End
+
+Class cpSlideJoint Extends Void
+End
+
+Class cpPivotJoint Extends Void
+End
+
+Class cpGrooveJoint Extends Void
+End
+
+Class cpDampedSpring Extends Void
+End
+
+Class cpDampedRotarySpring Extends Void
+End
+
+Class cpRotaryLimitJoint Extends Void
+End
+
+Class cpRatchetJoint extends Void
+End
+
+Class cpGearJoint Extends Void
+End
+
+Class cpSimpleMotor Extends Void
+End

modules/chipmunk/shape.monkey2

@@ -0,0 +1,141 @@
+
+Namespace chipmunk
+
+#Import "chipmunk_glue.h"
+
+Extern
+
+Class cpCircleShape Extends Void
+End
+
+Class cpSegmentShape Extends Void
+End
+
+Struct cpPointQueryInfo
+	Field shape:cpShape
+	Field point:cpVect
+	Field distance:cpFloat
+	Field gradient:cpVect
+End
+
+Struct cpSegmentQueryInfo
+	Field shape:cpShape
+	Field point:cpVect
+	Field normal:cpVect
+	Field alpha:cpFloat
+End
+
+Struct cpShapeFilter
+	Field group:cpGroup
+	Field categories:cpBitmask
+	Field mask:cpBitmask
+End
+
+Const CP_SHAPE_FILTER_ALL:cpShapeFilter
+Const CP_SHAPE_FILTER_NONE:cpShapeFilter
+
+Function cpShapeFilterNew:cpShapeFilter( group:cpGroup, categories:cpBitmask, mask:cpBitmask )
+Function cpShapeDestroy:Void( shape:cpShape )
+Function cpShapeFree:Void( shape:cpShape )
+Function cpShapeCacheBB:cpBB( shape:cpShape )
+Function cpShapeUpdate:cpBB( shape:cpShape, transform:cpTransform )
+Function cpShapePointQuery:cpFloat( shape:cpShape, p:cpVect, out:cpPointQueryInfo Ptr )
+Function cpShapeSegmentQuery:cpBool( shape:cpShape, a:cpVect, b:cpVect, radius:cpFloat, info:cpSegmentQueryInfo Ptr )
+Function cpShapesCollide:cpContactPointSet( a:cpShape, b:cpShape )
+Function cpShapeGetSpace:cpSpace Ptr( shape:cpShape )
+Function cpShapeGetBody:cpBody( shape:cpShape )
+Function cpShapeSetBody:Void( shape:cpShape, body:cpBody )
+Function cpShapeGetMass:cpFloat( shape:cpShape )
+Function cpShapeSetMass:Void( shape:cpShape, mass:cpFloat )
+Function cpShapeGetDensity:cpFloat( shape:cpShape )
+Function cpShapeSetDensity:Void( shape:cpShape, density:cpFloat )
+Function cpShapeGetMoment:cpFloat( shape:cpShape )
+Function cpShapeGetArea:cpFloat( shape:cpShape )
+Function cpShapeGetCenterOfGravity:cpVect( shape:cpShape )
+Function cpShapeGetBB:cpBB( shape:cpShape )
+Function cpShapeGetSensor:cpBool( shape:cpShape )
+Function cpShapeSetSensor:Void( shape:cpShape, sensor:cpBool )
+Function cpShapeGetElasticity:cpFloat( shape:cpShape )
+Function cpShapeSetElasticity:Void( shape:cpShape, elasticity:cpFloat )
+Function cpShapeGetFriction:cpFloat( shape:cpShape )
+Function cpShapeSetFriction:Void( shape:cpShape, friction:cpFloat )
+Function cpShapeGetSurfaceVelocity:cpVect( shape:cpShape )
+Function cpShapeSetSurfaceVelocity:Void( shape:cpShape, surfaceVelocity:cpVect )
+Function cpShapeGetUserData:cpDataPointer( shape:cpShape )
+Function cpShapeSetUserData:Void( shape:cpShape, userData:cpDataPointer )
+Function cpShapeGetCollisionType:cpCollisionType( shape:cpShape )
+Function cpShapeSetCollisionType:Void( shape:cpShape, collisionType:cpCollisionType )
+Function cpShapeGetFilter:cpShapeFilter( shape:cpShape )
+Function cpShapeSetFilter:Void( shape:cpShape, filter:cpShapeFilter )
+Function cpCircleShapeAlloc:cpCircleShape Ptr(  )
+Function cpCircleShapeInit:cpCircleShape Ptr( circle:cpCircleShape Ptr, body:cpBody, radius:cpFloat, offset:cpVect )
+Function cpCircleShapeNew:cpShape( body:cpBody, radius:cpFloat, offset:cpVect )
+Function cpCircleShapeGetOffset:cpVect( shape:cpShape )
+Function cpCircleShapeGetRadius:cpFloat( shape:cpShape )
+Function cpSegmentShapeAlloc:cpSegmentShape Ptr(  )
+Function cpSegmentShapeInit:cpSegmentShape Ptr( seg:cpSegmentShape Ptr, body:cpBody, a:cpVect, b:cpVect, radius:cpFloat )
+Function cpSegmentShapeNew:cpShape( body:cpBody, a:cpVect, b:cpVect, radius:cpFloat )
+Function cpSegmentShapeSetNeighbors:Void( shape:cpShape, prev:cpVect, next_:cpVect )
+Function cpSegmentShapeGetA:cpVect( shape:cpShape )
+Function cpSegmentShapeGetB:cpVect( shape:cpShape )
+Function cpSegmentShapeGetNormal:cpVect( shape:cpShape )
+Function cpSegmentShapeGetRadius:cpFloat( shape:cpShape )
+
+Class cpShape Extends Void
+
+	Property Body:cpBody() Extension="cpShapeGetBody"
+	Setter( body:cpBody ) Extension="cpShapeSetBody"
+	
+	Property Mass:cpFloat() Extension="cpShapeGetMass"
+	Setter( mass:cpFloat ) Extension="cpShapeSetMass"
+	
+	Property Density:cpFloat() Extension="cpShapeGetDensity"
+	Setter( density:cpFloat ) Extension="cpShapeSetDensity"
+	
+	Property Sensor:cpBool() Extension="cpShapeGetSensor"
+	Setter( sensor:cpBool ) Extension="cpShapeSetSensor"
+	
+	Property Elasticity:cpFloat() Extension="cpShapeGetElasticity"
+	Setter( elasticity:cpFloat ) Extension="cpShapeSetElasticity"
+	
+	Property Friction:cpFloat() Extension="cpShapeGetFriction"
+	Setter( friction:cpFloat ) Extension="cpShapeSetFriction"
+	
+	Property SurfaceVelocity:cpVect() Extension="cpShapeGetSurfaceVelocity"
+	Setter( surfaceVelocity:cpVect ) Extension="cpShapeSetSurfaceVelocity"
+	
+	Property UserData:cpDataPointer() Extension="cpShapeGetUserData"
+	Setter( userData:cpDataPointer ) Extension="cpShapeSetUserData"
+	
+	Property CollisionType:cpCollisionType() Extension="cpShapeGetCollisionType"
+	Setter( collisionType:cpCollisionType ) Extension="cpShapeSetCollisionType"
+	
+	Property Moment:cpFloat() Extension="cpShapeGetMoment"
+	
+	Property Area:cpFloat() Extension="cpShapeGetArea"
+	
+	Property CenterOfGravity:cpVect() Extension="cpShapeGetCenterOfGravity"
+
+	Property CacheBB:cpBB() Extension="cpShapeCacheBB"
+
+	Property BB:cpBB() Extension="cpShapeGetBB"
+	
+	Property Space:cpSpace() Extension="cpShapeGetSpace"
+	
+	Property CircleRadius:cpFloat() Extension="cpCircleShapeGetRadius"
+	
+	Property CircleOffset:cpVect() Extension="cpCircleShapeGetOffset"
+	
+	Property SegmentA:cpVect() Extension="cpSegmentShapeGetA"
+	
+	Property SegmentB:cpVect() Extension="cpSegmentShapeGetB"
+	
+	Method Update:cpBB( transform:cpTransform ) Extension="cpShapeUpdate"
+	
+	Method PointQuery:cpFloat( p:cpVect, out:cpPointQueryInfo Ptr ) Extension="cpShapePointQuery"
+	
+	Method SegmentQuery:cpBool( a:cpVect, b:cpVect, radius:cpFloat, info:cpSegmentQueryInfo Ptr ) Extension="cpShapeSegmentQuery"
+	
+	Method sCollide:cpContactPointSet( a:cpShape, b:cpShape ) Extension="cpShapesCollide"
+	
+End

modules/chipmunk/space.monkey2

@@ -0,0 +1,172 @@
+
+Namespace chipmunk
+
+#Import "chipmunk_glue.h"
+
+Extern
+
+'***** File: Chipmunk7/include/chipmunk/cpSpace.h *****
+
+Alias cpCollisionBeginFunc:cpBool( cpArbiter, cpSpace, cpDataPointer )
+Alias cpCollisionPreSolveFunc:cpBool( cpArbiter, cpSpace, cpDataPointer )
+Alias cpCollisionPostSolveFunc:Void( cpArbiter, cpSpace, cpDataPointer )
+Alias cpCollisionSeparateFunc:Void( cpArbiter, cpSpace, cpDataPointer )
+
+Class cpCollisionHandler="bb_cpCollisionHandler"
+	Field typeA:cpCollisionType
+	Field typeB:cpCollisionType
+	Field beginFunc:cpCollisionBeginFunc
+	Field preSolveFunc:cpCollisionPreSolveFunc
+	Field postSolveFunc:cpCollisionPostSolveFunc
+	Field separateFunc:cpCollisionSeparateFunc
+	Field userData:cpDataPointer
+End
+
+Alias cpSpaceDebugDrawCircleImpl:Void( cpVect, cpFloat, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, cpDataPointer )
+Alias cpSpaceDebugDrawSegmentImpl:Void( cpVect, cpVect, cpSpaceDebugColor, cpDataPointer )
+Alias cpSpaceDebugDrawFatSegmentImpl:Void( cpVect, cpVect, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, cpDataPointer )
+Alias cpSpaceDebugDrawPolygonImpl:Void( Int, cpVect Ptr, cpFloat, cpSpaceDebugColor, cpSpaceDebugColor, cpDataPointer )
+Alias cpSpaceDebugDrawDotImpl:Void( cpFloat, cpVect, cpSpaceDebugColor, cpDataPointer )
+Alias cpSpaceDebugDrawColorForShapeImpl:cpSpaceDebugColor( cpShape, cpDataPointer )
+
+Enum cpSpaceDebugDrawFlags
+End
+
+Const CP_SPACE_DEBUG_DRAW_SHAPES:cpSpaceDebugDrawFlags
+Const CP_SPACE_DEBUG_DRAW_CONSTRAINTS:cpSpaceDebugDrawFlags
+Const CP_SPACE_DEBUG_DRAW_COLLISION_POINTS:cpSpaceDebugDrawFlags
+
+Struct cpSpaceDebugColor
+	Field r:Float
+	Field g:Float
+	Field b:Float
+	Field a:Float
+End
+
+Class cpSpaceDebugDrawOptions="bb_cpSpaceDebugDrawOptions"
+	Field drawCircle:cpSpaceDebugDrawCircleImpl
+	Field drawSegment:cpSpaceDebugDrawSegmentImpl
+	Field drawFatSegment:cpSpaceDebugDrawFatSegmentImpl
+	Field drawPolygon:cpSpaceDebugDrawPolygonImpl
+	Field drawDot:cpSpaceDebugDrawDotImpl
+	Field flags:cpSpaceDebugDrawFlags
+	Field shapeOutlineColor:cpSpaceDebugColor
+	Field colorForShape:cpSpaceDebugDrawColorForShapeImpl
+	Field constraintColor:cpSpaceDebugColor
+	Field collisionPointColor:cpSpaceDebugColor
+	Field userData:cpDataPointer
+End
+
+Alias cpPostStepFunc:Void( cpSpace, Void Ptr, Void Ptr )
+Alias cpSpacePointQueryFunc:Void( cpShape, cpVect, cpFloat, cpVect, Void Ptr )
+Alias cpSpaceSegmentQueryFunc:Void( cpShape, cpVect, cpVect, cpFloat, Void Ptr )
+Alias cpSpaceBBQueryFunc:Void( cpShape, Void Ptr )
+Alias cpSpaceShapeQueryFunc:Void( cpShape, cpContactPointSet Ptr, Void Ptr )
+Alias cpSpaceBodyIteratorFunc:Void( cpBody, Void Ptr )
+Alias cpSpaceShapeIteratorFunc:Void( cpShape, Void Ptr )
+Alias cpSpaceConstraintIteratorFunc:Void( cpConstraint Ptr, Void Ptr )
+
+Function cpSpaceAlloc:cpSpace(  )
+Function cpSpaceInit:cpSpace( space:cpSpace )
+Function cpSpaceNew:cpSpace(  )
+Function cpSpaceDestroy:Void( space:cpSpace )
+Function cpSpaceFree:Void( space:cpSpace )
+Function cpSpaceGetIterations:Int( space:cpSpace )
+Function cpSpaceSetIterations:Void( space:cpSpace, iterations:Int )
+Function cpSpaceGetGravity:cpVect( space:cpSpace )
+Function cpSpaceSetGravity:Void( space:cpSpace, gravity:cpVect )
+Function cpSpaceGetDamping:cpFloat( space:cpSpace )
+Function cpSpaceSetDamping:Void( space:cpSpace, damping:cpFloat )
+Function cpSpaceGetIdleSpeedThreshold:cpFloat( space:cpSpace )
+Function cpSpaceSetIdleSpeedThreshold:Void( space:cpSpace, idleSpeedThreshold:cpFloat )
+Function cpSpaceGetSleepTimeThreshold:cpFloat( space:cpSpace )
+Function cpSpaceSetSleepTimeThreshold:Void( space:cpSpace, sleepTimeThreshold:cpFloat )
+Function cpSpaceGetCollisionSlop:cpFloat( space:cpSpace )
+Function cpSpaceSetCollisionSlop:Void( space:cpSpace, collisionSlop:cpFloat )
+Function cpSpaceGetCollisionBias:cpFloat( space:cpSpace )
+Function cpSpaceSetCollisionBias:Void( space:cpSpace, collisionBias:cpFloat )
+Function cpSpaceGetCollisionPersistence:cpTimestamp( space:cpSpace )
+Function cpSpaceSetCollisionPersistence:Void( space:cpSpace, collisionPersistence:cpTimestamp )
+Function cpSpaceGetUserData:cpDataPointer( space:cpSpace )
+Function cpSpaceSetUserData:Void( space:cpSpace, userData:cpDataPointer )
+Function cpSpaceGetStaticBody:cpBody( space:cpSpace )
+Function cpSpaceGetCurrentTimeStep:cpFloat( space:cpSpace )
+Function cpSpaceIsLocked:cpBool( space:cpSpace )
+Function cpSpaceAddDefaultCollisionHandler:cpCollisionHandler( space:cpSpace )="bb_cpSpaceAddDefaultCollisionHandler"
+Function cpSpaceAddCollisionHandler:cpCollisionHandler( space:cpSpace, a:cpCollisionType, b:cpCollisionType )="bb_cpSpaceAddCollisionHandler"
+Function cpSpaceAddWildcardHandler:cpCollisionHandler( space:cpSpace, type:cpCollisionType )="bb_cpSpaceAddWildcardHandler"
+Function cpSpaceAddShape:cpShape( space:cpSpace, shape:cpShape )
+Function cpSpaceAddBody:cpBody( space:cpSpace, body:cpBody )
+Function cpSpaceAddConstraint:cpConstraint Ptr( space:cpSpace, constraint:cpConstraint Ptr )
+Function cpSpaceRemoveShape:Void( space:cpSpace, shape:cpShape )
+Function cpSpaceRemoveBody:Void( space:cpSpace, body:cpBody )
+Function cpSpaceRemoveConstraint:Void( space:cpSpace, constraint:cpConstraint Ptr )
+Function cpSpaceContainsShape:cpBool( space:cpSpace, shape:cpShape )
+Function cpSpaceContainsBody:cpBool( space:cpSpace, body:cpBody )
+Function cpSpaceContainsConstraint:cpBool( space:cpSpace, constraint:cpConstraint Ptr )
+Function cpSpaceAddPostStepCallback:cpBool( space:cpSpace, func:cpPostStepFunc, key:Void Ptr, data:Void Ptr )
+Function cpSpacePointQuery:Void( space:cpSpace, point:cpVect, maxDistance:cpFloat, filter:cpShapeFilter, func:cpSpacePointQueryFunc, data:Void Ptr )
+Function cpSpacePointQueryNearest:cpShape( space:cpSpace, point:cpVect, maxDistance:cpFloat, filter:cpShapeFilter, out:cpPointQueryInfo Ptr )
+Function cpSpaceSegmentQuery:Void( space:cpSpace, start:cpVect, end_:cpVect, radius:cpFloat, filter:cpShapeFilter, func:cpSpaceSegmentQueryFunc, data:Void Ptr )
+Function cpSpaceSegmentQueryFirst:cpShape( space:cpSpace, start:cpVect, end_:cpVect, radius:cpFloat, filter:cpShapeFilter, out:cpSegmentQueryInfo Ptr )
+Function cpSpaceBBQuery:Void( space:cpSpace, bb:cpBB, filter:cpShapeFilter, func:cpSpaceBBQueryFunc, data:Void Ptr )
+Function cpSpaceShapeQuery:cpBool( space:cpSpace, shape:cpShape, func:cpSpaceShapeQueryFunc, data:Void Ptr )
+Function cpSpaceEachBody:Void( space:cpSpace, func:cpSpaceBodyIteratorFunc, data:Void Ptr )
+Function cpSpaceEachShape:Void( space:cpSpace, func:cpSpaceShapeIteratorFunc, data:Void Ptr )
+Function cpSpaceEachConstraint:Void( space:cpSpace, func:cpSpaceConstraintIteratorFunc, data:Void Ptr )
+Function cpSpaceReindexStatic:Void( space:cpSpace )
+Function cpSpaceReindexShape:Void( space:cpSpace, shape:cpShape )
+Function cpSpaceReindexShapesForBody:Void( space:cpSpace, body:cpBody )
+Function cpSpaceUseSpatialHash:Void( space:cpSpace, dim:cpFloat, count:Int )
+Function cpSpaceStep:Void( space:cpSpace, dt:cpFloat )
+Function cpSpaceDebugDraw:Void( space:cpSpace, options:cpSpaceDebugDrawOptions )="bb_cpSpaceDebugDraw"
+
+Class cpSpace Extends Void
+
+	Property Iterations:Int() Extension="cpSpaceGetIterations"
+	Setter( iterations:Int ) Extension="cpSpaceSetIterations"
+	
+	Property Gravity:cpVect() Extension="cpSpaceGetGravity"
+	Setter( gravity:cpVect ) Extension="cpSpaceSetGravity"
+	
+	Property Damping:cpFloat() Extension="cpSpaceGetDamping"
+	Setter( damping:cpFloat ) Extension="cpSpaceSetDamping"
+
+	Property IdleSpeedThreshold:cpFloat() Extension="cpSpaceGetIdleSpeedThreshold"
+	Setter( idleSpeedThreshold:cpFloat ) Extension="cpSpaceSetIdleSpeedThreshold"
+	
+	Property SleepTimeThreshold:cpFloat() Extension="cpSpaceGetSleepTimeThreshold"
+	Setter( sleepTimeThreshold:cpFloat ) Extension="cpSpaceSetSleepTimeThreshold"
+	
+	Property CollisionSlop:cpFloat() Extension="cpSpaceGetCollisionSlop"
+	Setter( collisionSlop:cpFloat ) Extension="cpSpaceSetCollisionSlop"
+	
+	Property CollisionBias:cpFloat() Extension="cpSpaceGetCollisionBias"
+	Setter( collisionBias:cpFloat ) Extension="cpSpaceSetCollisionBias"
+	
+	Property CollisionPersistence:cpTimestamp() Extension="cpSpaceGetCollisionPersistence"
+	Setter( collisionPersistence:cpTimestamp ) Extension="cpSpaceSetCollisionPersistence"
+	
+	Property UserData:cpDataPointer() Extension="cpSpaceGetUserData"
+	Setter( userData:cpDataPointer ) Extension="cpSpaceSetUserData"
+		
+	Property StaticBody:cpBody() Extension="cpSpaceGetStaticBody"
+	
+	Property CurrentTimeStep:cpFloat() Extension="cpSpaceGetCurrentTimeStep"
+	
+	property IsLocked:cpBool() Extension="cpSpaceIsLocked"
+	
+	Method StepTime( dt:cpFloat ) Extension="cpSpaceStep"
+	
+	Method AddShape:cpShape( shape:cpShape ) Extension="cpSpaceAddShape"
+	
+	Method AddBody:cpBody( body:cpBody ) Extension="cpSpaceAddBody"
+
+	Method RemoveShape( shape:cpShape ) Extension="cpSpaceRemoveShape"
+	
+	Method RemoveBody( body:cpBody ) Extension="cpSpaceRemoveBody"
+
+	Method AddDefaultCollisionHandler:cpCollisionHandler() Extension="bb_cpSpaceAddDefaultCollisionHandler"
+	
+	Method DebugDraw( options:cpSpaceDebugDrawOptions ) Extension="bb_cpSpaceDebugDraw"
+End

modules/chipmunk/types.monkey2

@@ -0,0 +1,140 @@
+
+Namespace chipmunk
+
+#Import "chipmunk_glue.h"
+
+Extern
+
+'***** File: Chipmunk7/include/chipmunk/chipmunk.h *****
+
+Global cpVersionString:CString
+Function cpMomentForCircle:cpFloat( m:cpFloat, r1:cpFloat, r2:cpFloat, offset:cpVect )
+Function cpAreaForCircle:cpFloat( r1:cpFloat, r2:cpFloat )
+Function cpMomentForSegment:cpFloat( m:cpFloat, a:cpVect, b:cpVect, radius:cpFloat )
+Function cpAreaForSegment:cpFloat( a:cpVect, b:cpVect, radius:cpFloat )
+Function cpMomentForPoly:cpFloat( m:cpFloat, count:Int, verts:cpVect Ptr, offset:cpVect, radius:cpFloat )
+Function cpAreaForPoly:cpFloat( count:Int, verts:cpVect Ptr, radius:cpFloat )
+Function cpCentroidForPoly:cpVect( count:Int, verts:cpVect Ptr )
+Function cpMomentForBox:cpFloat( m:cpFloat, width:cpFloat, height:cpFloat )
+Function cpMomentForBox2:cpFloat( m:cpFloat, box:cpBB )
+Function cpConvexHull:Int( count:Int, verts:cpVect Ptr, result:cpVect Ptr, first:Int Ptr, tol:cpFloat )
+Function cpClosetPointOnSegment:cpVect( p:cpVect, a:cpVect, b:cpVect )
+
+'***** File: Chipmunk7/include/chipmunk/chipmunk_types.h *****
+
+Alias cpFloat:Double
+Function cpfmax:cpFloat( a:cpFloat, b:cpFloat )
+Function cpfmin:cpFloat( a:cpFloat, b:cpFloat )
+Function cpfabs:cpFloat( f:cpFloat )
+Function cpfclamp:cpFloat( f:cpFloat, min:cpFloat, max:cpFloat )
+Function cpfclamp01:cpFloat( f:cpFloat )
+Function cpflerp:cpFloat( f1:cpFloat, f2:cpFloat, t:cpFloat )
+Function cpflerpconst:cpFloat( f1:cpFloat, f2:cpFloat, d:cpFloat )
+Alias cpHashValue:libc.uintptr_t
+Alias cpCollisionID:libc.uint32_t
+Alias cpBool:UByte
+Alias cpDataPointer:Void Ptr
+Alias cpCollisionType:Int'libc.uintptr_t
+Alias cpGroup:libc.uintptr_t
+Alias cpBitmask:UInt
+Alias cpTimestamp:UInt
+
+Struct cpVect
+	Field x:cpFloat
+	Field y:cpFloat
+End
+
+Struct cpTransform
+	Field a:cpFloat
+	Field b:cpFloat
+	Field c:cpFloat
+	Field d:cpFloat
+	Field tx:cpFloat
+	Field ty:cpFloat
+End
+
+Struct cpMat2x2
+	Field a:cpFloat
+	Field b:cpFloat
+	Field c:cpFloat
+	Field d:cpFloat
+End
+
+'***** File: Chipmunk7/include/chipmunk/cpVect.h *****
+
+Const cpvzero:cpVect
+Function cpv:cpVect( x:cpFloat, y:cpFloat )
+Function cpveql:cpBool( v1:cpVect, v2:cpVect )
+Function cpvadd:cpVect( v1:cpVect, v2:cpVect )
+Function cpvsub:cpVect( v1:cpVect, v2:cpVect )
+Function cpvneg:cpVect( v:cpVect )
+Function cpvmult:cpVect( v:cpVect, s:cpFloat )
+Function cpvdot:cpFloat( v1:cpVect, v2:cpVect )
+Function cpvcross:cpFloat( v1:cpVect, v2:cpVect )
+Function cpvperp:cpVect( v:cpVect )
+Function cpvrperp:cpVect( v:cpVect )
+Function cpvproject:cpVect( v1:cpVect, v2:cpVect )
+Function cpvforangle:cpVect( a:cpFloat )
+Function cpvtoangle:cpFloat( v:cpVect )
+Function cpvrotate:cpVect( v1:cpVect, v2:cpVect )
+Function cpvunrotate:cpVect( v1:cpVect, v2:cpVect )
+Function cpvlengthsq:cpFloat( v:cpVect )
+Function cpvlength:cpFloat( v:cpVect )
+Function cpvlerp:cpVect( v1:cpVect, v2:cpVect, t:cpFloat )
+Function cpvnormalize:cpVect( v:cpVect )
+Function cpvslerp:cpVect( v1:cpVect, v2:cpVect, t:cpFloat )
+Function cpvslerpconst:cpVect( v1:cpVect, v2:cpVect, a:cpFloat )
+Function cpvclamp:cpVect( v:cpVect, len:cpFloat )
+Function cpvlerpconst:cpVect( v1:cpVect, v2:cpVect, d:cpFloat )
+Function cpvdist:cpFloat( v1:cpVect, v2:cpVect )
+Function cpvdistsq:cpFloat( v1:cpVect, v2:cpVect )
+Function cpvnear:cpBool( v1:cpVect, v2:cpVect, dist:cpFloat )
+Function cpMat2x2New:cpMat2x2( a:cpFloat, b:cpFloat, c:cpFloat, d:cpFloat )
+Function cpMat2x2Transform:cpVect( m:cpMat2x2, v:cpVect )
+
+'***** File: Chipmunk7/include/chipmunk/cpBB.h *****
+
+Struct cpBB
+	Field l:cpFloat
+	Field b:cpFloat
+	Field r:cpFloat
+	Field t:cpFloat
+End
+Function cpBBNew:cpBB( l:cpFloat, b:cpFloat, r:cpFloat, t:cpFloat )
+Function cpBBNewForExtents:cpBB( c:cpVect, hw:cpFloat, hh:cpFloat )
+Function cpBBNewForCircle:cpBB( p:cpVect, r:cpFloat )
+Function cpBBIntersects:cpBool( a:cpBB, b:cpBB )
+Function cpBBContainsBB:cpBool( bb:cpBB, other:cpBB )
+Function cpBBContainsVect:cpBool( bb:cpBB, v:cpVect )
+Function cpBBMerge:cpBB( a:cpBB, b:cpBB )
+Function cpBBExpand:cpBB( bb:cpBB, v:cpVect )
+Function cpBBCenter:cpVect( bb:cpBB )
+Function cpBBArea:cpFloat( bb:cpBB )
+Function cpBBMergedArea:cpFloat( a:cpBB, b:cpBB )
+Function cpBBSegmentQuery:cpFloat( bb:cpBB, a:cpVect, b:cpVect )
+Function cpBBIntersectsSegment:cpBool( bb:cpBB, a:cpVect, b:cpVect )
+Function cpBBClampVect:cpVect( bb:cpBB, v:cpVect )
+Function cpBBWrapVect:cpVect( bb:cpBB, v:cpVect )
+Function cpBBOffset:cpBB( bb:cpBB, v:cpVect )
+
+'***** File: Chipmunk7/include/chipmunk/cpTransform.h *****
+
+Const cpTransformIdentity:cpTransform
+Function cpTransformNew:cpTransform( a:cpFloat, b:cpFloat, c:cpFloat, d:cpFloat, tx:cpFloat, ty:cpFloat )
+Function cpTransformNewTranspose:cpTransform( a:cpFloat, c:cpFloat, tx:cpFloat, b:cpFloat, d:cpFloat, ty:cpFloat )
+Function cpTransformInverse:cpTransform( t:cpTransform )
+Function cpTransformMult:cpTransform( t1:cpTransform, t2:cpTransform )
+Function cpTransformPoint:cpVect( t:cpTransform, p:cpVect )
+Function cpTransformVect:cpVect( t:cpTransform, v:cpVect )
+Function cpTransformbBB:cpBB( t:cpTransform, bb:cpBB )
+Function cpTransformTranslate:cpTransform( translate:cpVect )
+Function cpTransformScale:cpTransform( scaleX:cpFloat, scaleY:cpFloat )
+Function cpTransformRotate:cpTransform( radians:cpFloat )
+Function cpTransformRigid:cpTransform( translate:cpVect, radians:cpFloat )
+Function cpTransformRigidInverse:cpTransform( t:cpTransform )
+Function cpTransformWrap:cpTransform( outer:cpTransform, inner:cpTransform )
+Function cpTransformWrapInverse:cpTransform( outer:cpTransform, inner:cpTransform )
+Function cpTransformOrtho:cpTransform( bb:cpBB )
+Function cpTransformBoneScale:cpTransform( v0:cpVect, v1:cpVect )
+Function cpTransformAxialScale:cpTransform( axis:cpVect, pivot:cpVect, scale:cpFloat )
+

src/mojox_r/mojox_r.monkey2

@@ -0,0 +1,83 @@
+
+Class OptionsView Extends View
+
+	Method AddInt( text:String,value:Int,modified:Int( value:Int ) )
+	End
+	
+	Method AddString( text:String,value:String,modified:String( value:String ) )
+	End
+	
+	Method AddFilePath( text:String,value:String )
+	End
+	
+	Method AddDirectoryPath( text:String,value:String )
+	End
+	
+	Private
+	
+	Class Option
+	
+		Field label:Label
+		Field view:View
+		
+		Method New( text:String )
+		End
+		
+	End
+	
+	Class IntField Extends Option
+	End
+	
+	Class StringField Extends Option
+	End
+	
+	Class FilePathField Extends Option
+	End
+	
+	Class DirectoryPathField Extends Option
+	End
+	
+	Protected
+	
+	Method OnMeasure:Vec2i() Override
+	
+		Local w0:=0,w1:=0,h:=0
+		
+		For Local opt:=Eachin _options
+			w0=Max( w0,opt.label.MeasuredSize.x )
+			w1=Max( w1,opt.view.MeasuredSize.x )
+			h+=Max( opt.label.MeasuredSize.y,opt.view.MeasuredSize.y )
+		Next
+		
+		_w0=w0
+		_w1=w1
+		
+		Return New Vec2i( w0+w1,h )
+	End
+	
+	Method OnLayout() Override
+	
+		For Local opt:=Eachin _options
+		
+			opt.Frame=New Recti( x,y,x+_w0,y
+		
+		Next
+	
+	End
+	
+	Private
+	
+	Field _w0:Int,_w1:Int
+	
+	Field _options:=New Stack<Option>
+
+End
+
+Class ObjectView Extends View
+
+	Method New( obj:Object )
+	
+		
+	End
+
+End