#include <OPC_RayCollider.h>

Inheritance diagram for RayCollider:

Public Member Functions
bool	Collide (const Ray &world_ray, const Model &model, const Matrix4x4 world=null, udword cache=null)
bool	Collide (const Ray &world_ray, const AABBTree *tree, Container &box_indices)
inline_ udword	GetNbIntersections () const
inline_ udword	GetNbRayBVTests () const
inline_ udword	GetNbRayPrimTests () const
	override (Collider) const char *ValidateSettings()
	RayCollider ()
inline_ void	SetClosestHit (bool flag)
inline_ void	SetCulling (bool flag)
inline_ void	SetDestination (CollisionFaces *cf)
inline_ void	SetMaxDist (float max_dist=MAX_FLOAT)
virtual	~RayCollider ()
Protected Member Functions
void	_RayStab (const AABBCollisionNode *node)
void	_RayStab (const AABBNoLeafNode *node)
void	_RayStab (const AABBQuantizedNode *node)
void	_RayStab (const AABBQuantizedNoLeafNode *node)
void	_RayStab (const AABBTreeNode *node, Container &box_indices)
void	_SegmentStab (const AABBCollisionNode *node)
void	_SegmentStab (const AABBNoLeafNode *node)
void	_SegmentStab (const AABBQuantizedNode *node)
void	_SegmentStab (const AABBQuantizedNoLeafNode *node)
void	_SegmentStab (const AABBTreeNode *node, Container &box_indices)
BOOL	InitQuery (const Ray &world_ray, const Matrix4x4 world=null, udword face_id=null)
inline_ BOOL	RayAABBOverlap (const Point &center, const Point &extents)
inline_ BOOL	RayTriOverlap (const Point &vert0, const Point &vert1, const Point &vert2)
inline_ BOOL	SegmentAABBOverlap (const Point &center, const Point &extents)
Protected Attributes
Point	mCenterCoeff
bool	mClosestHit
	Report closest hit only.
bool	mCulling
	Stab culled faces or not.
Point	mData
Point	mData2
Point	mDir
	Ray direction (normalized)
Point	mExtentsCoeff
Point	mFDir
	fabsf(mDir)
float	mMaxDist
	Valid segment on the ray.
udword	mNbIntersections
	Number of valid intersections.
udword	mNbRayBVTests
	Number of Ray-BV tests.
udword	mNbRayPrimTests
	Number of Ray-Primitive tests.
Point	mOrigin
	Ray origin.
CollisionFace	mStabbedFace
	Current stabbed face.
CollisionFaces *	mStabbedFaces
	List of stabbed faces.

Detailed Description

Contains a ray-vs-tree collider. This class performs a stabbing query on an AABB tree, i.e. does a ray-mesh collision.

HIGHER DISTANCE BOUND:

If P0 and P1 are two 3D points, let's define:

d = distance between P0 and P1
Origin = P0
Direction = (P1 - P0) / d = normalized direction vector
A parameter t such as a point P on the line (P0,P1) is P = Origin + t * Direction
t = 0 --> P = P0
t = d --> P = P1

Then we can define a general "ray" as:

struct Ray { Point Origin; Point Direction; };

But it actually maps three different things:

a segment, when 0 <= t <= d
a half-line, when 0 <= t < +infinity, or -infinity < t <= d
a line, when -infinity < t < +infinity

In Opcode, we support segment queries, which yield half-line queries by setting d = +infinity. We don't support line-queries. If you need them, shift the origin along the ray by an appropriate margin.

In short, the lower bound is always 0, and you can setup the higher bound "d" with RayCollider::SetMaxDist().

Query |segment |half-line |line --------|-------------------|---------------|---------------- Usages |-shadow feelers |-raytracing |- |-sweep tests |-in/out tests |

FIRST CONTACT:

You can setup "first contact" mode or "all contacts" mode with RayCollider::SetFirstContact().
In "first contact" mode we return as soon as the ray hits one face. If can be useful e.g. for shadow feelers, where you want to know whether the path to the light is free or not (a boolean answer is enough).
In "all contacts" mode we return all faces hit by the ray.

TEMPORAL COHERENCE:

You can enable or disable temporal coherence with RayCollider::SetTemporalCoherence().
It currently only works in "first contact" mode.
If temporal coherence is enabled, the previously hit triangle is cached during the first query. Then, next queries start by colliding the ray against the cached triangle. If they still collide, we return immediately.

CLOSEST HIT:

