Package org.jbox2d.collision

Class Collision

java.lang.Object

org.jbox2d.collision.Collision

public class Collision
extends java.lang.Object

Functions used for computing contact points, distance queries, and TOI queries. Collision methods are non-static for pooling speed, retrieve a collision object from the SingletonPool. Should not be finalructed.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	Collision.ClipVertex	Used for computing contact manifolds.
private static class	Collision.EdgeResults	Java-specific class for returning edge results
(package private) static class	Collision.EPAxis	This structure is used to keep track of the best separating axis.
(package private) static class	Collision.EPCollider	This class collides and edge and a polygon, taking into account edge adjacency.
static class	Collision.PointState	This is used for determining the state of contact points.
(package private) static class	Collision.ReferenceFace	Reference face used for clipping
(package private) static class	Collision.TempPolygon	This holds polygon B expressed in frame A.

Field Summary

Fields

Modifier and Type	Field	Description
private Distance.SimplexCache	cache
private ContactID	cf
private Collision.ClipVertex[]	clipPoints1
private Collision.ClipVertex[]	clipPoints2
private Collision.EPCollider	collider
private static Vec2	d
private Vec2	e
private Vec2	e1
private Collision.ClipVertex[]	incidentEdge
private DistanceInput	input
private Vec2	localNormal
private Vec2	localTangent
private Vec2	n
static int	NULL_FEATURE
private DistanceOutput	output
private Vec2	P
private Vec2	planePoint
private IWorldPool	pool
private Vec2	Q
private Collision.EdgeResults	results1
private Collision.EdgeResults	results2
private Vec2	tangent
private Vec2	temp
private Vec2	v11
private Vec2	v12

Constructor Summary

Constructors

Constructor	Description
Collision(IWorldPool argPool)

Method Summary

Modifier and Type	Method	Description
static int	clipSegmentToLine(Collision.ClipVertex[] vOut, Collision.ClipVertex[] vIn, Vec2 normal, float offset, int vertexIndexA)	Clipping for contact manifolds.
void	collideCircles(Manifold manifold, CircleShape circle1, Transform xfA, CircleShape circle2, Transform xfB)	Compute the collision manifold between two circles.
void	collideEdgeAndCircle(Manifold manifold, EdgeShape edgeA, Transform xfA, CircleShape circleB, Transform xfB)
void	collideEdgeAndPolygon(Manifold manifold, EdgeShape edgeA, Transform xfA, PolygonShape polygonB, Transform xfB)
void	collidePolygonAndCircle(Manifold manifold, PolygonShape polygon, Transform xfA, CircleShape circle, Transform xfB)	Compute the collision manifold between a polygon and a circle.
void	collidePolygons(Manifold manifold, PolygonShape polyA, Transform xfA, PolygonShape polyB, Transform xfB)	Compute the collision manifold between two polygons.
float	edgeSeparation(PolygonShape poly1, Transform xf1, int edge1, PolygonShape poly2, Transform xf2)	Find the separation between poly1 and poly2 for a given edge normal on poly1.
void	findIncidentEdge(Collision.ClipVertex[] c, PolygonShape poly1, Transform xf1, int edge1, PolygonShape poly2, Transform xf2)
void	findMaxSeparation(Collision.EdgeResults results, PolygonShape poly1, Transform xf1, PolygonShape poly2, Transform xf2)	Find the max separation between poly1 and poly2 using edge normals from poly1.
static void	getPointStates(Collision.PointState[] state1, Collision.PointState[] state2, Manifold manifold1, Manifold manifold2)	Compute the point states given two manifolds.
boolean	testOverlap(Shape shapeA, int indexA, Shape shapeB, int indexB, Transform xfA, Transform xfB)	Determine if two generic shapes overlap.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

NULL_FEATURE

public static final int NULL_FEATURE

See Also:

Constant Field Values

pool

private final IWorldPool pool

input

private final DistanceInput input

cache

private final Distance.SimplexCache cache

output

private final DistanceOutput output

d

private static Vec2 d

temp

private final Vec2 temp

results1

private final Collision.EdgeResults results1

results2

private final Collision.EdgeResults results2

incidentEdge

