#include <Opcode.h>

Inheritance diagram for Opcode::RayCollider:

Public Member Functions
	RayCollider ()

virtual	~RayCollider ()

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_ void	SetCulling (bool flag)

inline_ void	SetMaxDist (float max_dist=MAX_FLOAT)

inline_ void	SetHitCallback (HitCallback cb)

inline_ void	SetUserData (void *user_data)

inline_ udword	GetNbRayBVTests () const

inline_ udword	GetNbRayPrimTests () const

inline_ udword	GetNbIntersections () const

	override (Collider) const char *ValidateSettings()

Public Member Functions inherited from Opcode::Collider
	Collider ()

virtual	~Collider ()

inline_ BOOL	GetContactStatus () const

inline_ BOOL	FirstContactEnabled () const

inline_ BOOL	TemporalCoherenceEnabled () const

inline_ BOOL	ContactFound () const

inline_ BOOL	TemporalHit () const

inline_ BOOL	SkipPrimitiveTests () const

inline_ void	SetFirstContact (bool flag)

inline_ void	SetTemporalCoherence (bool flag)

inline_ void	SetPrimitiveTests (bool flag)

virtual const char *	ValidateSettings ()=0

Protected Member Functions
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)

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)

inline_ bool	RayAABBOverlap (const Point &center, const Point &extents)

inline_ bool	SegmentAABBOverlap (const Point &center, const Point &extents)

inline_ bool	RayTriOverlap (const Point &vert0, const Point &vert1, const Point &vert2)

bool	InitQuery (const Ray &world_ray, const Matrix4x4 world=null, udword face_id=null)

Protected Member Functions inherited from Opcode::Collider
inline_ BOOL	Setup (const BaseModel *model)

virtual inline_ void	InitQuery ()

Protected Attributes
Point	mOrigin
	Ray origin. More...

Point	mDir
	Ray direction (normalized) More...

Point	mFDir
	fabsf(mDir) More...

Point	mData

Point	mData2

CollisionFace	mStabbedFace
	Current stabbed face. More...

HitCallback	mHitCallback
	Callback used to record a hit. More...

void *	mUserData
	User-defined data. More...

udword	mNbRayBVTests
	Number of Ray-BV tests. More...

udword	mNbRayPrimTests
	Number of Ray-Primitive tests. More...

udword	mNbIntersections
	Number of valid intersections. More...

Point	mCenterCoeff

Point	mExtentsCoeff

float	mMaxDist
	Valid segment on the ray. More...

bool	mCulling
	Stab culled faces or not. More...

Protected Attributes inherited from Opcode::Collider
udword	mFlags
	Bit flags. More...

const BaseModel *	mCurrentModel
	Current model for collision query (owner of touched faces) More...

const MeshInterface *	mIMesh
	User-defined mesh interface. More...

Detailed Description

Definition at line 64 of file Opcode.h.

Constructor & Destructor Documentation

RayCollider::RayCollider ( )

Constructor.

Definition at line 206 of file OPC_RayCollider.cpp.

                          :
 #ifdef OPC_RAYHIT_CALLBACK
     mHitCallback        (null),
     mUserData           (0),
 #else
     mStabbedFaces       (null),
 #endif
     mNbRayBVTests       (0),
     mNbRayPrimTests     (0),
     mNbIntersections    (0),
     mMaxDist            (MAX_FLOAT),
 #ifndef OPC_RAYHIT_CALLBACK
     mClosestHit         (false),
 #endif
     mCulling            (true)
 {
 }

RayCollider::~RayCollider ( )

virtual

Destructor.

Definition at line 229 of file OPC_RayCollider.cpp.

230 {

231 }

Member Function Documentation

void RayCollider::_RayStab ( const AABBCollisionNode * node)

protected

Recursive stabbing query for normal AABB trees.

Parameters

node	[in] current collision node

Definition at line 634 of file OPC_RayCollider.cpp.

 {
     // Perform Ray-AABB overlap test
     if(!RayAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents))  return;
 
     if(node->IsLeaf())
     {
         RAY_PRIM(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _RayStab(node->GetPos());
 
         if(ContactFound()) return;
 
         _RayStab(node->GetNeg());
     }
 }

void RayCollider::_RayStab ( const AABBNoLeafNode * node)

protected

Recursive stabbing query for no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 689 of file OPC_RayCollider.cpp.

 {
     // Perform Ray-AABB overlap test
     if(!RayAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents))  return;
 
     if(node->HasPosLeaf())
     {
         RAY_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
     }
     else _RayStab(node->GetPos());
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())
     {
         RAY_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
     }
     else _RayStab(node->GetNeg());
 }

void RayCollider::_RayStab ( const AABBQuantizedNode * node)

protected

Recursive stabbing query for quantized AABB trees.

Parameters

node	[in] current collision node

Definition at line 659 of file OPC_RayCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Perform Ray-AABB overlap test
     if(!RayAABBOverlap(Center, Extents))    return;
 
     if(node->IsLeaf())
     {
         RAY_PRIM(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _RayStab(node->GetPos());
 
         if(ContactFound()) return;
 
         _RayStab(node->GetNeg());
     }
 }

void RayCollider::_RayStab ( const AABBQuantizedNoLeafNode * node)

protected

Recursive stabbing query for quantized no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 715 of file OPC_RayCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Perform Ray-AABB overlap test
     if(!RayAABBOverlap(Center, Extents))    return;
 
     if(node->HasPosLeaf())
     {
         RAY_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
     }
     else _RayStab(node->GetPos());
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())
     {
         RAY_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
     }
     else _RayStab(node->GetNeg());
 }

void RayCollider::_RayStab	(	const AABBTreeNode *	node,
		Container &	box_indices
	)

protected

Recursive stabbing query for vanilla AABB trees.

Parameters

node	[in] current collision node
box_indices	[out] indices of stabbed boxes

Definition at line 747 of file OPC_RayCollider.cpp.

 {
     // Test the box against the ray
     Point Center, Extents;
     node->GetAABB()->GetCenter(Center);
     node->GetAABB()->GetExtents(Extents);
     if(!RayAABBOverlap(Center, Extents))    return;
     if(node->IsLeaf())
     {
         mFlags |= OPC_CONTACT;
         box_indices.Add(node->GetPrimitives(), node->GetNbPrimitives());
     }
     else
     {
         _RayStab(node->GetPos(), box_indices);
         _RayStab(node->GetNeg(), box_indices);
     }
 }

void RayCollider::_SegmentStab ( const AABBCollisionNode * node)

protected

Recursive stabbing query for normal AABB trees.

Parameters

node	[in] current collision node

Definition at line 496 of file OPC_RayCollider.cpp.

 {
     // Perform Segment-AABB overlap test
     if(!SegmentAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents))  return;
 
     if(node->IsLeaf())
     {
         SEGMENT_PRIM(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _SegmentStab(node->GetPos());
 
         if(ContactFound()) return;
 
         _SegmentStab(node->GetNeg());
     }
 }

void RayCollider::_SegmentStab ( const AABBNoLeafNode * node)

protected

Recursive stabbing query for no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 551 of file OPC_RayCollider.cpp.

 {
     // Perform Segment-AABB overlap test
     if(!SegmentAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents))  return;
 
     if(node->HasPosLeaf())
     {
         SEGMENT_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
     }
     else _SegmentStab(node->GetPos());
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())
     {
         SEGMENT_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
     }
     else _SegmentStab(node->GetNeg());
 }

void RayCollider::_SegmentStab ( const AABBQuantizedNode * node)

protected

Recursive stabbing query for quantized AABB trees.

Parameters

node	[in] current collision node

Definition at line 521 of file OPC_RayCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Perform Segment-AABB overlap test
     if(!SegmentAABBOverlap(Center, Extents))    return;
 
     if(node->IsLeaf())
     {
         SEGMENT_PRIM(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _SegmentStab(node->GetPos());
 
         if(ContactFound()) return;
 
         _SegmentStab(node->GetNeg());
     }
 }

void RayCollider::_SegmentStab ( const AABBQuantizedNoLeafNode * node)

protected

Recursive stabbing query for quantized no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 577 of file OPC_RayCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Perform Segment-AABB overlap test
     if(!SegmentAABBOverlap(Center, Extents))    return;
 
     if(node->HasPosLeaf())
     {
         SEGMENT_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
     }
     else _SegmentStab(node->GetPos());
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())
     {
         SEGMENT_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
     }
     else _SegmentStab(node->GetNeg());
 }

