Module org.dyn4j

Package org.dyn4j.world

Class AbstractCollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Object

AbstractCollisionWorld<T,E,V>

Type Parameters:

T - the CollisionBody type

E - the Fixture type

V - the CollisionData type

All Implemented Interfaces:

DataContainer, Shiftable, CollisionWorld<T,E,V>

Direct Known Subclasses:

AbstractPhysicsWorld

public abstract class AbstractCollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>
extends Object
implements CollisionWorld<T,E,V>, Shiftable, DataContainer

Abstract implementation of the CollisionWorld interface.

Implements the basic wiring for a collision detection pipeline. Extenders are expected to implement the processCollisions(Iterator) and createCollisionData(CollisionPair) methods. It's expected that extenders would fully enumerate the Iterator given in the processCollisions(Iterator) method to ensure a detection cycle is fully completed.

Extenders should call the detect() method to initiate the collision detection pipeline. Calling the detect() will call the processCollisions(Iterator) method to perform additional processing on the collisions found.

At a high-level this class handles the following pipeline activities:

1. (out of) Bounds detection (optional)
2. Broad-phase collision detection
3. Narrow-phase collision detection
4. Narrow-phase post-processing (ex. Link shapes)
5. Manifold (contact point) generation

NOTE: This class uses the AbstractCollisionBody.setOwner(Object) and AbstractCollisionBody.setFixtureModificationHandler(org.dyn4j.collision.FixtureModificationHandler) methods to handle certain scenarios like fixture removal on a body or bodies added to more than one world. Callers should NOT use the methods.

Since:

4.0.0

Version:

4.0.0

Author:

William Bittle

See Also:

CollisionWorld

Field Summary

Fields inherited from interface CollisionWorld

DEFAULT_INITIAL_BODY_CAPACITY

Constructor Summary

Constructors

Constructor	Description
AbstractCollisionWorld()	Default constructor.
AbstractCollisionWorld(int initialBodyCapacity)	Optional constructor.

Method Summary