private final Collision.ClipVertex[] incidentEdge

localTangent

private final Vec2 localTangent

localNormal

private final Vec2 localNormal

planePoint

private final Vec2 planePoint

tangent

private final Vec2 tangent

v11

private final Vec2 v11

v12

private final Vec2 v12

clipPoints1

private final Collision.ClipVertex[] clipPoints1

clipPoints2

private final Collision.ClipVertex[] clipPoints2

Q

private final Vec2 Q

e

private final Vec2 e

cf

private final ContactID cf

e1

private final Vec2 e1

P

private final Vec2 P

n

private final Vec2 n

collider

private final Collision.EPCollider collider

Constructor Detail

Collision

public Collision(IWorldPool argPool)

Method Detail

testOverlap

public final boolean testOverlap(Shape shapeA,
                                 int indexA,
                                 Shape shapeB,
                                 int indexB,
                                 Transform xfA,
                                 Transform xfB)

Determine if two generic shapes overlap.

Parameters:

shapeA -

shapeB -

xfA -

xfB -

Returns:

getPointStates

public static final void getPointStates(Collision.PointState[] state1,
                                        Collision.PointState[] state2,
                                        Manifold manifold1,
                                        Manifold manifold2)

Compute the point states given two manifolds. The states pertain to the transition from manifold1 to manifold2. So state1 is either persist or remove while state2 is either add or persist.

Parameters:

state1 -

state2 -

manifold1 -

manifold2 -

clipSegmentToLine

public static final int clipSegmentToLine(Collision.ClipVertex[] vOut,
                                          Collision.ClipVertex[] vIn,
                                          Vec2 normal,
                                          float offset,
                                          int vertexIndexA)

Clipping for contact manifolds. Sutherland-Hodgman clipping.

Parameters:

vOut -

vIn -

normal -

offset -

Returns:

collideCircles

public final void collideCircles(Manifold manifold,
                                 CircleShape circle1,
                                 Transform xfA,
                                 CircleShape circle2,
                                 Transform xfB)

Compute the collision manifold between two circles.

Parameters:

manifold -

circle1 -

xfA -

circle2 -

xfB -

collidePolygonAndCircle

public final void collidePolygonAndCircle(Manifold manifold,
                                          PolygonShape polygon,
                                          Transform xfA,
                                          CircleShape circle,
                                          Transform xfB)

Compute the collision manifold between a polygon and a circle.

Parameters:

manifold -

polygon -

xfA -

circle -

xfB -

edgeSeparation

public final float edgeSeparation(PolygonShape poly1,
                                  Transform xf1,
                                  int edge1,
                                  PolygonShape poly2,
                                  Transform xf2)

Find the separation between poly1 and poly2 for a given edge normal on poly1.

Parameters:

poly1 -

xf1 -

edge1 -

poly2 -

xf2 -

findMaxSeparation

public final void findMaxSeparation(Collision.EdgeResults results,
                                    PolygonShape poly1,
                                    Transform xf1,
                                    PolygonShape poly2,
                                    Transform xf2)

Find the max separation between poly1 and poly2 using edge normals from poly1.

Parameters:

edgeIndex -

poly1 -

xf1 -

poly2 -

xf2 -

findIncidentEdge

public final void findIncidentEdge(Collision.ClipVertex[] c,
                                   PolygonShape poly1,
                                   Transform xf1,
                                   int edge1,
                                   PolygonShape poly2,
                                   Transform xf2)

collidePolygons

public final void collidePolygons(Manifold manifold,
                                  PolygonShape polyA,
                                  Transform xfA,
                                  PolygonShape polyB,
                                  Transform xfB)

Compute the collision manifold between two polygons.

Parameters:

manifold -

polygon1 -

xf1 -

polygon2 -

xf2 -

collideEdgeAndCircle

public void collideEdgeAndCircle(Manifold manifold,
                                 EdgeShape edgeA,
                                 Transform xfA,
                                 CircleShape circleB,
                                 Transform xfB)

collideEdgeAndPolygon

public void collideEdgeAndPolygon(Manifold manifold,
                                  EdgeShape edgeA,
                                  Transform xfA,
                                  PolygonShape polygonB,
                                  Transform xfB)