void RayCollider::_SegmentStab	(	const AABBTreeNode *	node,
		Container &	box_indices
	)

protected

Recursive stabbing query for vanilla AABB trees.

Parameters

node	[in] current collision node
box_indices	[out] indices of stabbed boxes

Definition at line 609 of file OPC_RayCollider.cpp.

 {
     // Test the box against the segment
     Point Center, Extents;
     node->GetAABB()->GetCenter(Center);
     node->GetAABB()->GetExtents(Extents);
     if(!SegmentAABBOverlap(Center, Extents))    return;
 
     if(node->IsLeaf())
     {
         box_indices.Add(node->GetPrimitives(), node->GetNbPrimitives());
     }
     else
     {
         _SegmentStab(node->GetPos(), box_indices);
         _SegmentStab(node->GetNeg(), box_indices);
     }
 }

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.

Definition at line 265 of file OPC_RayCollider.cpp.

Referenced by Opcode::Picking().

 {
     // Checkings
     if(!Setup(&model))  return false;
 
     // Init collision query
     if(InitQuery(world_ray, world, cache))  return true;
 
     if(!model.HasLeafNodes())
     {
         if(model.IsQuantized())
         {
             const AABBQuantizedNoLeafTree* Tree = (const AABBQuantizedNoLeafTree*)model.GetTree();
 
             // Setup dequantization coeffs
             mCenterCoeff    = Tree->mCenterCoeff;
             mExtentsCoeff   = Tree->mExtentsCoeff;
 
             // Perform stabbing query
             if(IR(mMaxDist)!=IEEE_MAX_FLOAT)    _SegmentStab(Tree->GetNodes());
             else                                _RayStab(Tree->GetNodes());
         }
         else
         {
             const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
 
             // Perform stabbing query
             if(IR(mMaxDist)!=IEEE_MAX_FLOAT)    _SegmentStab(Tree->GetNodes());
             else                                _RayStab(Tree->GetNodes());
         }
     }
     else
     {
         if(model.IsQuantized())
         {
             const AABBQuantizedTree* Tree = (const AABBQuantizedTree*)model.GetTree();
 
             // Setup dequantization coeffs
             mCenterCoeff    = Tree->mCenterCoeff;
             mExtentsCoeff   = Tree->mExtentsCoeff;
 
             // Perform stabbing query
             if(IR(mMaxDist)!=IEEE_MAX_FLOAT)    _SegmentStab(Tree->GetNodes());
             else                                _RayStab(Tree->GetNodes());
         }
         else
         {
             const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
 
             // Perform stabbing query
             if(IR(mMaxDist)!=IEEE_MAX_FLOAT)    _SegmentStab(Tree->GetNodes());
             else                                _RayStab(Tree->GetNodes());
         }
     }
 
     // Update cache if needed
     UPDATE_CACHE
     return true;
 }

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

Stabbing query for vanilla AABB trees.

Parameters

world_ray	[in] stabbing ray in world space
tree	[in] AABB tree
box_indices	[out] indices of stabbed boxes

Returns: true if success

Definition at line 466 of file OPC_RayCollider.cpp.

 {
     // ### bad design here
 
     // This is typically called for a scene tree, full of -AABBs-, not full of triangles.
     // So we don't really have "primitives" to deal with. Hence it doesn't work with
     // "FirstContact" + "TemporalCoherence".
     OPASSERT( !(FirstContactEnabled() && TemporalCoherenceEnabled()) );
 
     // Checkings
     if(!tree)                   return false;
 
     // Init collision query
     // Basically this is only called to initialize precomputed data
     if(InitQuery(world_ray))    return true;
 
     // Perform stabbing query
     if(IR(mMaxDist)!=IEEE_MAX_FLOAT)    _SegmentStab(tree, box_indices);
     else                                _RayStab(tree, box_indices);
 
     return true;
 }

inline_ udword Opcode::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 169 of file Opcode.h.

inline_ udword Opcode::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 148 of file Opcode.h.

inline_ udword Opcode::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 158 of file Opcode.h.