You can enable or disable "closest hit" with RayCollider::SetClosestHit().
It currently only works in "all contacts" mode.
If closest hit is enabled, faces are sorted by distance on-the-fly and the closest one only is reported.

BACKFACE CULLING:

You can enable or disable backface culling with RayCollider::SetCulling().
If culling is enabled, ray will not hit back faces (only front faces).

Author:: Pierre Terdiman

Version:: 1.3

Date:: June, 2, 2001

Definition at line 63 of file OPC_RayCollider.h.

Constructor & Destructor Documentation

RayCollider::RayCollider ( )

virtual RayCollider::~RayCollider ( ) [virtual]

Member Function Documentation

void RayCollider::_RayStab ( const AABBCollisionNode * node ) [protected]

void RayCollider::_RayStab ( const AABBNoLeafNode * node ) [protected]

void RayCollider::_RayStab ( const AABBQuantizedNode * node ) [protected]

void RayCollider::_RayStab ( const AABBQuantizedNoLeafNode * node ) [protected]

void RayCollider::_RayStab	(	const AABBTreeNode *	node,
		Container &	box_indices
	)		`[protected]`

void RayCollider::_SegmentStab ( const AABBCollisionNode * node ) [protected]

void RayCollider::_SegmentStab ( const AABBNoLeafNode * node ) [protected]

void RayCollider::_SegmentStab ( const AABBQuantizedNode * node ) [protected]

void RayCollider::_SegmentStab ( const AABBQuantizedNoLeafNode * node ) [protected]

void RayCollider::_SegmentStab	(	const AABBTreeNode *	node,
		Container &	box_indices
	)		`[protected]`

bool RayCollider::Collide	(	const Ray &	world_ray,
		const Model &	model,
		const Matrix4x4 *	world = `null`,
		udword *	cache = `null`
	)

Generic stabbing query for generic OPCODE models. After the call, access the results:

with GetContactStatus()
in the user-provided destination array

Parameters:

world_ray	[in] stabbing ray in world space
model	[in] Opcode model to collide with
world	[in] model's world matrix, or null
cache	[in] a possibly cached face index, or null

Returns:: true if success

Warning:: SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.

bool RayCollider::Collide	(	const Ray &	world_ray,
		const AABBTree *	tree,
		Container &	box_indices
	)

inline_ udword RayCollider::GetNbIntersections ( ) const [inline]

Stats: gets the number of intersection found after a collision query. Can be used for in/out tests.

See also:: GetNbRayBVTests(); GetNbRayPrimTests()

Returns:: the number of valid intersections during last query

Definition at line 168 of file OPC_RayCollider.h.

inline_ udword RayCollider::GetNbRayBVTests ( ) const [inline]

Stats: gets the number of Ray-BV overlap tests after a collision query.

See also:: GetNbRayPrimTests(); GetNbIntersections()

Returns:: the number of Ray-BV tests performed during last query

Definition at line 147 of file OPC_RayCollider.h.

inline_ udword RayCollider::GetNbRayPrimTests ( ) const [inline]

Stats: gets the number of Ray-Triangle overlap tests after a collision query.

See also:: GetNbRayBVTests(); GetNbIntersections()

Returns:: the number of Ray-Triangle tests performed during last query

Definition at line 157 of file OPC_RayCollider.h.

BOOL RayCollider::InitQuery	(	const Ray &	world_ray,
		const Matrix4x4 *	world = `null`,
		udword *	face_id = `null`
	)		`[protected]`

RayCollider::override ( Collider ) const

Validates current settings. You should call this method after all the settings and callbacks have been defined for a collider.

Returns:: null if everything is ok, else a string describing the problem

inline_ BOOL RayCollider::RayAABBOverlap	(	const Point &	center,
		const Point &	extents
	)		`[protected]`

Computes a ray-AABB overlap test using the separating axis theorem. Ray is cached within the class.

Parameters:

center	[in] AABB center
extents	[in] AABB extents

Returns:: true on overlap

Definition at line 40 of file OPC_RayAABBOverlap.h.

inline_ BOOL RayCollider::RayTriOverlap	(	const Point &	vert0,
		const Point &	vert1,
		const Point &	vert2
	)		`[protected]`

Computes a ray-triangle intersection test. Original code from Tomas M�ller's "Fast Minimum Storage Ray-Triangle Intersection". It's been optimized a bit with integer code, and modified to return a non-intersection if distance from ray origin to triangle is negative.

Parameters: