|Portability||portable (needs FFI)|
|Shapes used for collisions, their properties and some useful
A collision shape is attached to a Body to define its
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 Shape must also be
added to a Space, even if the body was already added.
|There are three types of shapes that can be attached
|Circle||A circle is the fastest collision type. It also
|LineSegment||A line segment is meant to be used as a static
shape. (It can be used with moving bodies, however
two line segments never generate collisions between
|Polygon||Polygons are the slowest of all shapes but
the most flexible. The list of vertices must form
a convex hull with clockwise winding.
Note that if you want a non-convex polygon you may
add several convex polygons to the body.
|newShape 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
|The collision type is used to determine which collision
Physics.Hipmunk.Space.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)
Groups are used to filter collisions between shapes. If
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)
This is primarely used to create multi-body, multi-shape
objects such as ragdolls. It may be thought as a lightweight
alternative to creating a callback that filters the
Layers 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 0xFFFF)
Note that although this type may have more than 32 bits,
for portability you should only rely on the lower 32 bits.
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.
The amount of elasticity applied during a collision is
calculated by multiplying the elasticity of both shapes.
(default is zero)
IMPORTANT: by default no elastic iterations are done
when the space Physics.Hipmunk.Space.steps. This means
that all shapes react as they had zero elasticity.
So, if you want some elasticity, remember to call
Physics.Hipmunk.Space.setElasticIterations to something
greater than zero, maybe 10.
The 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
The amount of friction applied during a collision is
determined by multiplying the friction coefficient
of both shapes. (default is zero)
|The surface velocity of the shape. Useful to create
conveyor belts and players that move around. This
value is only used when calculating friction, not
collision. (default is zero)
|getBody s is the body that this shape is associated
to. Useful especially in Physics.Hipmunk.Space.Callback.
|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.
|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 shapePoly (and the same restrictions for the vertices
apply as well).
|shapeQuery shape p returns True iff the point in
position p (in world's coordinates) lies within
the shape shape.
This section is inspired by pymunk.util,
a Python module made from http://code.google.com/p/pymunk/,
although implementations are quite different.
Also, unless noted otherwise all polygons are
assumed to be simple (i.e. no overlapping edges).
|A line segment.
|A possible intersection between two segments.
|IntPoint !Position||Intercept in a point.
|IntSegmt !Segment||Share a segment.
|The epsilon used in the algorithms below when necessary
to compare floats for "equality".
|"Equality" under epsilon. That is, a .==. b
if abs (a - b) <= epsilon.
isLeft (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.
|O(n). isClockwise verts is True iff verts form
a clockwise polygon.
|O(n). isConvex verts is True iff vers form a convex
|O(1). intersects seg1 seg2 is the intersection between
the two segments seg1 and seg2. See Intersection.
O(n). polyReduce delta verts removes from verts all
points that have less than delta distance
in relation to the one preceding it.
Note that a very small polygon may be completely "eaten"
if all its vertices are within a delta radius from the
|O(n). polyCenter verts is the position in the center
of the polygon formed by verts.
O(n log n). convexHull verts is the convex hull of the
polygon defined by verts. The vertices of the convex
hulls are given in clockwise winding. The polygon
doesn't have to be simple.
Implemented using Graham scan, see
|Produced by Haddock version 2.3.0|