bool RayCollider::InitQuery	(	const Ray &	world_ray,
		const Matrix4x4 *	world = `null`,
		udword *	face_id = `null`
	)

protected

Initializes a stabbing query :

reset stats & contact status
compute ray in local space
check temporal coherence

Parameters

world_ray	[in] stabbing ray in world space
world	[in] object's world matrix, or null
face_id	[in] index of previously stabbed triangle

Returns: TRUE if we can return immediately

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

Definition at line 340 of file OPC_RayCollider.cpp.

 {
     // Reset stats & contact status
     Collider::InitQuery();
     mNbRayBVTests       = 0;
     mNbRayPrimTests     = 0;
     mNbIntersections    = 0;
 #ifndef OPC_RAYHIT_CALLBACK
     if(mStabbedFaces)   mStabbedFaces->Reset();
 #endif
 
     // Compute ray in local space
     // The (Origin/Dir) form is needed for the ray-triangle test anyway (even for segment tests)
     if(world)
     {
         Matrix3x3 InvWorld = *world;
         mDir = InvWorld * world_ray.mDir;
 
         Matrix4x4 World;
         InvertPRMatrix(World, *world);
         mOrigin = world_ray.mOrig * World;
     }
     else
     {
         mDir    = world_ray.mDir;
         mOrigin = world_ray.mOrig;
     }
 
     // 4) Special case: 1-triangle meshes [Opcode 1.3]
     if(mCurrentModel && mCurrentModel->HasSingleNode())
     {
         // We simply perform the BV-Prim overlap test each time. We assume single triangle has index 0.
         if(!SkipPrimitiveTests())
         {
             // Perform overlap test between the unique triangle and the ray (and set contact status if needed)
             SEGMENT_PRIM(udword(0), OPC_CONTACT)
 
             // Return immediately regardless of status
             return TRUE;
         }
     }
 
     // Check temporal coherence :
 
     // Test previously colliding primitives first
     if(TemporalCoherenceEnabled() && FirstContactEnabled() && face_id && *face_id!=INVALID_ID)
     {
 #ifdef OLD_CODE
 #ifndef OPC_RAYHIT_CALLBACK
         if(!mClosestHit)
 #endif
         {
             // Request vertices from the app
             VertexPointers VP;
             mIMesh->GetTriangle(VP, *face_id);
             // Perform ray-cached tri overlap test
             if(RayTriOverlap(*VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2]))
             {
                 // Intersection point is valid if:
                 // - distance is positive (else it can just be a face behind the orig point)
                 // - distance is smaller than a given max distance (useful for shadow feelers)
 //              if(mStabbedFace.mDistance>0.0f && mStabbedFace.mDistance<mMaxDist)
                 if(IR(mStabbedFace.mDistance)<IR(mMaxDist)) // The other test is already performed in RayTriOverlap
                 {
                     // Set contact status
                     mFlags |= OPC_TEMPORAL_CONTACT;
 
                     mStabbedFace.mFaceID = *face_id;
 
 #ifndef OPC_RAYHIT_CALLBACK
                     if(mStabbedFaces)   mStabbedFaces->AddFace(mStabbedFace);
 #endif
                     return TRUE;
                 }
             }
         }
 #else
         // New code
         // We handle both Segment/ray queries with the same segment code, and a possible infinite limit
         SEGMENT_PRIM(*face_id, OPC_TEMPORAL_CONTACT)
 
         // Return immediately if possible
         if(GetContactStatus())  return TRUE;
 #endif
     }
 
     // Precompute data (moved after temporal coherence since only needed for ray-AABB)
     if(IR(mMaxDist)!=IEEE_MAX_FLOAT)
     {
         // For Segment-AABB overlap
         mData = 0.5f * mDir * mMaxDist;
         mData2 = mOrigin + mData;
 
         // Precompute mFDir;
         mFDir.x = fabsf(mData.x);
         mFDir.y = fabsf(mData.y);
         mFDir.z = fabsf(mData.z);
     }
     else
     {
         // For Ray-AABB overlap
 //      udword x = SIR(mDir.x)-1;
 //      udword y = SIR(mDir.y)-1;
 //      udword z = SIR(mDir.z)-1;
 //      mData.x = FR(x);
 //      mData.y = FR(y);
 //      mData.z = FR(z);
 
         // Precompute mFDir;
         mFDir.x = fabsf(mDir.x);
         mFDir.y = fabsf(mDir.y);
         mFDir.z = fabsf(mDir.z);
     }
 
     return FALSE;
 }