Modifier and Type	Method	Description
void	addBody(T body)	Adds the given CollisionBody to this CollisionWorld.
boolean	addBoundsListener(BoundsListener<T,E> listener)	Adds the given BoundsListener to this world.
boolean	addCollisionListener(CollisionListener<T,E> listener)	Adds the given CollisionListener to this world.
boolean	containsBody(T body)	Returns true if this world contains the given body.
List<ConvexCastResult<T,E>>	convexCast(Convex convex, Transform transform, Vector2 deltaPosition, double deltaAngle, DetectFilter<T,E> filter)	Returns a list of ConvexCastResults containing all the body-fixtures that overlap with the given Convex over the given deltaPosition and deltaAngle using the current state of the BroadphaseDetector.
ConvexCastResult<T,E>	convexCastClosest(Convex convex, Transform transform, Vector2 deltaPosition, double deltaAngle, DetectFilter<T,E> filter)	Returns the closest ConvexCastResult that overlaps with the given Convex over the given deltaPosition and deltaAngle using the current state of the BroadphaseDetector.
ConvexCastResult<T,E>	convexCastClosest(Convex convex, Transform transform, Vector2 deltaPosition, double deltaAngle, T body, DetectFilter<T,E> filter)	Returns the closest ConvexCastResult that overlaps with the given Convex over the given deltaPosition and deltaAngle only testing against the given CollisionBody.
Iterator<ConvexCastResult<T,E>>	convexCastIterator(Convex convex, Transform transform, Vector2 deltaPosition, double deltaAngle, DetectFilter<T,E> filter)	Returns an iterator of ConvexCastResults containing all the body-fixtures that overlap with the given Convex over the given deltaPosition and deltaAngle using the current state of the BroadphaseDetector.
List<DetectResult<T,E>>	detect(AABB aabb, DetectFilter<T,E> filter)	Returns a list of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector.
List<DetectResult<T,E>>	detect(AABB aabb, T body, DetectFilter<T,E> filter)	Returns a list of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector, only testing against the given CollisionBody.
List<ConvexDetectResult<T,E>>	detect(Convex convex, Transform transform, DetectFilter<T,E> filter)	Returns a list of ConvexDetectResults containing all the body-fixtures that overlap with the given Convex using the current state of the BroadphaseDetector.
List<ConvexDetectResult<T,E>>	detect(Convex convex, Transform transform, T body, DetectFilter<T,E> filter)	Returns a list of ConvexDetectResults containing all the body-fixtures that overlapped with the given Convex using the current state of the BroadphaseDetector, only testing against the given CollisionBody.
Iterator<DetectResult<T,E>>	detectIterator(AABB aabb, DetectFilter<T,E> filter)	Returns an iterator of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector.
Iterator<DetectResult<T,E>>	detectIterator(AABB aabb, T body, DetectFilter<T,E> filter)	Returns an iterator of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector, only testing against the given CollisionBody.
Iterator<ConvexDetectResult<T,E>>	detectIterator(Convex convex, Transform transform, DetectFilter<T,E> filter)	Returns an iterator of ConvexDetectResults containing all the body-fixtures that overlapped with the given Convex using the current state of the BroadphaseDetector.
Iterator<ConvexDetectResult<T,E>>	detectIterator(Convex convex, Transform transform, T body, DetectFilter<T,E> filter)	Returns an iterator of ConvexDetectResults containing all the body-fixtures that overlapped with the given Convex using the current state of the BroadphaseDetector, only testing against the given CollisionBody.
List<T>	getBodies()	Returns an unmodifiable list containing all the bodies in this world.
T	getBody(int index)	Returns the CollisionBody at the given index.
int	getBodyCount()	Returns the number of CollisionBodys in this CollisionWorld.
Iterator<T>	getBodyIterator()	Returns an iterator for iterating over the bodies in this world.
Bounds	getBounds()	Returns the bounds of this world.
List<BoundsListener<T,E>>	getBoundsListeners()	Returns an unmodifiable list of all the bounds listeners registered to this world.
BroadphaseDetector<T,E>	getBroadphaseDetector()	Returns the broad-phase collision detection algorithm.
BroadphaseFilter<T,E>	getBroadphaseFilter()	Returns the BroadphaseFilter used when detecting collisions for each time step.
V	getCollisionData(T body1, E fixture1, T body2, E fixture2)	Returns the collision data for the given body-fixture pairs.
Iterator<V>	getCollisionDataIterator()	Returns an iterator that can be used to enumerate all the collisions in this world.
List<CollisionListener<T,E>>	getCollisionListeners()	Returns an unmodifiable list of all the collision listeners registered to this world.
ManifoldSolver	getManifoldSolver()	Returns the manifold solver.
NarrowphaseDetector	getNarrowphaseDetector()	Returns the narrow-phase collision detection algorithm.
NarrowphasePostProcessor	getNarrowphasePostProcessor()	Returns the narrow-phase post processing algorithm.
RaycastDetector	getRaycastDetector()	Returns the raycast detector.
TimeOfImpactDetector	getTimeOfImpactDetector()	Returns the time of impact detector.
Object	getUserData()	Gets the custom user data.
boolean	isEmpty()	Returns true if this world doesn't contain any bodies or joints.
List<RaycastResult<T,E>>	raycast(Ray ray, double maxLength, DetectFilter<T,E> filter)	Returns a list of RaycastResults containing all the body-fixtures that overlap with the given Ray using the current state of the BroadphaseDetector.
List<RaycastResult<T,E>>	raycast(Ray ray, double maxLength, T body, DetectFilter<T,E> filter)	Returns a list of RaycastResults containing all the body-fixtures that overlap with the given Ray only testing against the given CollisionBody.
RaycastResult<T,E>	raycastClosest(Ray ray, double maxLength, DetectFilter<T,E> filter)	Returns the closest RaycastResult that overlaps with the given Ray using the current state of the BroadphaseDetector.
RaycastResult<T,E>	raycastClosest(Ray ray, double maxLength, T body, DetectFilter<T,E> filter)	Returns the closest RaycastResult that overlaps with the given Ray only testing against the given CollisionBody.
Iterator<RaycastResult<T,E>>	raycastIterator(Ray ray, double maxLength, DetectFilter<T,E> filter)	Returns an iterator of RaycastResults containing all the body-fixtures that overlap with the given Ray using the current state of the BroadphaseDetector.
Iterator<RaycastResult<T,E>>	raycastIterator(Ray ray, double maxLength, T body, DetectFilter<T,E> filter)	Returns an iterator of RaycastResults containing all the body-fixtures that overlap with the given Ray only testing against the given CollisionBody.
void	removeAllBodies()	Removes all bodies from this world.
void	removeAllBoundsListeners()	Removes all bounds listeners from this world.
void	removeAllCollisionListeners()	Removes all collision listeners from this world.
void	removeAllListeners()	Removes all listeners from this world.
boolean	removeBody(int index)	Removes the CollisionBody at the given index from this CollisionWorld.
boolean	removeBody(T body)	Removes the given CollisionBody from this CollisionWorld.
boolean	removeBoundsListener(BoundsListener<T,E> listener)	Removes the given bounds listener from this world and returns true if it was removed.
boolean	removeCollisionListener(CollisionListener<T,E> listener)	Removes the given collision listener from this world and returns true if it was removed.
void	setBounds(Bounds bounds)	Sets the bounds of this CollisionWorld.
void	setBroadphaseDetector(BroadphaseDetector<T,E> broadphaseDetector)	Sets the broad-phase collision detection algorithm.
void	setBroadphaseFilter(BroadphaseFilter<T,E> filter)	Sets the BroadphaseFilter used when detecting collisions for each time step.
void	setManifoldSolver(ManifoldSolver manifoldSolver)	Sets the manifold solver.
void	setNarrowphaseDetector(NarrowphaseDetector narrowphaseDetector)	Sets the narrow-phase collision detection algorithm.
void	setNarrowphasePostProcessor(NarrowphasePostProcessor narrowphasePostProcessor)	Sets the narrow-phase post processing algorithm.
void	setRaycastDetector(RaycastDetector raycastDetector)	Sets the raycast detector.
void	setTimeOfImpactDetector(TimeOfImpactDetector timeOfImpactDetector)	Sets the time of impact detector.
void	setUserData(Object data)	Sets the custom user data to the given data.
void	shift(Vector2 shift)	Translates the object to match the given coordinate shift.

Methods inherited from class Object

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

Constructor Detail

AbstractCollisionWorld

public AbstractCollisionWorld()

Default constructor.

Uses the CollisionWorld.DEFAULT_INITIAL_BODY_CAPACITY as the initial capacity.

AbstractCollisionWorld

public AbstractCollisionWorld(int initialBodyCapacity)

Optional constructor.

Parameters:

initialBodyCapacity - the default initial body capacity

Method Detail

addBody

public void addBody(T body)

Description copied from interface: CollisionWorld

Adds the given CollisionBody to this CollisionWorld.

Specified by:

addBody in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

body - the CollisionBody to add

removeAllBodies

public void removeAllBodies()

Description copied from interface: CollisionWorld

Removes all bodies from this world.

Specified by:

removeAllBodies in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

containsBody

public boolean containsBody(T body)

Description copied from interface: CollisionWorld

Returns true if this world contains the given body.

Specified by:

containsBody in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

body - the CollisionBody to test for

Returns:

boolean true if the body is contained in this world

removeBody

public boolean removeBody(int index)

Description copied from interface: CollisionWorld

Removes the CollisionBody at the given index from this CollisionWorld.

Specified by:

removeBody in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

index - the index of the body to remove.

Returns:

boolean true if the body was removed

removeBody

public boolean removeBody(T body)

Description copied from interface: CollisionWorld

Removes the given CollisionBody from this CollisionWorld.

Specified by:

removeBody in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

body - the CollisionBody to remove.

Returns:

boolean true if the body was removed

getBodies

public List<T> getBodies()

Description copied from interface: CollisionWorld

Returns an unmodifiable list containing all the bodies in this world.

The returned list is backed by the internal list, therefore adding or removing bodies while iterating through the returned list is not permitted. Use the CollisionWorld.getBodyIterator() method instead.

Specified by:

getBodies in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

List<CollisionBody>

See Also:

CollisionWorld.getBodyIterator()

getBody

public T getBody(int index)

Description copied from interface: CollisionWorld

Returns the CollisionBody at the given index.

Specified by:

getBody in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

index - the index

Returns:

CollisionBody

getBodyCount

public int getBodyCount()

Description copied from interface: CollisionWorld

Returns the number of CollisionBodys in this CollisionWorld.

Specified by:

getBodyCount in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

int the number of bodies

isEmpty

public boolean isEmpty()

Description copied from interface: CollisionWorld

Returns true if this world doesn't contain any bodies or joints.

Specified by:

isEmpty in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

boolean

getBodyIterator

public Iterator<T> getBodyIterator()

Description copied from interface: CollisionWorld

Returns an iterator for iterating over the bodies in this world.

The returned iterator supports the remove method.

Specified by:

getBodyIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

Iterator<CollisionBody>

setBounds

public void setBounds(Bounds bounds)

Description copied from interface: CollisionWorld

Sets the bounds of this CollisionWorld.

Specified by:

setBounds in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

bounds - the bounds; can be null

getBounds

public Bounds getBounds()

Description copied from interface: CollisionWorld

Returns the bounds of this world.

This will return null if no bounds were initially set or if it was set to null via the CollisionWorld.setBounds(Bounds) method.

Specified by:

getBounds in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

Bounds the bounds or null

setBroadphaseDetector

public void setBroadphaseDetector(BroadphaseDetector<T,E> broadphaseDetector)

Description copied from interface: CollisionWorld

Sets the broad-phase collision detection algorithm.

Specified by:

setBroadphaseDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

broadphaseDetector - the broad-phase collision detection algorithm

getBroadphaseDetector

public BroadphaseDetector<T,E> getBroadphaseDetector()

Description copied from interface: CollisionWorld

Returns the broad-phase collision detection algorithm.

Specified by:

getBroadphaseDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

BroadphaseDetector the broad-phase collision detection algorithm

setBroadphaseFilter

public void setBroadphaseFilter(BroadphaseFilter<T,E> filter)

Description copied from interface: CollisionWorld

Sets the BroadphaseFilter used when detecting collisions for each time step.

This should always be an instance of a class that extends the PhysicsBodyBroadphaseFilter so that the standard filters are retained.

Specified by:

setBroadphaseFilter in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

filter - the filter

getBroadphaseFilter

public BroadphaseFilter<T,E> getBroadphaseFilter()

Description copied from interface: CollisionWorld

Returns the BroadphaseFilter used when detecting collisions for each time step.

Specified by:

getBroadphaseFilter in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

BroadphaseFilter

setNarrowphaseDetector

public void setNarrowphaseDetector(NarrowphaseDetector narrowphaseDetector)

Description copied from interface: CollisionWorld

Sets the narrow-phase collision detection algorithm.

Specified by:

setNarrowphaseDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

narrowphaseDetector - the narrow-phase collision detection algorithm

getNarrowphaseDetector

public NarrowphaseDetector getNarrowphaseDetector()

Description copied from interface: CollisionWorld

Returns the narrow-phase collision detection algorithm.

Specified by:

getNarrowphaseDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

NarrowphaseDetector the narrow-phase collision detection algorithm

setNarrowphasePostProcessor

public void setNarrowphasePostProcessor(NarrowphasePostProcessor narrowphasePostProcessor)

Description copied from interface: CollisionWorld

Sets the narrow-phase post processing algorithm.

Specified by:

setNarrowphasePostProcessor in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

narrowphasePostProcessor - the narrow-phase post processing algorithm

getNarrowphasePostProcessor

public NarrowphasePostProcessor getNarrowphasePostProcessor()

Description copied from interface: CollisionWorld

Returns the narrow-phase post processing algorithm.

Specified by:

getNarrowphasePostProcessor in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

NarrowphasePostProcessor the narrow-phase post processing algorithm

setManifoldSolver

public void setManifoldSolver(ManifoldSolver manifoldSolver)

Description copied from interface: CollisionWorld

Sets the manifold solver.

Specified by:

setManifoldSolver in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

manifoldSolver - the manifold solver

getManifoldSolver

public ManifoldSolver getManifoldSolver()

Description copied from interface: CollisionWorld

Returns the manifold solver.

Specified by:

getManifoldSolver in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

ManifoldSolver the manifold solver

setRaycastDetector

public void setRaycastDetector(RaycastDetector raycastDetector)

Description copied from interface: CollisionWorld

Sets the raycast detector.

Specified by:

setRaycastDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

raycastDetector - the raycast detector

getRaycastDetector

public RaycastDetector getRaycastDetector()

Description copied from interface: CollisionWorld

Returns the raycast detector.

Specified by:

getRaycastDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

RaycastDetector the raycast detector

setTimeOfImpactDetector

public void setTimeOfImpactDetector(TimeOfImpactDetector timeOfImpactDetector)

Description copied from interface: CollisionWorld

Sets the time of impact detector.

Specified by:

setTimeOfImpactDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

timeOfImpactDetector - the time of impact detector

getTimeOfImpactDetector

public TimeOfImpactDetector getTimeOfImpactDetector()

Description copied from interface: CollisionWorld

Returns the time of impact detector.

Specified by:

getTimeOfImpactDetector in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

TimeOfImpactDetector the time of impact detector

shift

public void shift(Vector2 shift)

Description copied from interface: Shiftable

Translates the object to match the given coordinate shift.

Specified by:

shift in interface Shiftable

Parameters:

shift - the amount to shift along the x and y axes

getCollisionDataIterator

public Iterator<V> getCollisionDataIterator()

Description copied from interface: CollisionWorld

Returns an iterator that can be used to enumerate all the collisions in this world.

This returns the collision data for any pair that was detected in the broadphase. Use the CollisionData.isBroadphaseCollision(), CollisionData.isManifoldCollision(), etc. methods to inspect the type of collision or the details about the collision.

NOTE: This iterator does NOT support removal.

Specified by:

getCollisionDataIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

Iterator<V>

getCollisionData

public V getCollisionData(T body1,
                          E fixture1,
                          T body2,
                          E fixture2)

Description copied from interface: CollisionWorld

Returns the collision data for the given body-fixture pairs.

This returns the collision data for any pair that was detected in the broadphase. Use the CollisionData.isBroadphaseCollision(), CollisionData.isManifoldCollision(), etc. methods to inspect the type of collision or the details about the collision.

Returns null if the body-fixtures are not colliding or if either no longer exist in the world.

Specified by:

getCollisionData in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

body1 - the first body

fixture1 - the first body's fixture

body2 - the second body

fixture2 - the second body's fixture

Returns:

V

getBoundsListeners

public List<BoundsListener<T,E>> getBoundsListeners()

Description copied from interface: CollisionWorld

Returns an unmodifiable list of all the bounds listeners registered to this world.

Specified by:

getBoundsListeners in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

List<BoundsListener>

getCollisionListeners

public List<CollisionListener<T,E>> getCollisionListeners()

Description copied from interface: CollisionWorld

Returns an unmodifiable list of all the collision listeners registered to this world.

Specified by:

getCollisionListeners in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Returns:

List<CollisionListener>

removeAllListeners

public void removeAllListeners()

Description copied from interface: CollisionWorld

Removes all listeners from this world.

Specified by:

removeAllListeners in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

removeAllBoundsListeners

public void removeAllBoundsListeners()

Description copied from interface: CollisionWorld

Removes all bounds listeners from this world.

Specified by:

removeAllBoundsListeners in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

removeAllCollisionListeners

public void removeAllCollisionListeners()

Description copied from interface: CollisionWorld

Removes all collision listeners from this world.

Specified by:

removeAllCollisionListeners in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

removeBoundsListener

public boolean removeBoundsListener(BoundsListener<T,E> listener)

Description copied from interface: CollisionWorld

Removes the given bounds listener from this world and returns true if it was removed.

This method will return false if the listener was not found in this world.

Specified by:

removeBoundsListener in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

listener - the listener

Returns:

boolean

removeCollisionListener

public boolean removeCollisionListener(CollisionListener<T,E> listener)

Description copied from interface: CollisionWorld

Removes the given collision listener from this world and returns true if it was removed.

This method will return false if the listener was not found in this world.

Specified by:

removeCollisionListener in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

listener - the listener

Returns:

boolean

addBoundsListener

public boolean addBoundsListener(BoundsListener<T,E> listener)

Description copied from interface: CollisionWorld

Adds the given BoundsListener to this world.

NOTE: No effort is made to prevent duplicate listeners from being added.

Specified by:

addBoundsListener in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

listener - the listener to add

Returns:

boolean

addCollisionListener

public boolean addCollisionListener(CollisionListener<T,E> listener)

Description copied from interface: CollisionWorld

Adds the given CollisionListener to this world.

NOTE: No effort is made to prevent duplicate listeners from being added.

Specified by:

addCollisionListener in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

listener - the listener to add

Returns:

boolean

getUserData

public Object getUserData()

Description copied from interface: DataContainer

Gets the custom user data.

Specified by:

getUserData in interface DataContainer

Returns:

Object will return null if not set

setUserData

public void setUserData(Object data)

Description copied from interface: DataContainer

Sets the custom user data to the given data.

Specified by:

setUserData in interface DataContainer

Parameters:

data - the user data

detect

public List<DetectResult<T,E>> detect(AABB aabb,
                                            DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns a list of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector.

Specified by:

detect in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

aabb - the aabb

filter - the filter; can be null

Returns:

List<DetectResult>

detectIterator

public Iterator<DetectResult<T,E>> detectIterator(AABB aabb,
                                                        DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns an iterator of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector.

NOTE: The returned DetectResults are reused internally. You should call the DetectResult.copy() method to create a copy of the result if you need to keep it outside of the iteration.

Specified by:

detectIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

aabb - the aabb

filter - the filter; can be null

Returns:

Iterator<DetectResult>

detect

public List<DetectResult<T,E>> detect(AABB aabb,
                                            T body,
                                            DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns a list of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector, only testing against the given CollisionBody.

Specified by:

detect in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

aabb - the aabb

body - the body

filter - the filter; can be null

Returns:

List<DetectResult>

detectIterator

public Iterator<DetectResult<T,E>> detectIterator(AABB aabb,
                                                        T body,
                                                        DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns an iterator of DetectResults containing all the body-fixtures that overlap with the given AABB using the current state of the BroadphaseDetector, only testing against the given CollisionBody.

NOTE: The returned DetectResults are reused internally. You should call the DetectResult.copy() method to create a copy of the result if you need to keep it outside of the iteration.

Specified by:

detectIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

aabb - the aabb

body - the body

filter - the filter; can be null

Returns:

Iterator<DetectResult>

detect

public List<ConvexDetectResult<T,E>> detect(Convex convex,
                                                  Transform transform,
                                                  DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns a list of ConvexDetectResults containing all the body-fixtures that overlap with the given Convex using the current state of the BroadphaseDetector.

Specified by:

detect in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

filter - the filter; can be null

Returns:

List<ConvexDetectResult>

detectIterator

public Iterator<ConvexDetectResult<T,E>> detectIterator(Convex convex,
                                                              Transform transform,
                                                              DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns an iterator of ConvexDetectResults containing all the body-fixtures that overlapped with the given Convex using the current state of the BroadphaseDetector.

Specified by:

detectIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

filter - the filter; can be null

Returns:

Iterator<ConvexDetectResult>

detect

public List<ConvexDetectResult<T,E>> detect(Convex convex,
                                                  Transform transform,
                                                  T body,
                                                  DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns a list of ConvexDetectResults containing all the body-fixtures that overlapped with the given Convex using the current state of the BroadphaseDetector, only testing against the given CollisionBody.

Specified by:

detect in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

body - the body

filter - the filter; can be null

Returns:

List<ConvexDetectResult>

detectIterator

public Iterator<ConvexDetectResult<T,E>> detectIterator(Convex convex,
                                                              Transform transform,
                                                              T body,
                                                              DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns an iterator of ConvexDetectResults containing all the body-fixtures that overlapped with the given Convex using the current state of the BroadphaseDetector, only testing against the given CollisionBody.

Specified by:

detectIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

body - the body

filter - the filter; can be null

Returns:

Iterator<ConvexDetectResult>

raycast

public List<RaycastResult<T,E>> raycast(Ray ray,
                                              double maxLength,
                                              DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns a list of RaycastResults containing all the body-fixtures that overlap with the given Ray using the current state of the BroadphaseDetector.

If the ray begins inside a fixture, that fixture will not be included in the results.

Specified by:

raycast in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

ray - the ray

maxLength - the max length of the ray; any value less than or equal to zero represents infinite length

filter - the filter; can be null

Returns:

List<RaycastResult>

raycastIterator

public Iterator<RaycastResult<T,E>> raycastIterator(Ray ray,
                                                          double maxLength,
                                                          DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns an iterator of RaycastResults containing all the body-fixtures that overlap with the given Ray using the current state of the BroadphaseDetector.

If the ray begins inside a fixture, that fixture will not be included in the results.

Specified by:

raycastIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

ray - the ray

maxLength - the max length of the ray; any value less than or equal to zero represents infinite length

filter - the filter; can be null

Returns:

Iterator<RaycastResult>

raycast

public List<RaycastResult<T,E>> raycast(Ray ray,
                                              double maxLength,
                                              T body,
                                              DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns a list of RaycastResults containing all the body-fixtures that overlap with the given Ray only testing against the given CollisionBody.

This method does not use the current state of the BroadphaseDetector and instead tests the given body's fixtures directly.

If the ray begins inside a fixture, that fixture will not be included in the results.

Specified by:

raycast in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

ray - the ray

maxLength - the max length of the ray; any value less than or equal to zero represents infinite length

body - the body

filter - the filter; can be null

Returns:

List<RaycastResult>

raycastIterator

public Iterator<RaycastResult<T,E>> raycastIterator(Ray ray,
                                                          double maxLength,
                                                          T body,
                                                          DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns an iterator of RaycastResults containing all the body-fixtures that overlap with the given Ray only testing against the given CollisionBody.

This method does not use the current state of the BroadphaseDetector and instead tests the given body's fixtures directly.

If the ray begins inside a fixture, that fixture will not be included in the results.

Specified by:

raycastIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

ray - the ray

maxLength - the max length of the ray; any value less than or equal to zero represents infinite length

body - the body

filter - the filter; can be null

Returns:

Iterator<RaycastResult>

raycastClosest

public RaycastResult<T,E> raycastClosest(Ray ray,
                                               double maxLength,
                                               DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns the closest RaycastResult that overlaps with the given Ray using the current state of the BroadphaseDetector.

The closest is defined as the closest intersection of the ray and a fixture to the ray's start point.

If the ray begins inside a fixture, that fixture will not be included in the results.

Specified by:

raycastClosest in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

ray - the ray

maxLength - the max length of the ray; any value less than or equal to zero represents infinite length

filter - the filter; can be null

Returns:

RaycastResult

raycastClosest

public RaycastResult<T,E> raycastClosest(Ray ray,
                                               double maxLength,
                                               T body,
                                               DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns the closest RaycastResult that overlaps with the given Ray only testing against the given CollisionBody.

The closest is defined as the closest intersection of the ray and a fixture to the ray's start point.

This method does not use the current state of the BroadphaseDetector and instead tests the given body's fixtures directly.

If the ray begins inside a fixture, that fixture will not be included in the results.

Specified by:

raycastClosest in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

ray - the ray

maxLength - the max length of the ray; any value less than or equal to zero represents infinite length

body - the body

filter - the filter; can be null

Returns:

RaycastResult

convexCastClosest

public ConvexCastResult<T,E> convexCastClosest(Convex convex,
                                                     Transform transform,
                                                     Vector2 deltaPosition,
                                                     double deltaAngle,
                                                     T body,
                                                     DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns the closest ConvexCastResult that overlaps with the given Convex over the given deltaPosition and deltaAngle only testing against the given CollisionBody.

The closest is defined as the closest intersection from the initial position/rotation of the given convex.

The deltaPosition and deltaAngle parameters define the cast of the convex. Imagine moving the given convex from it's current transform position to the given position and rotating the given convex from it's current transform rotation to the given rotation. This method detects if there was any collisions between these start and end states.

This method assumes linear motion, meaning that the direction of motion is in the same direction for the start and end states as defined by the deltaPosition parameter.

Specified by:

convexCastClosest in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

deltaPosition - the change in position of the convex

deltaAngle - the change in rotation of the convex

body - the body

filter - the filter; can be null

Returns:

ConvexCastResult

convexCast

public List<ConvexCastResult<T,E>> convexCast(Convex convex,
                                                    Transform transform,
                                                    Vector2 deltaPosition,
                                                    double deltaAngle,
                                                    DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns a list of ConvexCastResults containing all the body-fixtures that overlap with the given Convex over the given deltaPosition and deltaAngle using the current state of the BroadphaseDetector.

The deltaPosition and deltaAngle parameters define the cast of the convex. Imagine moving the given convex from it's current transform position to the given position and rotating the given convex from it's current transform rotation to the given rotation. This method detects if there was any collisions between these start and end states.

This method assumes linear motion, meaning that the direction of motion is in the same direction for the start and end states as defined by the deltaPosition parameter.

Specified by:

convexCast in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

deltaPosition - the change in position of the convex

deltaAngle - the change in rotation of the convex

filter - the filter; can be null

Returns:

List<ConvexCastResult>

convexCastClosest

public ConvexCastResult<T,E> convexCastClosest(Convex convex,
                                                     Transform transform,
                                                     Vector2 deltaPosition,
                                                     double deltaAngle,
                                                     DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns the closest ConvexCastResult that overlaps with the given Convex over the given deltaPosition and deltaAngle using the current state of the BroadphaseDetector.

The closest is defined as the closest intersection from the initial position/rotation of the given convex.

The deltaPosition and deltaAngle parameters define the cast of the convex. Imagine moving the given convex from it's current transform position to the given position and rotating the given convex from it's current transform rotation to the given rotation. This method detects if there was any collisions between these start and end states.

This method assumes linear motion, meaning that the direction of motion is in the same direction for the start and end states as defined by the deltaPosition parameter.

Specified by:

convexCastClosest in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

deltaPosition - the change in position of the convex

deltaAngle - the change in rotation of the convex

filter - the filter; can be null

Returns:

ConvexCastResult

convexCastIterator

public Iterator<ConvexCastResult<T,E>> convexCastIterator(Convex convex,
                                                                Transform transform,
                                                                Vector2 deltaPosition,
                                                                double deltaAngle,
                                                                DetectFilter<T,E> filter)

Description copied from interface: CollisionWorld

Returns an iterator of ConvexCastResults containing all the body-fixtures that overlap with the given Convex over the given deltaPosition and deltaAngle using the current state of the BroadphaseDetector.

The deltaPosition and deltaAngle parameters define the cast of the convex. Imagine moving the given convex from it's current transform position to the given position and rotating the given convex from it's current transform rotation to the given rotation. This method detects if there was any collisions between these start and end states.

This method assumes linear motion, meaning that the direction of motion is in the same direction for the start and end states as defined by the deltaPosition parameter.

Specified by:

convexCastIterator in interface CollisionWorld<T extends CollisionBody<E>,E extends Fixture,V extends CollisionData<T,E>>

Parameters:

convex - the convex

transform - the transform

deltaPosition - the change in position of the convex

deltaAngle - the change in rotation of the convex

filter - the filter; can be null

Returns:

Iterator<ConvexCastResult>