add ode

1 files changed, 764 insertions, 0 deletions

diff --git a/libs/ode-0.16.1/OPCODE/OPC_RayCollider.cpp b/libs/ode-0.16.1/OPCODE/OPC_RayCollider.cpp
new file mode 100644
index 0000000..6a81857
--- /dev/null
+++ b/libs/ode-0.16.1/OPCODE/OPC_RayCollider.cpp
@@ -0,0 +1,764 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+ *	OPCODE - Optimized Collision Detection
+ *	Copyright (C) 2001 Pierre Terdiman
+ *	Homepage: http://www.codercorner.com/Opcode.htm
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Contains code for a ray collider.
+ *	\file		OPC_RayCollider.cpp
+ *	\author		Pierre Terdiman
+ *	\date		June, 2, 2001
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	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).
+ *		
+ *
+ *
+ *	\class		RayCollider
+ *	\author		Pierre Terdiman
+ *	\version	1.3
+ *	\date		June, 2, 2001
+*/
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	This class describes a face hit by a ray or segment.
+ *	This is a particular class dedicated to stabbing queries.
+ *
+ *	\class		CollisionFace
+ *	\author		Pierre Terdiman
+ *	\version	1.3
+ *	\date		March, 20, 2001
+*/
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	This class is a dedicated collection of CollisionFace.
+ *
+ *	\class		CollisionFaces
+ *	\author		Pierre Terdiman
+ *	\version	1.3
+ *	\date		March, 20, 2001
+*/
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Precompiled Header
+#include "Stdafx.h"
+
+using namespace Opcode;
+
+#include "OPC_RayAABBOverlap.h"
+#include "OPC_RayTriOverlap.h"
+
+#define SET_CONTACT(prim_index, flag)											\
+	mNbIntersections++;															\
+	/* Set contact status */													\
+	mFlags |= flag;																\
+	/* In any case the contact has been found and recorded in mStabbedFace  */	\
+	mStabbedFace.mFaceID = prim_index;
+
+#ifdef OPC_RAYHIT_CALLBACK
+
+	#define HANDLE_CONTACT(prim_index, flag)													\
+		SET_CONTACT(prim_index, flag)															\
+																								\
+		if(mHitCallback)	(mHitCallback)(mStabbedFace, mUserData);
+
+	#define UPDATE_CACHE					\
+		if(cache && GetContactStatus())		\
+		{									\
+			*cache	= mStabbedFace.mFaceID;	\
+		}
+#else
+
+	#define HANDLE_CONTACT(prim_index, flag)													\
+		SET_CONTACT(prim_index, flag)															\
+																								\
+		/* Now we can also record it in mStabbedFaces if available */							\
+		if(mStabbedFaces)																		\
+		{																						\
+			/* If we want all faces or if that's the first one we hit */						\
+			if(!mClosestHit || !mStabbedFaces->GetNbFaces())									\
+			{																					\
+				mStabbedFaces->AddFace(mStabbedFace);											\
+			}																					\
+			else																				\
+			{																					\
+				/* We only keep closest hit */													\
+				CollisionFace* Current = const_cast<CollisionFace*>(mStabbedFaces->GetFaces());	\
+				if(Current && mStabbedFace.mDistance<Current->mDistance)						\
+				{																				\
+					*Current = mStabbedFace;													\
+				}																				\
+			}																					\
+		}
+
+	#define UPDATE_CACHE												\
+		if(cache && GetContactStatus() && mStabbedFaces)				\
+		{																\
+			const CollisionFace* Current = mStabbedFaces->GetFaces();	\
+			if(Current)	*cache	= Current->mFaceID;						\
+			else		*cache	= INVALID_ID;							\
+		}
+#endif
+
+#define SEGMENT_PRIM(prim_index, flag)														\
+	/* Request vertices from the app */														\
+	VertexPointers VP;	ConversionArea VC;	mIMesh->GetTriangle(VP, prim_index, VC);		\
+																							\
+	/* Perform ray-tri overlap test and return */											\
+	if(RayTriOverlap(*VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2]))							\
+	{																						\
+		/* Intersection point is valid if dist < segment's length */						\
+		/* We know dist>0 so we can use integers */											\
+		if(IR(mStabbedFace.mDistance)<IR(mMaxDist))											\
+		{																					\
+			HANDLE_CONTACT(prim_index, flag)												\
+		}																					\
+	}
+
+#define RAY_PRIM(prim_index, flag)															\
+	/* Request vertices from the app */														\
+	VertexPointers VP;	ConversionArea VC;	mIMesh->GetTriangle(VP, prim_index, VC);		\
+																							\
+	/* Perform ray-tri overlap test and return */											\
+	if(RayTriOverlap(*VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2]))							\
+	{																						\
+		HANDLE_CONTACT(prim_index, flag)													\
+	}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Constructor.
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+RayCollider::RayCollider() :
+#ifdef OPC_RAYHIT_CALLBACK
+	mHitCallback		(null),
+	mUserData			(0),
+#else
+	mStabbedFaces		(null),
+	mClosestHit			(false),
+#endif
+	mNbRayBVTests		(0),
+	mNbRayPrimTests		(0),
+	mNbIntersections	(0),
+	mMaxDist			(MAX_FLOAT),
+	mCulling			(true)
+
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Destructor.
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+RayCollider::~RayCollider()
+{
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Validates current settings. You should call this method after all the settings and callbacks have been defined.
+ *	\return		null if everything is ok, else a string describing the problem
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+const char* RayCollider::ValidateSettings()
+{
+	if(mMaxDist<0.0f)											return "Higher distance bound must be positive!";
+	if(TemporalCoherenceEnabled() && !FirstContactEnabled())	return "Temporal coherence only works with ""First contact"" mode!";
+#ifndef OPC_RAYHIT_CALLBACK
+	if(mClosestHit && FirstContactEnabled())					return "Closest hit doesn't work with ""First contact"" mode!";
+	if(TemporalCoherenceEnabled() && mClosestHit)				return "Temporal coherence can't guarantee to report closest hit!";
+#endif
+	if(SkipPrimitiveTests())									return "SkipPrimitiveTests not possible for RayCollider ! (not implemented)";
+	return null;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Generic stabbing query for generic OPCODE models. After the call, access the results:
+ *	- with GetContactStatus()
+ *	- in the user-provided destination array
+ *
+ *	\param		world_ray		[in] stabbing ray in world space
+ *	\param		model			[in] Opcode model to collide with
+ *	\param		world			[in] model's world matrix, or null
+ *	\param		cache			[in] a possibly cached face index, or null
+ *	\return		true if success
+ *	\warning	SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+bool RayCollider::Collide(const Ray& world_ray, const Model& model, const Matrix4x4* world, udword* cache)
+{
+	// 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 = static_cast<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 = static_cast<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 = static_cast<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 = static_cast<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;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Initializes a stabbing query :
+ *	- reset stats & contact status
+ *	- compute ray in local space
+ *	- check temporal coherence
+ *
+ *	\param		world_ray	[in] stabbing ray in world space
+ *	\param		world		[in] object's world matrix, or null
+ *	\param		face_id		[in] index of previously stabbed triangle
+ *	\return		TRUE if we can return immediately
+ *	\warning	SCALE NOT SUPPORTED. The matrix must contain rotation & translation parts only.
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+BOOL RayCollider::InitQuery(const Ray& world_ray, const Matrix4x4* world, udword* face_id)
+{
+	// 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;
+			ConversionArea VC;
+			mIMesh->GetTriangle(VP, *face_id, VC);
+			// 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;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Stabbing query for vanilla AABB trees.
+ *	\param		world_ray		[in] stabbing ray in world space
+ *	\param		tree			[in] AABB tree
+ *	\param		box_indices		[out] indices of stabbed boxes
+ *	\return		true if success
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+bool RayCollider::Collide(const Ray& world_ray, const AABBTree* tree, Container& box_indices)
+{
+	// ### 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".
+	ASSERT( !(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;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for normal AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_SegmentStab(const AABBCollisionNode* node)
+{
+	// 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());
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for quantized AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_SegmentStab(const AABBQuantizedNode* node)
+{
+	// 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());
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for no-leaf AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_SegmentStab(const AABBNoLeafNode* node)
+{
+	// 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());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for quantized no-leaf AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_SegmentStab(const AABBQuantizedNoLeafNode* node)
+{
+	// 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());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for vanilla AABB trees.
+ *	\param		node		[in] current collision node
+ *	\param		box_indices	[out] indices of stabbed boxes
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_SegmentStab(const AABBTreeNode* node, Container& box_indices)
+{
+	// 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);
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for normal AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_RayStab(const AABBCollisionNode* node)
+{
+	// 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());
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for quantized AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_RayStab(const AABBQuantizedNode* node)
+{
+	// 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());
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for no-leaf AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_RayStab(const AABBNoLeafNode* node)
+{
+	// 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());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for quantized no-leaf AABB trees.
+ *	\param		node	[in] current collision node
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_RayStab(const AABBQuantizedNoLeafNode* node)
+{
+	// 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());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Recursive stabbing query for vanilla AABB trees.
+ *	\param		node		[in] current collision node
+ *	\param		box_indices	[out] indices of stabbed boxes
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void RayCollider::_RayStab(const AABBTreeNode* node, Container& box_indices)
+{
+	// 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);
+	}
+}