Opcode::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 Opcode::RayCollider::RayAABBOverlap	(	const Point &	center,
		const Point &	extents
	)

protected

inline_ bool Opcode::RayCollider::RayTriOverlap	(	const Point &	vert0,
		const Point &	vert1,
		const Point &	vert2
	)

protected

inline_ bool Opcode::RayCollider::SegmentAABBOverlap	(	const Point &	center,
		const Point &	extents
	)

protected

inline_ void Opcode::RayCollider::SetCulling ( bool flag)

inline

Settings: enable or disable backface culling.

Parameters

flag	[in] true to enable backface culling

See Also: SetClosestHit(bool flag); SetMaxDist(float max_dist); SetDestination(StabbedFaces* sf)

Definition at line 111 of file Opcode.h.

Referenced by Opcode::Picking().

inline_ void Opcode::RayCollider::SetHitCallback ( HitCallback cb)

inline

Definition at line 125 of file Opcode.h.

Referenced by Opcode::Picking(), Opcode::SetupAllHits(), Opcode::SetupClosestHit(), Opcode::SetupInOutTest(), and Opcode::SetupShadowFeeler().

inline_ void Opcode::RayCollider::SetMaxDist ( float max_dist = MAX_FLOAT)

inline

Settings: sets the higher distance bound.

Parameters

max_dist [in] higher distance bound. Default = maximal value, for ray queries (else segment)

See Also: SetClosestHit(bool flag); SetCulling(bool flag); SetDestination(StabbedFaces* sf)

Definition at line 122 of file Opcode.h.

Referenced by Opcode::Picking().

inline_ void Opcode::RayCollider::SetUserData ( void * user_data)

inline

Definition at line 126 of file Opcode.h.

Referenced by Opcode::Picking(), Opcode::SetupAllHits(), and Opcode::SetupClosestHit().

Member Data Documentation

Point Opcode::RayCollider::mCenterCoeff

protected

Definition at line 199 of file Opcode.h.

bool Opcode::RayCollider::mCulling

protected

Stab culled faces or not.

Definition at line 206 of file Opcode.h.

Point Opcode::RayCollider::mData

protected

Definition at line 184 of file Opcode.h.

Point Opcode::RayCollider::mData2

protected

Definition at line 184 of file Opcode.h.

Point Opcode::RayCollider::mDir

protected

Ray direction (normalized)

Definition at line 182 of file Opcode.h.

Point Opcode::RayCollider::mExtentsCoeff

protected

Definition at line 200 of file Opcode.h.

Point Opcode::RayCollider::mFDir

protected

fabsf(mDir)

Definition at line 183 of file Opcode.h.

HitCallback Opcode::RayCollider::mHitCallback

protected

Callback used to record a hit.

Definition at line 188 of file Opcode.h.

float Opcode::RayCollider::mMaxDist

protected

Valid segment on the ray.

Definition at line 202 of file Opcode.h.

udword Opcode::RayCollider::mNbIntersections

protected

Number of valid intersections.

Definition at line 197 of file Opcode.h.

udword Opcode::RayCollider::mNbRayBVTests

protected

Number of Ray-BV tests.

Definition at line 194 of file Opcode.h.

udword Opcode::RayCollider::mNbRayPrimTests

protected

Number of Ray-Primitive tests.

Definition at line 195 of file Opcode.h.

Point Opcode::RayCollider::mOrigin

protected

Ray origin.

Definition at line 181 of file Opcode.h.

CollisionFace Opcode::RayCollider::mStabbedFace

protected

Current stabbed face.

Definition at line 186 of file Opcode.h.

void* Opcode::RayCollider::mUserData

protected

User-defined data.

Definition at line 189 of file Opcode.h.

The documentation for this class was generated from the following files:

src/cmd/collide2/OPC_RayCollider.h
src/cmd/collide2/OPC_RayCollider.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation