!l#[      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      SafechiphunkInternal helper function to convert list of storable elements to tuple of length and elements stored in memory and executes IO actions, cleaning up afterwards. Math helpers.SafechiphunkClamp f to be between min and maxchiphunkLinearly interpolate between f1 and f2chiphunkLinearly interpolate from f1 towards f2 by no more than d.chiphunkfchiphunkminchiphunkmaxchiphunkf1chiphunkf2chiphunkf1chiphunkf2chiphunkdBasic Chipmunk data types.None0FTUchiphunkCollision typechiphunk Pointer to  chiphunk0Type used for 23 affine transforms in Chipmunk.chiphunk Chipmunk s \ struct encapsulates a pair of colliding shapes and all of the data about their collision. \ is created when a collision starts, and persist until those shapes are no longer colliding."Why are they called arbiters? The short answer is that I kept using the word arbitrates  to describe the way that collisions were resolved and then I saw that Box2D actually called them arbiters way back in 2006 when I was looking at its solver. An arbiter is like a judge, a person that has authority to settle disputes between two people. It was a fun, fitting name and was shorter to type than CollisionPair which I had been using. It was originally meant to be a private internal structure only, but evolved to be useful from callbacks.chiphunkA constraint is something that describes how two bodies interact with each other. (how they constrain each other) Constraints can be simple joints that allow bodies to pivot around each other like the bones in your body, or they can be more abstract like the gear joint or motors.chiphunk,There are currently 3 collision shape types:Circles': Fastest and simplest collision shape. Line segmentsS: Meant mainly as a static shape. Can be beveled in order to give them a thickness.Convex polygons-: Slowest, but most flexible collision shape.YYou can add as many shapes to a body as you wish. That is why the two types are separate.Combining multiple shapes gives you the flexibility to make any object you want as well as providing different areas of the same object with different friction, elasticity or callback values.chiphunkSpaces in Chipmunk are the basic unit of simulation. You add rigid bodies, shapes, and constraints to the space and then step them all forward through time together.chiphunkiChipmunk supports three different types of bodies with unique behavioral and performance characteristics.chiphunk6Dynamic bodies are the default body type. They react to collisions, are affected by forces and gravity, and have a finite amount of mass. These are the type of bodies that you want the physics engine to simulate for you. Dynamic bodies interact with all types of bodies and can generate collision callbacks.chiphunkKinematic bodies are bodies that are controlled from your code instead of inside the physics engine. They arent affected by gravity and they have an infinite amount of mass so they don t react to collisions or forces with other bodies. Kinematic bodies are controlled by setting their velocity, which will cause them to move. Good examples of kinematic bodies might include things like moving platforms. Objects that are touching or jointed to a kinematic body are never allowed to fall asleep.chiphunkStatic bodies are bodies that never (or rarely) move. Using static bodies for things like terrain offers a big performance boost over other body types  because Chipmunk doesn t need to check for collisions between static objects and it never needs to update their collision information. Additionally, because static bodies don t move, Chipmunk knows it s safe to let objects that are touching or jointed to them fall asleep. Generally all of your level geometry will be attached to a static body except for things like moving platforms or doors. Every space provide a built-in static body for your convenience. Static bodies can be moved, but there is a performance penalty as the collision information is recalculated. There is no penalty for having multiple static bodies, and it can be useful for simplifying your code by allowing different parts of your static geometry to be initialized or moved separately.chiphunkRigid body somewhere in C code.chiphunkPointer to user data.chiphunkPointer to bounding box.chiphunkFSimple bounding box struct. Stored as left, bottom, right, top values.chiphunkPointer to vector.!chiphunk2D vector packed into a struct.chiphunk lifted to reader monad'  !"#$Shapes manipulationsNonechiphunk Pointer to %%chiphunk|Fast collision filtering type that is used to determine if two objects collide before calling collision or query callbacks.*chiphunkaThe rigid body the shape is attached to. Can only be set when the shape is not added to a space.+chiphunkBThe bounding box of the shape. Only guaranteed to be valid after 5 or  spaceStep is called. Moving a body that a shape is connected to does not update its bounding box. For shapes used for queries that aren t attached to bodies, you can also use 6.,chiphunk}A boolean value if this shape is a sensor or not. Sensors only call collision callbacks, and never generate real collisions.-chiphunkElasticity of the shape. A value of 0.0 gives no bounce, while a value of 1.0 will give a perfect  bounce. However due to inaccuracies in the simulation using 1.0 or greater is not recommended however.hThe elasticity for a collision is found by multiplying the elasticity of the individual shapes together..chiphunk`Friction coefficient. Chipmunk uses the Coulomb friction model, a value of 0.0 is frictionless.fThe friction for a collision is found by multiplying the friction of the individual shapes together. @http://www.roymech.co.uk/Useful_Tables/Tribology/co_of_frict.htmTable of friction coefficients./chiphunkThe surface velocity of the object. Useful for creating conveyor belts or players that move around. This value is only used when calculating friction, not resolving the collision.0chiphunkCollision type of this shape. | You can assign types to Chipmunk collision shapes that trigger callbacks when objects of certain types touch. See the callbacks section for more information.1chiphunkSThe collision filter for this shape. See Filtering Collisions for more information.2chiphunkThe  that shape has been added to.3chiphunkA user definable data pointer. If you set this to point at the game object the shapes is for, then you can access your game object from Chipmunk callbacks.4chiphunkDeallocates shape.5chiphunk Synchronizes shape with the body its attached to.6chiphunk+Sets the position and rotation of the shape7chiphunkCreate new circle-like shape.8chiphunk Create new segment-shaped shape.9chiphunkWhen you have a number of segment shapes that are all joined together, things can still collide with the cracks  between the segments. By setting the neighbor segment endpoints you can tell Chipmunk to avoid colliding with the inner parts of the crack.:chiphunkA convex hull will be calculated from the vertexes automatically. The polygon shape will be created with a radius, increasing the size of the shape.;chiphunkAlternate constructors for poly shapes. This version does not apply a transform nor does it create a convex hull. Verticies must be provided with a counter-clockwise winding.<chiphunk"Createa box shape from dimensions.=chiphunkAlternative to < using  to set size.5chiphunkshape6chiphunk shape7chiphunk!The body to attach the circle to.chiphunkRadius of the circle.chiphunkCOffset from the body's center of gravity in body local coordinates.8chiphunk"The body to attach the segment to.chiphunk One endpoint.chiphunkAnother endpoint.chiphunkThe thickness of the segment.:chiphunkThe body to attach the poly to.chiphunk The array of ! structs.chiphunk3The transform that will be applied to every vertex.chiphunkRadius.<chiphunkThe body to attach tochiphunk Box widthchiphunk Box heightchiphunkRadius=chiphunkThe body to attach tochiphunk Shape sizechiphunkRadius%&'()*+,-./0123456789:;<=9Helpers functions mostly for estimating certain measures.None >chiphunk5Calculate the moment of inertia for a hollow circle, r1 and r2g are the inner and outer diameters in no particular order. (A solid circle has an inner diameter of 0)?chiphunkBCalculate the moment of inertia for a line segment. The endpoints a and b are relative to the body.@chiphunkCalculate the moment of inertia for a solid polygon shape assuming its center of gravity is at its centroid. The offset is added to each vertex.AchiphunkECalculate the moment of inertia for a solid box centered on the body.BchiphunkArea of a hollow circle.CchiphunkBArea of a beveled segment. (Will always be zero if radius is zero)Dchiphunk`Signed area of a polygon shape. Returns a negative number for polygons with a clockwise winding.Echiphunk%Calculate the centroid for a polygon.Fchiphunk3Calculate the convex hull of a given set of points.>chiphunkMasschiphunkr1chiphunkr2chiphunkOffset?chiphunkMasschiphunkachiphunkbchiphunk Thickness@chiphunkMasschiphunkVertexeschiphunkOffsetchiphunk ThicknessAchiphunkMasschiphunkWidthchiphunkHeightBchiphunkr1chiphunkr2CchiphunkOne endchiphunk Other endchiphunk ThicknessDchiphunkVertexeschiphunk ThicknessFchiphunkSet of vertexeschiphunk^Allowed amount to shrink the hull when simplifying it. A tolerance of 0 creates an exact hull.chiphunk=Second element is index of first output vertex in input list. >?@ABCDEFDealing with joints/constraintsNone1Gchiphunk(The first body constraint is attached toHchiphunk)The second body constraint is attached toIchiphunk^The maximum force that the constraint can use to act on the two bodies. Defaults to INFINITY.JchiphunkThe percentage of joint error that remains unfixed after a second. This works exactly the same as the collision bias property of a space, but applies to fixing error (stretching) of joints instead of overlapping collisions.Kchiphunk`Get the maximum speed at which the constraint can apply error correction. Defaults to INFINITY.LchiphunkThe # that constraint has been added to.MchiphunkConstraints can be used for filtering collisions too. When two bodies collide, Chipmunk ignores the collisions if this property is set to False> on any constraint that connects the two bodies. Defaults to True.gThis can be used to create a chain that self collides, but adjacent links in the chain do not collide.NchiphunkA user definable data pointer. Use this pointer to get a reference to the game object that owns this constraint from callbacks.OchiphunkoThe most recent impulse that constraint applied. To convert this to a force, divide by the timestep passed to  spaceStep~. You can use this to implement breakable joints to check if the force they attempted to apply exceeded a certain threshold.PchiphunkaFree function is shared by all joint types. Allocation functions are specific to each joint type.QchiphunkConnect two bodies via anchor points on those bodies. The distance between the two anchor points is measured when the joint is created. If you want to set a specific distance, use the setter function to override it.RchiphunkAnchor on first body.SchiphunkAnchor on second body.Tchiphunk/Desired distance the joint will try to enforce.UchiphunkIConnect two bodies via anchor points forcing distance to remain in range.VchiphunkAnchor on first body.WchiphunkAnchor on second body.Xchiphunk3The minimum distance the joint will try to enforce.Ychiphunk3The maximum distance the joint will try to enforce.Zchiphunk}Because the pivot location is given in world coordinates, you must have the bodies moved into the correct positions already.[chiphunkAlternatively you can specify the joint based on a pair of anchor points, but make sure you have the bodies in the right place as the joint will fix itself as soon as you start simulating the space.\chiphunkAnchor on first body.]chiphunkAnchor on second body.^chiphunkfPivot is attached to groove on first body and to anchor on the second. All coordinates are body local._chiphunk)First endpoint of groove (on first body).`chiphunk*Second endpoint of groove (on first body).achiphunkAnchor on second body.bchiphunk Defined much like a slide joint.cchiphunkAnchor on first body.dchiphunkAnchor on second body.echiphunk0Desired distance the spring will try to enforce.fchiphunkSpring stiffnessgchiphunkSpring dampinghchiphunk*Create new damped rotary spring constraintichiphunk<Set desired angle in radians the spring will try to enforce.jchiphunkSpring stiffness.kchiphunkSpring damping.lchiphunk"Create new rotation limiting jointmchiphunk7Minimum angle in radians the joint will try to enforce.nchiphunk7Maximum angle in radians the joint will try to enforce.ochiphunk(Allocate and initialize a ratchet joint.pchiphunk'The angle of the current ratchet tooth.qchiphunk The phase offset of the ratchet.rchiphunk%The angular distance of each ratchet.schiphunk%Allocate and initialize a gear joint.tchiphunkPhase offset of the ratchet.uchiphunkRatio of the ratchetvchiphunk'Allocate and initialize a simple motor.wchiphunkRatio of angular velocities. QchiphunkFirst body to connectchiphunkSecond body to connectchiphunk First anchorchiphunk Second anchorUchiphunkFirst body to connectchiphunkSecond body to connectchiphunk First anchorchiphunk Second anchorchiphunkMinimum allowed distancechiphunkMaximum allowed distanceZchiphunkFirst body to connectchiphunkSecond body to connectchiphunk+Point in the world coordinates of the pivot[chiphunkFirst body to connectchiphunkSecond body to connectchiphunkAnchor on first bodychiphunkAnchor on second body^chiphunkFirst body to connectchiphunkSecond body to connectchiphunk(First endpoint of groove (on first body)chiphunk)Second endpoint of groove (on first body)chiphunkAnchor (on second body)bchiphunkFirst body to connectchiphunkSecond body to connectchiphunk First anchorchiphunk Second anchorchiphunkDistance the spring wants to bechiphunkSpring constant ( .http://en.wikipedia.org/wiki/Young%27s_modulusYoung's modulus)chiphunk&How soft to make damping of the springhchiphunkFirst body to connectchiphunkSecond body to connectchiphunk6Relative angle in radians that the bodies want to havechiphunkSpring constant (stiffness)chiphunkSpring dampinglchiphunkFirst body to connectchiphunkSecond body to connectchiphunk/Minimum angle in radians the joint will enforcechiphunk/Maximum angle in radians the joint will enforceochiphunkFirst body to connectchiphunkSecond body to connectchiphunkEThe initial offset to use when deciding where the ratchet angles are.chiphunkThe distance between clicks schiphunkFirst body to connectchiphunkSecond body to connectchiphunk-The initial angular offset of the two bodies.chiphunk Ratio measures in absolute termsvchiphunkFirst body to connectchiphunkSecond body to connectchiphunk&The desired relative angular velocity.2GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwCollision handler definitionNoneBxchiphunk+Function type used for postStep callbacks. space/ is the space the callback was registered on, obj3 is the pointer value you supplied as the key, and dataH is a user definable pointer you can use to pass in as a context value.ychiphunkPointer to collision handlerzchiphunkDThis collision handler processes collisions between objects of type typeA and typeBo. Fill the desired collision callback functions- they are documented above. A user definable context pointer userDatae is included for your convenience. This pointer is provided as an argument in each callback function.qA collision handler is a set of 4 function callbacks for the different collision events that Chipmunk recognizes.|chiphunktypeA}chiphunktypeB~chiphunkYTwo shapes just started touching for the first time this step. Return true from the callback to process the collision normally or false to cause Chipmunk to ignore the collision entirely. If you return false, the preSolve and postSolve callbacks will never be run, but you will still recieve a separate event when the shapes stop overlapping.chiphunkTwo shapes are touching during this step. Return false from the callback to make Chipmunk ignore the collision this step or true to process it normally. Additionally, you may override collision values using  ,   or  J to provide custom friction, elasticity, or surface velocity values. See  for more info.chiphunkTwo shapes are touching and their collision response has been processed. You can retrieve the collision impulse or kinetic energy at this time if you want to use it to calculate sound volumes or damage amounts. See  for more info.chiphunkTwo shapes have just stopped touching for the first time this step. To ensure that begin/separate are always called in balanced pairs, it will also be called when removing a shape while its in contact with something or when deallocating the space.chiphunkuserDatachiphunkCollision callbackchiphunk'Make callback. Need to free afterwards.chiphunk'Make callback. Need to free afterwards.chiphunkAdd a z for specific collision type pair or return the existing handler for the type pair. Whenever shapes with collision types (cpShape.collision_type) a and b collide, this handler will be used to process the collision events. When a new collision handler is created, the callbacks will all be set to builtin callbacks that perform the default behavior (call the wildcard handlers, and accept all collisions).chiphunkAdd a wildcard collision handler for given collision type. This handler will be used any time an object with this type collides with another object, regardless of its type. A good example is a projectile that should be destroyed the first time it hits anything. There may be a specific collision handler and two wildcard handlers. It s up to the specific handler to decide if and when to call the wildcard handlers and what to do with their return values. (See arbiterCallWildcard* below) When a new wildcard handler is created, the callbacks will all be set to builtin callbacks that perform the default behavior. (accept all collisions in begin and preSolve, or do nothing for postSolve and separate.chiphunk Return a reference to the default collision handler or that is used to process all collisions that don t have a more specific handler. The default behavior for each of the callbacks is to call the wildcard handlers, ANDing their return values together if applicable.chiphunk5Use this helper function to modify collision handler. tspaceAddCollisionHandler s t1 t2 >>= flip modifyColliionHandler (ch -> pure ch {chSeparateFunc = separateCollback}) chiphunkAdd func to be called before  spaceStep returns. key and data^ will be passed to your function. Only the first callback registered for any unique value of key will be recorded. It returns " if the callback is scheduled and $ when the key has already been used.nThe behavior of adding a postStep callback from outside of a collision handler or query callback is undefined.xchiphunkspacechiphunkobjchiphunkdatachiphunkachiphunkbchiphunktypechiphunkspacechiphunkfuncchiphunkkeychiphunkdataxyz{|}~ (Utilities for working with bounding box.NoneZchiphunkConvenience constructor for  structs.chiphunk%Convenience constructor for making a 7 fitting with a center point and half width and height.chiphunk%Convenience constructor for making a  fitting a circle at position p with radius r.chiphunk-Returns true if the bounding boxes intersect.chiphunkReturns true if bb completely contains other.chiphunkReturns true if bb contains v.chiphunk3Return the minimal bounding box that contains both a and b.chiphunk3Return the minimal bounding box that contains both bb and v.chiphunkReturn the center of bb.chiphunkReturn the area of bb.chiphunkMerges a and b2 then returns the area of the merged bounding box.chiphunk1Returns the fraction along the segment query the , is hit. Returns INFINITY if it doesn t hit.chiphunk1Returns true if the segment defined by endpoints a and b intersect bb.chiphunkReturns a copy of v clamped to the bounding box bb.chiphunkReturns a copy of v wrapped to the bounding box bb. chiphunk Center pointchiphunk Half widthchiphunk Half heightchiphunkpchiphunkrchiphunkbbchiphunkotherchiphunkbbchiphunkvchiphunkachiphunkbchiphunkbbchiphunkvchiphunkbbchiphunkbbchiphunkachiphunkbchiphunkBoxchiphunkOne segment endchiphunkOther segment endchiphunkbbchiphunkachiphunkbchiphunkbbchiphunkvchiphunkbbchiphunkv  NonechiphunkThe calculated elasticity for this collision pair. Setting the value in a preSolve() callback will override the value calculated by the space. The default calculation multiplies the elasticity of the two shapes together.chiphunkThe calculated friction for this collision pair. Setting the value in a preSolve() callback will override the value calculated by the space. The default calculation multiplies the friction of the two shapes together.chiphunknThe calculated surface velocity for this collision pair. Setting the value in a preSolve() callback will override the value calculated by the space. The default calculation subtracts the surface velocity of the second shape from the first and then projects that onto the tangent of the collision. This is so that only friction is affected by default calculation.Using a custom calculation, you can make something that responds like a pinball bumper, or where the surface velocity is dependent on the location of the contact point.chiphunkxA user definable context pointer. The value will persist until just after the separate callback is called for the pair.Note: If you need to clean up this pointer, you should implement the separate callback to do it. Also be careful when destroying the space as there may be active collisions still. In order to trigger the separate callbacks and clean up your data, you ll need to remove all the shapes from the space before disposing of it. This is something I d suggest doing anyway. See ChipmunkDemo.c:ChipmunkDemoFreeSpaceChildren() for an example of how to do it easily.chiphunkwThe number of contacts tracked by this arbiter. For the forseeable future, the maximum number of contacts will be two.chiphunk?Collision normal in a specific point tracked by this collision.chiphunk2Collision point of a specific point on first body.chiphunk3Collision point of a specific point on second body.chiphunk'Penetration depth of a collision point.chiphunk%Returns true if this is the first step the two shapes started touching. This can be useful for sound effects for instance. If its the first frame for a certain collision, check the energy of the collision in a postStep callbock and use that to determine the volume of a sound effect to play.chiphunkReturns Q during a separate callback if the callback was invoked due to an object removal.chiphunkThe colliding shapes in the order that they were defined in the collision handler associated with this arbiter. If you defined the handler as cpSpaceAddCollisionHandler(space, 1, 2, ...), you you will find that a->collision_type == 1 and b->collision_type == 2.chiphunkThe colliding bodies in the order that they were defined in the collision handler associated with this arbiter. If you defined the handler as cpSpaceAddCollisionHandler(space, 1, 2, ...), you you will find that a->collision_type == 1 and b->collision_type == 2.chiphunk+Run begin wildcard callback for first body.chiphunk,Run begin wildcard callback for second body.chiphunk.Run preSolve wildcard callback for first body.chiphunk/Run preSolve wildcard callback for second body.chiphunk/Run postSolve wildcard callback for first body.chiphunk0Run postSolve wildcard callback for second body.chiphunk.Run separate wildcard callback for first body.chiphunk/Run separate wildcard callback for second body.2D vector manipulations.None=chiphunkDConvenience constructor for creating new cpVect structs. Alias for !chiphunkConstant for the zero vector. Alias for chiphunkSCheck if two vectors are equal. (Be careful when comparing floating point numbers!) Alias for .chiphunkAdd two vectors. Alias for .chiphunkSubtract two vectors. Alias for  .chiphunkNegate a vector. Alias for !.chiphunkScalar multiplication. Alias for ".chiphunkVector dot product. Alias for #.chiphunk2D vector cross product analog. The cross product of 2D vectors results in a 3D vector with only a z component. This function returns the value along the z-axis.chiphunk4Returns a perpendicular vector. (90 degree rotation) Alias for $.chiphunk5Returns a perpendicular vector. (-90 degree rotation)chiphunk!Returns the vector projection of v1 onto v2. Alias for %.chiphunk&Uses complex multiplication to rotate v1 by v2. Scaling will occur if v1 is not a unit vector.chiphunk Inverse of .chiphunkReturns the length of v. Alias for &.chiphunkReturns the squared length of v. Faster than ' when you only need to compare lengths. Alias for '.chiphunkLinearly interpolate between v1 and v2. Alias for (.chiphunkLinearly interpolate between v1 towards v2 by distance d.chiphunk1Spherical linearly interpolate between v1 and v2.chiphunk'Spherical linearly interpolate between v1 towards v2 by no more than angle a in radians.chiphunkReturns a normalized copy of v . As a special case, it returns  when called on . Alias for ).chiphunkClamp v to length len.chiphunkReturns the distance between v1 and v2.chiphunk%Returns the squared distance between v1 and v2. Faster than ) when you only need to compare distances.chiphunk%Returns true if the distance between v1 and v2 is less than dist.chiphunk@Returns the unit length vector for the given angle (in radians).chiphunkReturns the angular direction v is pointing in (in radians). chiphunkv1chiphunkv2chiphunkv1chiphunkv2chiphunkv1chiphunkv2chiphunkv1chiphunkv2chiphunkdchiphunkv1chiphunkv2chiphunkv1chiphunkv2chiphunkachiphunkvchiphunklenchiphunkv1chiphunkv2chiphunkv1chiphunkv2chiphunkv1chiphunkv2chiphunkdistchiphunkv!"#$Manipulate spaceNone!chiphunk2Type of callback which can be used to iterate all s in a .chiphunk2Type of callback which can be used to iterate all s in a .chiphunk2Type of callback which can be used to iterate all s in a .chiphunklIterations allow you to control the accuracy of the solver. Defaults to 10. See above for more information.chiphunk1Global gravity applied to the space. Defaults to . Can be overridden on a per body basis by writing custom integration functions. Changing the gravity will activate all sleeping bodies in the space.chiphunkAmount of simple damping to apply to the space. A value of 0.9 means that each body will lose 10% of its velocity per second. Defaults to 1. Like gravity, it can be overridden on a per body basis.chiphunkSpeed threshold for a body to be considered idle. The default value of 0 means the space estimates a good threshold based on gravity.chiphunk~Time a group of bodies must remain idle in order to fall asleep. The default value of INFINITY disables the sleeping feature.chiphunkAmount of overlap between shapes that is allowed. To improve stability, set this as high as you can without noticable overlapping. It defaults to 0.1.chiphunkTChipmunk allows fast moving objects to overlap, then fixes the overlap over time. Overlapping objects are unavoidable even if swept collisions are supported, and this is an efficient and stable way to deal with overlapping objects. The bias value controls what percentage of overlap remains unfixed after a second and defaults to ~0.2%.aValid values are in the range from 0 to 1, but using 0 is not recommended for stability reasons.#The default value is calculated as (1.0 - 0.1) ^ 60Q meaning that Chipmunk attempts to correct 10% of error ever 1/60th of a second.Note5: Very very few games will need to change this value.chiphunkThe number of frames the space keeps collision solutions around for. Helps prevent jittering contacts from getting worse. This defaults to 3 and very very very few games will need to change this value.chiphunk+The current (if you are in a callback from  ) or most recent (outside of a  call) timestep.chiphunkReturns true when you cannot add/remove objects from the space. In particular, spaces are locked when in a collision callback. Instead, run your code in a post-step callback instead.chiphunkA user definable data pointer. It is often useful to point this at the gamestate object or scene management object that owns the space.chiphunkA dedicated static body for the space. You don t have to use it, but because its memory is managed automatically with the space its very convenient. You can set its user data pointer to something helpful if you want for callbacks.chiphunk&Standard Chipmunk allocation function.chiphunk(Standard Chipmunk deallocation function.chiphunkAdd shape to the space.chiphunkAdd body to the space.chiphunkAdd constraint to the space.chiphunkRemove shape from the space.chiphunkRemove body from the space.chiphunk!Remove constraint from the space.chiphunk(Check if shape is attached to the space.chiphunk'Check if body is attached to the space.chiphunk-Check if constraint is attached to the space.chiphunkReindex a specific shape.chiphunk*Reindex all the shapes for a certain body.chiphunkUReindex all static shapes. Generally updating only the shapes that changed is faster.chiphunkCall func for each body in the space also passing along your datas pointer. Sleeping bodies are included, but static and kinematic bodies are not as they aren t added to the space.chiphunkCall func for each shape in the space also passing along your data3 pointer. Sleeping and static shapes are included.chiphunkPCall func for each constraint in the space also passing along your data pointer.chiphunkUpdate the space for the given time step. Using a fixed time step is highly recommended. Doing so can greatly increase the quality of the simulation. The easiest way to do constant timesteps is to simple step forward by 1/60th of a second (or whatever your target framerate is) for each frame regardless of how long it took to render. This works fine for many games, but a better way to do it is to separate your physics timestep and rendering.chiphunkspacechiphunkfuncchiphunkdatachiphunkspacechiphunkfuncchiphunkdatachiphunkspacechiphunkfuncchiphunkdata"Rigid bodies manipulationsNoneQz%chiphunk2Type of callback which can be used to iterate all s in a .chiphunk2Type of callback which can be used to iterate all s in a .chiphunk2Type of callback which can be used to iterate all s in a .chiphunkCreates body of type .chiphunkCreate body of type .chiphunkCreate body of type .chiphunknBe careful not to free a body before any shapes or constraints attached to it have been removed from a space.*chiphunk4Get the type of a body (dynamic, kinematic, static).chiphunk8Type of a body (dynamic, kinematic, static). When changing an body to a dynamic body, the mass and moment of inertia are recalculated from the shapes added to the body. Custom calculated moments of inertia are not preseved when changing types. This function cannot be called directly in a collision callback.chiphunkMass of the body.chiphunkMoment of inertia (MoI or sometimes just moment) of the body. The moment is like the rotational mass of a body. See below for function to help calculate the moment.chiphunkLPosition of the body. When changing the position you may also want to call spaceReindexShapesForBodyv to update the collision detection information for the attached shapes if plan to make any queries against the space.chiphunkLocation of the center of gravity in body local coordinates. The default value is (0, 0), meaning the center of gravity is the same as the position of the body.chiphunk5Linear velocity of the center of gravity of the body.chiphunk]Force applied to the center of gravity of the body. This value is reset for every time step.chiphunk[Set rotation of the body in radians. When changing the rotation you may also want to call spaceReindexShapesForBody to update the collision detection information for the attached shapes if you plan to make any queries against the space. A body rotates around its center of gravity, not its position.chiphunk3Angular velocity of the body in radians per second.chiphunkDTorque applied to the body. This value is reset for every time step.chiphunk4The rotation vector for the body. Can be used with  or  to perform fast rotations.chiphunkThe  that body has been added to.chiphunknUser data pointer. Use this pointer to get a reference to the game object that owns this body from callbacks.chiphunk?Convert from body local coordinates to world space coordinates.chiphunk?Convert from world space coordinates to body local coordinates.chiphunk=Absolute velocity of the rigid body at the given world point.+chiphunkBAbsolute velocity of the rigid body at the given body local point.chiphunkAdd the force to body as if applied from the world point.chiphunkAdd the local force to body# as if applied from the body local point.chiphunkAdd the impulse to body as if applied from the world  point.chiphunkAdd the local impulse to body# as if applied from the body local point.chiphunk!Returns true if body is sleeping.chiphunkaReset the idle timer on a body. If it was sleeping, wake it and any other bodies it was touching.chiphunkbForces a body to fall asleep immediately even if it s in midair. Cannot be called from a callback. chiphunkActivates all bodies touching body. If filter is not $, then only bodies touching through filter will be awoken. chiphunkWhen objects in Chipmunk sleep, they sleep as a group of all objects that are touching or jointed together. When an object is woken up, all of the objects in its group are woken up.  E allows you group sleeping objects together. It acts identically to  if you pass  as group; by starting a new group. If you pass a sleeping body for group, body will be awoken when group is awoken. You can use this to initialize levels and start stacks of objects in a pre-sleeping state. chiphunkCall func) once for each shape that is attached to body and added to a space. dataW is passed along as a context value. It is safe to remove shapes using these callbacks. chiphunkCall func. once for each constraint that is attached to body and added to a space. data[ is passed along as a context value. It is safe to remove constraints using thes callbacks. chiphunk$This one is more interesting. Calls func# once for each collision pair that body is involved in. Calling %'arbiterGetBodies'/'arbiterGetShapes' will return the body or shape for body as the first argument. You can use this to check all sorts of collision information for a body like if it s touching the ground, another particular object, how much collision force is being applied to an object, etc.VSensor shapes and arbiters that have been rejected by a collision handler callback or  arbiterIgnore' are not tracked by the contact graph. chiphunk+Mass of the body. Guessing is usually fine.chiphunkMoment of inertia of the body. Guessing a moment of inertia can lead to a very poor simulation so it s recommended to use Chipmunk s moment calculations to estimate the moment for you.chiphunkbodychiphunkforcechiphunkpointchiphunkbodychiphunkforcechiphunkpointchiphunkbodychiphunkimpulsechiphunkpointchiphunkbodychiphunkimpulsechiphunkpoint chiphunkbodychiphunkfilter chiphunkbodychiphunkgroup chiphunkbodychiphunkfuncchiphunkdata chiphunkbodychiphunkfuncchiphunkdata chiphunkbodychiphunkfuncchiphunkdata)+     8Low-level Haskell bindings to Chipmunk2D physics libraryNoneS7  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !"#$ >?@ABCD     *+,-./0%&'()123456789:;<=EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwz{|}~yx , !"#$%&'()*+,-.//012344567789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !%&'(-"#$%#$&'()#*+'(,'(-'(.'/0'/1'23'/4'/5'/6'/7'/89:;'chiphunk-0.1.0.0-8L4qXJ3fYCg9FuEcivYqvd Chiphunk.LowChiphunk.Low.InternalChiphunk.Low.MathChiphunk.Low.TypesChiphunk.Low.ShapeChiphunk.Low.HelperChiphunk.Low.ConstraintChiphunk.Low.CallbackChiphunk.Low.ArbiterarbiterFrictionarbiterRestitutionarbiterSurfaceVelocityChiphunk.Low.BBChiphunk.Low.VectChiphunk.Low.SpaceChiphunk.Low.Body'StateVar-1.1.1.1-5zTmcSrVbN7I4w3ZMeZaTb Data.StateVar$= HasSetterget HasGetterbaseGHC.PtrnullPtrfClampfLerp fLerpConst CollisionType TransformtAtBtCtDtTxtTyArbiter ConstraintShapeSpaceBodyTypeBodyTypeDynamicBodyTypeKimenaticBodyTypeStaticBodyDataPtrBBbbLbbBbbRbbTVectvXvY ShapeFiltersfGroup sfCategoriessfMask shapeBodyshapeBB shapeSensorshapeElasticity shapeFrictionshapeSurfaceVelocityshapeCollisionType shapeFilter shapeSpace shapeUserData shapeFree shapeCacheBB shapeUpdatecircleShapeNewsegmentShapeNewsegmentShapeNeighbors polyShapeNewpolyShapeNewRaw boxShapeNew boxShapeNew2momentForCirclemomentForSegment momentForPoly momentForBox areaForCircleareaForSegment areaForPolycentroidForPoly convexHullconstraintBodyAconstraintBodyBconstraintMaxForceconstraintErrorBiasconstraintMaxBiasconstraintSpaceconstraintCollideBodiesconstraintUserDataconstraintImpulseconstraintFree pinJointNewpinJointAnchorApinJointAnchorB pinJointDist slideJointNewslideJointAnchorAslideJointAnchorB slideJointMin slideJointMax pivotJointNewpivotJointNew2pivotJointAnchorApivotJointAnchorBgrooveJointNewgrooveJointGrooveAgrooveJointGrooveBgrooveJointAnchorBdampedSpringNewdampedSpringAnchorAdampedSpringAnchorBdampedSpringRestLengthdampedSpringStiffnessdampedSpringDampingdampedRotarySpringNewdampedRotarySpringRestAngledampedRotarySpringStiffnessdampedRotarySpringDampingrotaryLimitJointNewrotaryLimitJointMinrotaryLimitJointMaxratchetJointNewratchetJointAngleratchetJointPhaseratchetJointRatchet gearJointNewgearJointPhasegearJointRatiosimpleMotorNewsimpleMotorRate PostStepFuncCollisionHandlerPtrCollisionHandlerchTypeAchTypeB chBeginFuncchPreSolveFuncchPostSolveFuncchSeparateFunc cpUserDataCollisionCallback mkCallback mkCallbackBspaceAddCollisionHandlerspaceAddWildcardHandlerspaceAddDefaultCollisionHandlermodifyCollisionHandlerspaceAddPostStepCallbackbbNewbbNewForExtentsbbNewForCircle bbIntersects bbContainsBBbbContainsVectbbMergebbExpandbbCenterbbArea bbMergedAreabbSegmentQuerybbIntersectsSegment bbClampVect bbWrapVectarbiterUserData arbiterCount arbiterNormal arbiterPointA arbiterPointB arbiterDeptharbiterIsFirstContactarbiterIsRemoval arbiterShapes arbiterBodiesarbiterCallWildcardBeginAarbiterCallWildcardBeginBarbiterCallWildcardPreSolveAarbiterCallWildcardPreSolveBarbiterCallWildcardPostSolveAarbiterCallWildcardPostSolveBarbiterCallWildcardSeparateAarbiterCallWildcardSeparateBcpvvZerovEqlvAddvSubvNegvMultvDotvCrossvPerpvRPerpvProjectvRotate vUnRotatevLength vLengthSqvLerp vLerpConstvSLerp vSLerpConst vNormalizevClampvDistvDistSqvNear vForAnglevToAngleSpaceConstraintIteratorFuncSpaceShapeIteratorFuncSpaceBodyIteratorFuncspaceIterations spaceGravity spaceDampingspaceIdleSpeedThresholdspaceSleepTimeThresholdspaceCollisionSlopspaceCollisionBiasspaceCollisionPersistencespaceCurrentTimeStep spaceIsLocked spaceUserDataspaceStaticBodyspaceNew spaceFree spaceAddShape spaceAddBodyspaceAddConstraintspaceRemoveShapespaceRemoveBodyspaceRemoveConstraintspaceContainsShapespaceContainsBodyspaceContainsConstraintspaceReindexShapespaceReindexShapesForBodyspaceReindexStatic spaceEachBodyspaceEachShapespaceEachConstraint spaceStepBodyArbiterIteratorFuncBodyConstraintIteratorFuncBodyShapeIteratorFuncbodyNewbodyNewKinematic bodyNewStaticbodyFreebodyTypebodyMass bodyMoment bodyPositionbodyCenterOfGravity bodyVelocity bodyForce bodyAnglebodyAngularVelocity bodyTorque bodyRotation bodySpace bodyUserDatabodyLocalToWorldbodyWorldToLocalbodyVelocityAtWorldPointbodyApplyForceAtWorldPointbodyApplyForceAtLocalPointbodyApplyImpulseAtWorldPointbodyApplyImpulseAtLocalPointbodyIsSleeping bodyActivate bodySleepbodyActivateStaticbodySleepWithGroup bodyEachShapebodyEachConstraintbodyEachArbiterwithList TransformPtrBBPtrVectPtr mkStateVar makeStateVarCPBoolShapeFilterPtrghc-prim GHC.TypesTrueFalse(vector-space-0.13-GUj35p8MCAg18SrOU8KiEzData.AdditiveGroupzeroV GHC.Classes==^+^^-^negateVData.VectorSpace^*<.> Data.Crosscross2project magnitude magnitudeSqlerp normalized cpBodyGetTypebodyVelocityAtLocalPoint