{_      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ portable (needs FFI) provisionalfelipe.lessa@gmail.com#6Type synonym used to hint that the argument or result  represents a position. /A two-dimensional vector. It is an instance of   however the operations  and (*) are not  supported. 6Type synonym used to hint that the argument or result " represents a damping constant. 6Type synonym used to hint that the argument or result  represents a distance. 6Type synonym used to hint that the argument or result # represents an angle in radians. 6Type synonym used to hint that the argument or result  represents time. 5The floating point type used internally in Chipmunk. 7Initilizes the Chipmunk library. This should be called 4 once before using any functions of this library. infinity# may be used to create bodies with  an infinite mass. resetShapeCounter( reset the shape counter to its default @ value. This is used to add determinism to a simulation. As = the ids created with this counter may affect the order in 9 which the collisions happen, there may be very slight @ differences in different simulations. It may be very useful  to call resetShapeCounter everytime you start a new  simulation. 9However, be careful as you should not use shapes created  before a call to  resetCounter with shapes created after it 9 as they may have the same id. This means that you can't add ? shapes created after the call to a space created before it. 3Constructs an unitary vector pointing to the given  angle (in radians). The length of a vector. 7Normalizes the vector (i.e. divides it by its length). 6Scales the components of a vector by the same amount.  toAngle v is the angle that v has  with the vector  Vector 1 0 (modulo 2*pi). v1 `dot` v2& computes the familiar dot operation. v1 `cross` v2( computes the familiar cross operation. perp v is a vector of same length as v but perpendicular  to v (i.e. toAngle (perp v) - toAngle v equals pi/2  modulo 2*pi). v1 `project` v2 is the vector projection of v1 onto v2. v1 `rotate` v2 uses complex multiplication  to rotate (and scale) v1 by v2. The inverse operation of rotate , such that  unrotate (rotate v1 v2) v2 equals v1.      portable (needs FFI) provisionalfelipe.lessa@gmail.com1A ) contains information about a collision.  It is passed to Physics.Hipmunk.Space.Full.  The fields  and  do not have any meaningfull  value until Physics.Hipmunk.Space.step has returned 6 (i.e. during a call to a callback this information 9 contains garbage), and by extension you can only know  the impulse sum after step returns as well.  IMPORTANT:- You may maintain a reference to an array of  Contact0s that was passed to a callback to do any other  processing later. However,  a new call to step will  invalidate any of those arrays! Be careful. "Position of the collision in world's coordinates. Normal of the collision. 'Penetration distance of the collision. +Normal component of final impulse applied.  (Valid only after step finishes.) /Tangential component of final impulse applied.  (Valid only after step finishes.) +Arbiters are used within callbacks. We don't expose them to  the user. /Type class implemented by entities that can be  added to a space. Add an entity to a . Don't add the same  entity twice to a space. Remove an entity from a . Don' t remove  an entity that wasn' t added. 8Internal function. Retrive the pointer of this entity. 7A space is where the simulation really occurs. You add 6 bodies, shapes and constraints to a space and then step it  to update it as whole. 6Internal. Class implemented by all constraint types. (Type of generic constraint initializar. An unknown constraint "type". Note that this isn't a   because you can't create a constraint of  Unknown type. /Represents a constraint between two bodies. Don' t forget to : add the bodies and the constraint itself to the space. : The phantom type indicates the type of the constraint. !#A collision shape is attached to a " to define its 5 shape. Multiple shapes may be attached, including ) overlapping ones (shapes of a body don't generate collisions  with each other).  Note that to have any effect, a ! must also be  added to a &, even if the body was already added. "8A rigid body representing the physical properties of an @ object, but without a shape. It may help to think of it as a $ particle that is able to rotate. Internal. Retrive a ! from a  and a . 7Internal. Free all function pointers of this handler. - !"- !"portable (needs FFI) provisionalfelipe.lessa@gmail.com&  #$%&'()newBody mass inertia creates a new " with ) the given mass and moment of inertia. It is recommended to call  setPosition afterwards. *+,-5Note that using this function to change the position 4 on every step is not recommended as it may leave  the velocity out of sync. ./AMaximum linear velocity after integrating, defaults to infinity. 012BMaximum angular velocity after integrating, defaults to infinity. 34slew b newpos dt changes the body b' s velocity  so that it reaches newpos in dt time. /It is usually used to change the position of a 4 static body in the world. In that case, remember - to reset the velocity to zero afterwards! 5#updateVelocity b gravity damping dt redefines body b's 7 linear and angular velocity to account for the force/torque 9 being applied to it, the gravity and a damping factor  during dt time using Euler integration. 7Note that this function only needs to be called if you ' are not adding the body to a space. 6updatePosition b dt" redefines the body position like  5 (and it also shouldn't be called if you % are adding this body to a space). 7 resetForces b) redefines as zero all forces and torque  acting on body b. 8applyForce b f r applies to the body b the force  f with offset r%, both vectors in world coordinates. / This is the most stable way to change a body' s velocity. 7Note that the force is accumulated in the body, so you  may need to call 9. 9applyOnlyForce b f r applies a force like 8,  but calling 7 before. Note that using this > function is preferable as it is optimized over this common  case. :applyImpulse b j r applies to the body b the impulse  j with offset r%, both vectors in world coordinates. ;*dampedSpring (b1,a1) (b2,a2) rlen k dmp dt applies a damped  spring force between bodies b1 and b2 at anchors  a1 and a2, respectively. k is the spring constant  (force/ distance), rlen# is the rest length of the spring,  dmp is the damping constant (force/velocity), and dt > is the time step to apply the force over. Both anchors are  in body coordinates. ;Note: large damping values can be unstable, you should use ) the damped spring constraint instead. < For a vector p in body b's coordinates,  localToWorld b p" returns the corresponding vector  in world coordinates. = For a vector p in world coordinates,  worldToLocal b p" returns the corresponding vector  in body b's coordinates. "#$%&'()*+,-./0123456789:;<=")(*'+-&./%0,$12#3456789:;<=#$%&'()*+,-./0123456789:;<=portable (needs FFI) provisionalfelipe.lessa@gmail.com3   >.A possible intersection between two segments. ?Share a segment. @Intercept in a point. ADon' t intercept. BA line segment. C4The surface velocity of the shape. Useful to create 5 conveyor belts and players that move around. This 5 value is only used when calculating friction, not  collision. (default is zero) D0The friction coefficient of the shape according # to Coulumb friction model (i.e. 0.0 is frictionless,  iron on iron is around 1.0, and it could be greater  then 1.0). 5The amount of friction applied during a collision is 6 determined by multiplying the friction coefficient % of both shapes. (default is zero) E)The elasticity of the shape is such that 0.0 gives no bounce  while 1.0 give a "perfect" bounce. Note that due to  inaccuracies using 1.0 or greater is not recommended. 7The amount of elasticity applied during a collision is < calculated by multiplying the elasticity of both shapes.  (default is zero) :By default old-style elastic iterations are done when the  space step)s. This used to result in a not-so-good 8 simulation, but now this is the recommended setting. FALayers are similar to groups, but use a bitmask. For a collision @ to occur, two shapes must have at least one layer in common.  In other words, layer1 .&. layer2 should be non-zero.  (default is -1, meaning all bits set) 9Note that although this type may have more than 32 bits, > for portability you should only rely on the lower 32 bits. G8Groups are used to filter collisions between shapes. If 5 the group is zero, then it imposes no restriction = to the collisions. However, if the group is non-zero then < the shape will not collide with other shapes in the same % non-zero group. (default is zero) 9This is primarely used to create multi-body, multi-shape @ objects such as ragdolls. It may be thought as a lightweight 7 alternative to creating a callback that filters the  collisions. H8The collision type is used to determine which collision 2 callback will be called. Its actual value doesn' t have a > meaning for Chipmunk other than the correspondence between @ shapes and the collision pair functions you add. (default is  zero) I5There are three types of shapes that can be attached  to bodies: J+Polygons are the slowest of all shapes but 5 the most flexible. The list of vertices must form ) a convex hull with clockwise winding. 6 Note that if you want a non-convex polygon you may , add several convex polygons to the body. KL/A line segment is meant to be used as a static 6 shape. (It can be used with moving bodies, however 7 two line segments never generate collisions between  each other.) MNOP0A circle is the fastest collision type. It also  rolls smoothly. QRnewShape b type off! creates a new shape attached to  body b at offset off. Note that you have to , add the shape to a space otherwise it won' t generate  collisions. Sbody s+ is the body that this shape is associated . to. Useful especially in a space callback. TUVWXYZmomentForShape m s off+ is a convenience function that calculates # the moment of inertia for shape s with mass m and at a  offset off of the body's center. Uses [,  \ and ] internally. [momentForCircle m (ri,ro) off is the moment of inertia  of a circle of m mass, inner radius of ri, outer radius  of ro and at an offset off from the center of the body. \momentForSegment m p1 p2 is the moment of inertia of a  segment of mass m going from point p1 to point p2. ]momentForPoly m verts off is the moment of inertia of a  polygon of m mass, at offset off from the center of  the body and comprised of verts vertices. This is similar  to J- (and the same restrictions for the vertices  apply as well). Internal. For l = [x1,x2,...,xn],  pairs f l is  [f x1 x2, f x2 x3, ...,f xn x1]. ^shapePointQuery shape p returns True iff the point  in position p (in world's coordinates) lies within the  shape shape. _shapeSegmentQuery shape p1 p2 returns  Just (t,n) iff the  segment from p1 to p2 (in world's coordinates)  intersects with the shape shape. In that case, 0 <= t <=  15 indicates that one of the intersections is at point p1 +  (p2 - p1) `scale` t with normal n. `8The epsilon used in the algorithms below when necessary  to compare floats for "equality". a"Equality" under ` . That is, a .==. b  if  abs (a - b) < = epsilon. bO(n). isClockwise verts is True iff verts form  a clockwise polygon. cisLeft (p1,p2) vert is  LT if vert' is at the left of the line defined by (p1,p2).  EQ if vert is at the line (p1,p2).  GT otherwise. dO(n). isConvex verts is True iff vers form a convex  polygon. eO(1). intersects seg1 seg2 is the intersection between  the two segments seg1 and seg2. See >. fO(n). polyReduce delta verts removes from verts all  points that have less than delta distance ( in relation to the one preceding it. 1Note that a very small polygon may be completely "eaten" $ if all its vertices are within a delta radius from the  first. gO(n). polyCenter verts is the position in the center  of the polygon formed by verts. h O(n log n). convexHull verts is the convex hull of the  polygon defined by verts. The vertices of the convex 5 hulls are given in clockwise winding. The polygon  doesn't have to be simple. #Implemented using Graham scan, see   1http://cgm.cs.mcgill.ca/~beezer/cs507/3coins.html. 2Internal. Works like minimum but also returns the : list without it. The order of the list may be changed.  We have "fst (takeMinimum xs) == minimum xs and  .sort (uncurry (:) $ takeMinimum xs) == sort xs ,!>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh,!IPLJQMNOKRHTGUFVEWDXCYSZ[\]^_B>A@?`acbdefgh+>A@??@ABCDEFGHIPLJQMNOKJKLMNOPQRSTUVWXYZ[\]^_`abcdefghportable (needs FFI) provisionalfelipe.lessa@gmail.comAi6A simple motor that applies opposite impulses to each 2 body. The rate is used to compute the torque. jkRate. l3A rotary limit constraints the difference of angle  between two bodies. mnMinimum distance. oMaximum distance. pA ratchet constraint. qrPhase. s Ratchet. t#A damped rotary spring constraint. uv Rest angle. w Stiffness. x Damping. y3A simple damped spring. Generally this constraint  should be used instead of applyDampedSpring. z{First anchor. |Second anchor. }Rest length. ~ Stiffness.  Damping. 1A gear joint restricts the bodies movement to be ; coordinated as if they were attached like dented gears. Phase of the movement. Ratio between the gears. 3A groove joint attaches a point on the second body ! to a groove in the first one. Groove, in first body's coordinates. Pivot, in second body's coordinates. 0A pivot joint allows the bodies to pivot around  a single point. 5Or you may specify the joint as two anchors (on each  body'4s coordinates), removing the need having the bodies  already in place. First anchor. Second anchor. (You may specify the pivot point in world's coordinates 0 (so both bodies should be already in place). Pivot point in world's coordinates. 1A slide joint is similar to a pin joint, however , it has a minimum and a maximum distance. First anchor. Second anchor. Minimum distance. Maximum distance. 2A pin joint connects the bodies with a solid pin. 3 The anchor points are kept at a fixed distance. First anchor. Second anchor. newConstraint b1 b2 type_ connects the two bodies b1 and b2 = with a constraint of the given type. Note that you should  add the   to a space. The " type class is implemented by all @ constraint types to allow them to be manipulated by the same = framework while retaining type-safety, consequently it isn't  exported. redefine constr type_ redefines constr' s parameters 6 on-the-fly, allowing you to dynamically change the  constraint' s behaviour. Sets the constraint'&s bias coefficient. By default it is - equal to the last value set globally with  setConstraintBiasCoef, which initially is 0.1 ;Completely safe function that discards the constraint type ' (which is a phantom type). You can "remember" it again by  using unsafeRemember from the Unsafe module. Helper functions similar to .  !5 ijklmnopqrstuvwxyz{|}~5 yz{|}~tuvwxpqrslmnoijk3ijkjklmnomnopqrsqrstuvwxuvwxyz{|}~z{|}~portable (needs FFI) provisionalfelipe.lessa@gmail.com*"#$%&'()*+,-./01231The time stamp of the simulation, increased in 1  every time  is called. 2The gravity applied to the system. (default is 0) 5The number of elastic iterations to use when solving  constraints. If 0', then old-style elastic code is used.  (default is 0). ;This property is deprecated. You should no longer need to ) set any value other than the default. :The number of iterations to use when solving constraints.  (default is 10). A  is a ! container that, when added  to a space via , is added to the static  list of shapes. 7A static shape is one assumed not to move. If you move 4 a static shape after adding it, then you need to . 8You should not add the same shape as active and static, 5 nor should you add as active and try to remove as  static or vice versa. Creates a new, empty space. : Some of the memory resources associated with the space " must be manually freed through  when the   is no longer necessary.  freeSpace sp% frees some memory resources that can't 3 be automatically deallocated in a portable way.  The space sp! then becomes invalid and should  not be used (passing sp to any other function,  including ", results in undefined behavior). 45674Strict version of modifyIORef (otherwise the thunks , will keep referencing removed entities). 5The amount of viscous damping applied to the system.  (default is 1) 0Rehashes the shapes in the static spatial hash. 5 You only need to call this if you move one of the  static shapes. spaceQuery sp pos l g cb will call cb for every  shape that  Contains point pos (in world's coordinates).  Isn't of the same group as g.  Shares at least one layer with l. :The order in which the callback is called is unspecified. 9 However it is guaranteed that it will be called once, 9 and only once, for each of the shapes described above  (and never for those who aren't). spaceQueryList sp pos l g acts like  but  returns a list of !!s instead of calling a callback. ( This is just a convenience function.  step sp dt will update the space sp for a dt time  step. (It is highly recommended to use a fixed dt to increase ; the efficiency of contact persistence. Some tips may be  found in  4http://www.gaffer.org/game-physics/fix-your-timestep. portable (needs FFI) provisionalfelipe.lessa@gmail.com>89:;<=>?@ABCEInternal. Class of data types than can be given back as responses of  callbacks. DEF-Internal. Type of callback used by Chipmunk. 7A 4-tuple of callbacks, one for each kind of collision  event.  beginHandler and preSolveHandler should return a Bool  stating True) if the collision should be processed or False ) if the collision should be ignored. If  beginHandler returns  False0, the collision will be completely ignored. If  preSolveHandler returns False, then the collision will be " ignored only for this time step. You may also use Nothing# to use the default handlers. The 1 default is to process all collisions. That is, Handler  Nothing Nothing Nothing Nothing is the same as   0 Handler {beginHandler = Just (return True) 0 ,preSolveHandler = Just (return True) . ,postSolveHandler = Just (return ()) / ,separateHandler = Just (return ())} however using Nothing! is more efficient (the Chipmunk  library won'$t need to call a Haskell function). Note that assigning Nothing does not mean that the default  set with  will be called. That $ default is called only if there isn't a registered handler for  the given collision types. GHIJKL;Monad where callbacks are run. Within this monad you have = access to functions describing the collision. You can also  run any IO actions using M from  transformers package.  However, remember not to call  or   outside a PostStep callback -- use  instead, for example:   - postStep entity (currentSpaceRemove entity) The phantom type t. describes the type of callback, which can be  " When the collision first occurs. $ Before the collision is processed. # After the collision is processed.  When the collision ends.  After the step finishes. ?This phantom type is used to disallow invalid operations. For  example, you can'-t calculate the normal of a collision if you  are in a Separate( event, as there is no collision inside  this event. And you can'&t add a new post-step callback inside  a post-step callback. NO:Class of callbacks called from collision events. That is,  everything other than . %Class of collision events other than Separate . That is, @ collision events where the shapes are touching or overlapping. Phantom type used in PostStep callbacks. The phantom type t inside this PostStep phantom type is + the collision event that originated this PostStep callback.  For example, if you add a PostStep from a Begin handler,  then it will have type PostStep Begin. It is used by the  PostStep's instance of . PPhantom type used in Separate collision events. QPhantom type used in  PostSolve collision events. RPhantom type used in PreSolve collision events. SPhantom type used in Begin collision events. TUV#Shapes involved in this collision. W)Space from where these shapes come from. True5 iff this is the first step that the shapes touched. $The normal vector of the collision. X$Points where the collision occured. =The total impulse that was applied to resolve the collision. A Returns incorrect results if elastic iterations are being used. <The total impulse with friction that was applied to resolve 6 the collision. Returns incorrect results if elastic  iterations are being used. Add an entity to the current  from where this  callback was called. Don'!t add the same entity twice to a  space. You can add entities only in  callbacks. You should  not use liftIO and spaceAdd. "Remove an entity from the current  from where this  callback was called. Don't remove an entity that wasn't  added.  You can remove entities only in  callbacks. You  should not use liftIO and  spaceRemove.  postStep e cb registers a callback cb for the   phase on a given entity e. PostStep callbacks are called  once when the step( call finishes (and only on the current ? time step). This is the only kind of callbacks that may call   and . Each entity may have  at most one callback registered on it.  If a second callback cb2$ gets registered on the same entity  e, then callback cb will not be called, only cb2. @ This is not a bug, but a feature. This allows you to say, for  example, )postStep shape (currentSpaceRemove shape) every  time shape collides. Even if shape collided many times in @ a single time step, only the last callback would be called and  shape would be removed just once. 9Note that this function registers a callback from within 6 another callback, as this is the motivation of using  PostStep callbacks. As , registers a PostStep callback. Unlike  ), this function allows you to register a PostStep : callback from anywhere. Also, from this callback you won't be  in 2 monad. It is therefore unsafe and should not be 1 used unless you really know what you are doing. YInternal. Create a new Z for a given callback. [!Internal. Transform callbacks of \s to ]s. ^Internal. Create the Zs and give them to C land. :Defines a new default collision handler. This handler is  used whenever two shapes a and b collide such that no . other collision pair function was defined to a's and b's ! collision types. The default is Handler Nothing Nothing  Nothing Nothing. (addCollisionHandler sp (cta,ctb) handler defines handler ? as the handler to be used whenever a collision occurs between  a shape of collision type cta and another of collision type  ctb: (and vice versa). Any other callback already registered  to handle  (cta,ctb) will be removed. Note that you should not# add handlers to both combinations  of  (cta,ctb) and  (ctb,cta)!. Doing so results in undefined 3 behaviour. A good rule of thumb is to always use cta <=  ctb", although this is not necessary. #removeCollisionHandler sp (cta,ctb) removes the handler  that was registered to handle  (cta,ctb), if any (see  )). Any collisions that would be handled @ by the removed handler will be handled by the default one (see  ). Note that you should always use the same order that was  passed to . In other words, after  (addCollisionHandler sp (cta,ctb) handler you should use  #removeCollisionHandler sp (cta,ctb), and never  #removeCollisionHandler sp (ctb,cta) (note the swapped  tuple). =Although pointless, it is harmless to remove a callback that  was not added. portable (needs FFI) provisionalfelipe.lessa@gmail.com_`abc"unsafeShapeRedefine shape type off redefines shape to $ have new parameters described on type and to be at offset  off. Be careful, $you should not change the shape type. 5 For example, it is unsafe to change a circle shape' s radius, ? but it is an error to try to change a circle into a segment . or a polygon. Note also that these errors are not  checked , meaning !they will probably crash Chipmunk. 4Unsafe function that changes the constraint type to 2 anything. It is unsafe because you should call redefine = only on the same kind of constraint you created, and this ? function allows you to bypass the type system checks. Note % also that, unlike Chipmunk, we don't check at run-time that  redefine$ is being called on the right type!  portable (needs FFI) provisionalfelipe.lessa@gmail.com  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrrsttuvwwxyzz{|}~~(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeHipmunk-5.2.0.2Physics.Hipmunk.CommonPhysics.Hipmunk.SpacePhysics.Hipmunk.ConstraintPhysics.Hipmunk.ShapePhysics.Hipmunk.BodyPhysics.Hipmunk.CallbacksPhysics.Hipmunk.UnsafePhysics.Hipmunk.InternalPhysics.HipmunkPositionVectorBiasCoefDampingDistanceAngleTimeCpFloat initChipmunkinfinityresetShapeCountercontactPersistence collisionSlopbiasCoefconstraintBiasCoef fromAnglelen normalizescaletoAngledotcrossperpprojectrotateunrotateEntityspaceAdd spaceRemoveSpaceUnknown ConstraintShapeBodyTorqueAngVelForceVelocityMomentMassnewBodymassmomentanglepositionvelocity maxVelocityforceangVel maxAngVeltorqueslewupdateVelocityupdatePosition resetForces applyForceapplyOnlyForce applyImpulseapplyDampedSpring localToWorld worldToLocal IntersectionIntSegmtIntPoint IntNowhereSegment SurfaceVelFriction ElasticityLayersGroup CollisionType ShapeTypePolygonvertices LineSegmentstartend thicknessCircleradiusnewShapebody collisionTypegrouplayers elasticityfriction surfaceVelmomentForShapemomentForCirclemomentForSegment momentForPolyshapePointQueryshapeSegmentQueryepsilon.==. isClockwiseisLeftisConvex intersects polyReduce polyCenter convexHull SimpleMotorsimpleMotorRate RotaryLimit rotaryMinDist rotaryMaxDistRatchet ratchetPhaseratchetDampedRotarySpringdampedRotRestAngledampedRotStiffnessdampedRotDamping DampedSpring dampedAnchor1 dampedAnchor2dampedRestLengthdampedStiffness dampedDampingGear gearPhase gearRatioGroove groovePoints groovePivotPivotPivot2 pivotAnchor1 pivotAnchor2Pivot1pivotPosSlide slideAnchor1 slideAnchor2 slideMinDist slideMaxDistPin pinAnchor1 pinAnchor2 newConstraint redefineC setBiasCoefCforgetC TimeStampGravityElasticIterations Iterations StaticShapeStaticunStaticnewSpace freeSpace iterationselasticIterationsgravitydamping timeStampresizeStaticHashresizeActiveHash rehashStatic spaceQueryspaceQueryListstepCollisionHandlerHandler beginHandlerpreSolveHandlerpostSolveHandlerseparateHandlerCallback NotPostStep NotSeparatePostStepSeparate PostSolvePreSolveBeginshapesisFirstContactnormalpoints totalImpulsetotalImpulseWithFrictioncurrentSpaceAddcurrentSpaceRemovepostStepunsafePostStepsetDefaultCollisionHandleraddCollisionHandlerremoveCollisionHandlerunsafeShapeRedefineunsafeRememberCcp_constraint_bias_coef cp_bias_coefcp_collision_slopcp_contact_persistencecpResetShapeIdCountercpInitChipmunkbaseGHC.NumNumsignumerror'makeStateVarFromPtr ContactPtrContactctJnAccctJtAccctPosctNormalctDist ArbiterPtrArbiter entityPtrCollisionType_HandlerFunPtrs CallbacksCBs cbsDefault cbsHandlers cbsPostStepEntitiesSpacePtrPConstraintTypesizeinit_redefConstraintInit ConstraintPtrCShapePtrSBodyPtrB VectorPtrunBunSunCunP retriveShapefreeHandlerFunPtrswrBodyWorld2LocalwrBodyLocal2WorldwrApplyDampedSpringwrBodyApplyImpulsewrBodyApplyForcecpBodyUpdatePositionwrBodyUpdateVelocitycpBodySetAnglecpBodySetMoment cpBodySetMass cpBodyInitwrShapeSegmentQuerywrShapePointQuerycpShapeDestroywrPolyShapeInitwrSegmentShapeInitwrCircleShapeInitpairs takeMinimumwrSimpleMotorInitwrRotaryLimitJointInitwrRatchetJointInitwrDampedRotarySpringInitwrDampedSpringInitwrGrooveJointInitwrGearJointInitwrPivot2JointInitwrPivot1JointInitwrSlideJointInitwrPinJointInitwith1Foreign.Marshal.Utilswithwith2with3 cpSpaceStepwrSpacePointQuerymakePointQueryFunccpSpaceRehashStaticcpSpaceResizeActiveHashcpSpaceResizeStaticHashcpSpaceRemoveStaticShapecpSpaceAddStaticShapecpSpaceRemoveConstraintcpSpaceAddConstraintcpSpaceRemoveShapecpSpaceAddShapecpSpaceRemoveBodycpSpaceAddBodycpSpaceDestroy cpSpaceInitPointQueryFuncPtrPointQueryFuncfreeAllspaceAddHelperspaceRemoveHelper modifyIORef'cpSpaceRemoveCollisionHandlercpSpaceAddCollisionHandler!cpSpaceSetDefaultCollisionHandlermakeChipmunkCB_VoidmakeChipmunkCB_CIntcpSpaceAddPostStepCallbackmakeChipmunkPostStepCB!wrArbiterTotalImpulseWithFrictionwrArbiterTotalImpulsewrArbiterGetNormal HandlerAdderMakeChipmunkCBmakeChipmunkCB ChipmunkCBPtr ChipmunkCBChipmunkPostStepCBPtrChipmunkPostStepCB CallbackEnvCEceSpace ceArbitertransformers-0.2.2.0Control.Monad.IO.ClassliftIOCBunCBenv arbiterPtrspace arbVecFunc adaptCallbackGHC.PtrFunPtrasCIntghc-primGHC.BoolBoolForeign.C.TypesCInt addHandlerwrPolyShapeSetVertscpSegmentShapeSetRadiuswrSegmentShapeSetEndpointswrCircleShapeSetOffsetcpCircleShapeSetRadius