h$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe-InferredchiphunkInternal 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. Safe-Inferred^chiphunkClamp 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.None28 chiphunkCollision 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 segments: Meant mainly as a static shape. Can be beveled in order to give them a thickness.Convex polygons-: Slowest, but most flexible collision shape.You 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.chiphunkChipmunk supports three different types of bodies with unique behavioral and performance characteristics.chiphunkDynamic 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.chiphunkSimple bounding box struct. Stored as left, bottom, right, top values.chiphunkPointer to vector.!chiphunk2D vector packed into a struct.chiphunk lifted to reader monad1  !"#$Shapes manipulationsNone'chiphunk Pointer to %%chiphunkFast collision filtering type that is used to determine if two objects collide before calling collision or query callbacks.*chiphunkThe rigid body the shape is attached to. Can only be set when the shape is not added to a space.+chiphunkThe bounding box of the shape. Only guaranteed to be valid after 7 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 8.,chiphunkA 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.The elasticity for a collision is found by multiplying the elasticity of the individual shapes together..chiphunkFriction coefficient. Chipmunk uses the Coulomb friction model, a value of 0.0 is frictionless.The 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.3chiphunkThe collision filter for this shape. See Filtering Collisions for more information.4chiphunkThe  that shape has been added to.5chiphunkA 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.6chiphunkDeallocates shape.7chiphunk Synchronizes shape with the body its attached to.8chiphunk+Sets the position and rotation of the shape9chiphunkCreate new circle-like shape.:chiphunk Create new segment-shaped shape.;chiphunkWhen 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.7chiphunkshape8chiphunk shape9chiphunk!The body to attach the circle to.chiphunkRadius of the circle.chiphunkOffset from the body's center of gravity in body local coordinates.:chiphunk"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 r2 are the inner and outer diameters in no particular order. (A solid circle has an inner diameter of 0)AchiphunkCalculate the moment of inertia for a line segment. The endpoints a and b are relative to the body.BchiphunkCalculate 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.CchiphunkCalculate the moment of inertia for a solid box centered on the body.DchiphunkArea of a hollow circle.EchiphunkArea of a beveled segment. (Will always be zero if radius is zero)FchiphunkSigned area of a polygon shape. Returns a negative number for polygons with a clockwise winding.Gchiphunk%Calculate the centroid for a polygon.Hchiphunk3Calculate the convex hull of a given set of points.@chiphunkMasschiphunkr1chiphunkr2chiphunkOffsetAchiphunkMasschiphunkachiphunkbchiphunk ThicknessBchiphunkMasschiphunkVertexeschiphunkOffsetchiphunk ThicknessCchiphunkMasschiphunkWidthchiphunkHeightDchiphunkr1chiphunkr2EchiphunkOne endchiphunk Other endchiphunk ThicknessFchiphunkVertexeschiphunk ThicknessHchiphunkSet of vertexeschiphunkAllowed 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. @ABCDEFGHIDealing with joints/constraintsNoneF1Jchiphunk(The first body constraint is attached toKchiphunk)The second body constraint is attached toLchiphunkThe maximum force that the constraint can use to act on the two bodies. Defaults to INFINITY.MchiphunkThe 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.NchiphunkGet the maximum speed at which the constraint can apply error correction. Defaults to INFINITY.OchiphunkThe # that constraint has been added to.PchiphunkConstraints 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.This can be used to create a chain that self collides, but adjacent links in the chain do not collide.QchiphunkA user definable data pointer. Use this pointer to get a reference to the game object that owns this constraint from callbacks.RchiphunkThe 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.SchiphunkFree function is shared by all joint types. Allocation functions are specific to each joint type.TchiphunkConnect 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.UchiphunkAnchor on first body.VchiphunkAnchor on second body.Wchiphunk/Desired distance the joint will try to enforce.XchiphunkConnect two bodies via anchor points forcing distance to remain in range.YchiphunkAnchor on first body.ZchiphunkAnchor on second body.[chiphunk3The minimum distance the joint will try to enforce.\chiphunk3The maximum distance the joint will try to enforce.]chiphunkBecause 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.achiphunkPivot is attached to groove on first body and to anchor on the second. All coordinates are body local.bchiphunk)First endpoint of groove (on first body).cchiphunk*Second endpoint of groove (on first body).dchiphunkAnchor on second body.echiphunk Defined much like a slide joint.fchiphunkAnchor on first body.gchiphunkAnchor on second body.hchiphunk0Desired distance the spring will try to enforce.ichiphunkSpring stiffnessjchiphunkSpring dampingkchiphunk*Create new damped rotary spring constraintlchiphunk>= 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.The behavior of adding a postStep callback from outside of a collision handler or query callback is undefined.{chiphunkspacechiphunkobjchiphunkdatachiphunkachiphunkbchiphunktypechiphunkspacechiphunkfuncchiphunkkeychiphunkdata{|}~ (Utilities for working with bounding box.None_ychiphunkConvenience 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  NonemchiphunkThe 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.chiphunkThe 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.chiphunkA 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.chiphunkThe 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.chiphunkReturns 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  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.NoneychiphunkConvenience constructor for creating new cpVect structs. Alias for !chiphunkConstant for the zero vector. Alias for chiphunkCheck 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.chiphunkReturns 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 .chiphunkIterations 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.chiphunkTime 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.chiphunkChipmunk 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%.Valid 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) ^ 60 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.chiphunkReindex all static shapes. Generally updating only the shapes that changed is faster.chiphunkCall func for each body in the space also passing along your data 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.chiphunkCall 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 manipulationsNone$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 .chiphunkBe careful not to free a body before any shapes or constraints attached to it have been removed from a space.chiphunkType 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.chiphunkPosition of the body. When changing the position you may also want to call spaceReindexShapesForBody 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.chiphunkForce applied to the center of gravity of the body. This value is reset for every time step.chiphunkSet 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.chiphunkTorque 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.chiphunkUser 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.chiphunkAbsolute 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.chiphunkReset the idle timer on a body. If it was sleeping, wake it and any other bodies it was touching.chiphunkForces 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.  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. data 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.Sensor 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.chiphunkbodychiphunkforcechiphunkpointchiphunkbodychiphunkforcechiphunkpointchiphunkbodychiphunkimpulsechiphunkpointchiphunkbodychiphunkimpulsechiphunkpointchiphunkbodychiphunkfilterchiphunkbodychiphunkgroupchiphunkbodychiphunkfuncchiphunkdatachiphunkbodychiphunkfuncchiphunkdatachiphunkbodychiphunkfuncchiphunkdata)8Low-level Haskell bindings to Chipmunk2D physics libraryNonem  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$ @ABCDEF*+,-./012%&'()3456789:;<=>?GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz}~|{  !"#$%&'()*+,-.//012344567789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                 %&'(-'chiphunk-0.1.3.0-5XTsCzJGLm4LxWcXHQ4Jj9 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.2-67vyH0wM7JT1vFTf2tRTVx Data.StateVar$= HasSetterget HasGetterbaseGHC.PtrnullPtrfClampfLerp fLerpConst CollisionType TransformtAtBtCtDtTxtTyArbiter ConstraintShapeSpaceBodyTypeBodyTypeDynamicBodyTypeKimenaticBodyTypeStaticBodyDataPtrBBbbLbbBbbRbbTVectvXvY ShapeFiltersfGroup sfCategoriessfMask shapeBodyshapeBB shapeSensorshapeElasticity shapeFrictionshapeSurfaceVelocityshapeCollisionType shapeMass shapeDensity shapeFilter shapeSpace shapeUserData shapeFree shapeCacheBB shapeUpdatecircleShapeNewsegmentShapeNewsegmentShapeNeighbors polyShapeNewpolyShapeNewRaw boxShapeNew boxShapeNew2momentForCirclemomentForSegment momentForPoly momentForBox areaForCircleareaForSegment areaForPolycentroidForPoly convexHullconvexDecompositionconstraintBodyAconstraintBodyBconstraintMaxForceconstraintErrorBiasconstraintMaxBiasconstraintSpaceconstraintCollideBodiesconstraintUserDataconstraintImpulseconstraintFree 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 makeStateVar PolylineSet unPolylineSetPolylineSetPtrPolyline unPolyline PolylinePtrCPBoolwithPolylinePtrpeekPolylineSetShapeFilterPtrghc-prim GHC.TypesTrueFalse(vector-space-0.16-KW8kSP6GMeFLB0ZvR8f5PWData.AdditiveGroupzeroV GHC.Classes==^+^^-^negateVData.VectorSpace^*<.> Data.Crosscross2project magnitude magnitudeSqlerp normalizedbodyVelocityAtLocalPoint