BVHTree_BinarySphere< T > Class Template Reference

BVHTree_BinarySphere class is a class for Binary Sphere Boundary Volume Hierarchy Tree. More...

#include <TAPsBVHTree_BinarySphere.hpp>

Inheritance diagram for BVHTree_BinarySphere< T >:

[legend]

Collaboration diagram for BVHTree_BinarySphere< T >:

[legend]

List of all members.

Public Member Functions
	BVHTree_BinarySphere (TransformationSupport< T > &transform, HEFaceList< T > *heFaceList)
	BVHTree_BinarySphere (TransformationSupport< T > &transform, Enum::CD type=Enum::UNDEFINED_TREE, int numOfNodes=0, BVHNode< T > *rootNode=NULL)
virtual bool	TestIntersectionWithLineSegmentTillLeafNodes (Vector3< T > const *const ptA, Vector3< T > const *const ptB)
virtual bool	TestOverlapWith (BoundingVolume< T > const *const pBV)
virtual bool	TestOverlapWith (MultiBoundingVolume< T > const *const pMBV)
virtual bool	TestOverlapWith (BVHNode< T > const *const node)
virtual bool	TestOverlapWith (BVHTree< T > const *const that)
virtual bool	TestOverlapWithTillLeafNodes (BoundingVolume< T > const *const pBV)
virtual bool	TestOverlapWithTillLeafNodes (MultiBoundingVolume< T > const *const pMBV)
virtual bool	TestOverlapWithTillLeafNodes (BVHNode< T > const *const node)
virtual bool	TestOverlapWithTillLeafNodes (BVHTree< T > const *const that)
virtual	~BVHTree_BinarySphere ()
Static Public Member Functions
static BVHTree< T > *	Build (TransformationSupport< T > &transform, std::list< HEFace< T > * > const *const heFaceList, Enum::CD treeType, BVHTree< T > *cdtree)
	O/P: pointer to BVHTree.
Protected Member Functions
void	ForBVCylinderTransformations (Matrix4x4< T > const &nodeTransform_IP, BoundingVolume< T > const *const pBV, Matrix4x4< T > const &bvTransformation, Matrix4x4< T > &nodeTransform_OP)
void	ForBVCylinderTransformations (Matrix4x4< T > const &nodeTransform_IP, BoundingVolume< T > const *const pBV, Matrix4x4< T > &nodeTransform_OP)
void	ForBVCylinderTransformations (BoundingVolume< T > const *const pBV, Matrix4x4< T > const &bvTransformation, Matrix4x4< T > &nodeTransform_OP)
void	ForBVCylinderTransformations (BoundingVolume< T > const *const pBV, Matrix4x4< T > &nodeTransform_OP)
void	ForBVSphereTransformations (BoundingVolume< T > const *const pBV, Matrix4x4< T > const &bvTransformation, Vector3< T > &sphereCenter, T &sphereRadius)
	Transform BV sphere's center and radius.
bool	TestIntersectionWithLineSegmentTillLeafNodesRecursive (BVHNode< T > const *const node, Vector3< T > const *const ptA, Vector3< T > const *const ptB)
virtual bool	TestOverlap_vs_BinarySphere (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BVHNode< T > const *const nodeB, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BinarySphere (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BVHNode< T > const *const nodeB)
virtual bool	TestOverlap_vs_BinarySphere (BVHNode< T > const *const nodeA, BVHNode< T > const *const nodeB, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BinarySphere (BVHNode< T > const *const nodeA, BVHNode< T > const *const nodeB)
virtual bool	TestOverlap_vs_BinarySphere_TillLeafNodes (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BVHNode< T > const *const nodeB, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BinarySphere_TillLeafNodes (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BVHNode< T > const *const nodeB)
virtual bool	TestOverlap_vs_BinarySphere_TillLeafNodes (BVHNode< T > const *const nodeA, BVHNode< T > const *const nodeB, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BinarySphere_TillLeafNodes (BVHNode< T > const *const nodeA, BVHNode< T > const *const nodeB)
virtual bool	TestOverlap_vs_BV (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BoundingVolume< T > const *const pBV, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BV (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BoundingVolume< T > const *const pBV)
virtual bool	TestOverlap_vs_BV (BVHNode< T > const *const nodeA, BoundingVolume< T > const *const pBV, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BV (BVHNode< T > const *const nodeA, BoundingVolume< T > const *const pBV)
bool	TestOverlap_vs_BV_Cylinder_AtOrigin (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, T cylinderRadius, T cylinderHeight)
bool	TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, T cylinderRadius, T cylinderHeight)
bool	TestOverlap_vs_BV_Sphere (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, Vector3< T > const &sphereCenter, T sphereRadius)
bool	TestOverlap_vs_BV_Sphere (BVHNode< T > const *const nodeA, Vector3< T > const &sphereCenter, T sphereRadius)
	Remark: existing transformB is already applied to sphereCenter and sphereRadius.
bool	TestOverlap_vs_BV_Sphere_TillLeafNodes (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, Vector3< T > const &sphereCenter, T sphereRadius)
bool	TestOverlap_vs_BV_Sphere_TillLeafNodes (BVHNode< T > const *const nodeA, Vector3< T > const &sphereCenter, T sphereRadius)
	Remark: existing transformB is already applied to sphereCenter and sphereRadius.
virtual bool	TestOverlap_vs_BV_TillLeafNodes (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BoundingVolume< T > const *const pBV, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BV_TillLeafNodes (BVHNode< T > const *const nodeA, Matrix4x4< T > const &transformA, BoundingVolume< T > const *const pBV)
virtual bool	TestOverlap_vs_BV_TillLeafNodes (BVHNode< T > const *const nodeA, BoundingVolume< T > const *const pBV, Matrix4x4< T > const &transformB)
virtual bool	TestOverlap_vs_BV_TillLeafNodes (BVHNode< T > const *const nodeA, BoundingVolume< T > const *const pBV)
Static Private Member Functions
static BVHTree< T > *	BSphereBuild (TransformationSupport< T > &transform, const std::list< HEFace< T > * > &heFaceList, BVHTree< T > *cdtree)
	O/P: pointer to BVHTree.
static void	BSphereBuildChildren (BVHNode< T > *pParentNode, const std::list< HEFace< T > * > &heFaceList, Vector3< T > const &principleVector)
static int	BSphereDetermineFaceGroup (HEFace< T > *face, const Vector3< T > &center, const Vector3< T > &direction)
static void	BSphereDivideToFaceGroups (const std::list< HEFace< T > * > &faces, std::list< HEFace< T > * > &group1, std::list< HEFace< T > * > &group2, const Vector3< T > &center, const Vector3< T > &direction)
static BVHNode< T > *	CreateBVHNodeBSphere (BVHNode< T > *pParentNode, const std::list< HEFace< T > * > &heFaceList)
Friends
std::ostream &	operator<< (std::ostream &output, BVHTree_BinarySphere< T > const &obj)

---

Detailed Description

template<typename T>
class BVHTree_BinarySphere< T >

BVHTree_BinarySphere class is a class for Binary Sphere Boundary Volume Hierarchy Tree.

See also:

TAPsCDLib.hpp for details about Collision Detection implemented in TAPs.

Definition at line 25 of file TAPsBVHTree_BinarySphere.hpp.

---

Constructor & Destructor Documentation

template<typename T>

BEGIN_NAMESPACE_TAPs BVHTree_BinarySphere< T >::BVHTree_BinarySphere	(	TransformationSupport< T > &	transform,
		Enum::CD	type = Enum::UNDEFINED_TREE,
		int	numOfNodes = 0,
		BVHNode< T > *	rootNode = NULL
	)			[inline]

Definition at line 18 of file TAPsBVHTree_BinarySphere.cpp.

    : BVHTree<T>( transform, type, numOfNodes, rootNode )
{}

template<typename T>

BVHTree_BinarySphere< T >::BVHTree_BinarySphere	(	TransformationSupport< T > &	transform,
		HEFaceList< T > *	heFaceList
	)			[inline]

Parameters:

transform	I/O: Transform
heFaceList	I/P: half-edge face list

Definition at line 27 of file TAPsBVHTree_BinarySphere.cpp.

                                                    : Transform
    HEFaceList<T> * heFaceList              
)
    : BVHTree<T>( transform )
{
    //-----------------------------------------------------
    // Copy original face list (heFaceList) to a list 
    // of face (faceList)
    std::list< HEFace<T> * > faceList;
    HEFace<T> * face = heFaceList->Head();
    while ( face ) {
        faceList.push_back( face );
        face = face->Next();
    }

    m_eType = Enum::BVH_TREE_BINARY_SPHERE;
    m_iTotalNodes = 1;
    m_Transform = transform;
    m_pRoot = CreateBVHNodeBSphere( NULL, faceList );

    Vector3<T> U, V, W;
    FindOBBOfFaceList( faceList, m_pRoot->GetCenter(), U, V, W );
    if ( m_pRoot )  BSphereBuildChildren( m_pRoot, faceList, U );

    FindListOfLeafNodes();

    SetNumOfNodes( CountNodes() );
}

template<typename T>

BVHTree_BinarySphere< T >::~BVHTree_BinarySphere

(

)

[inline, virtual]

Definition at line 58 of file TAPsBVHTree_BinarySphere.cpp.

{}

---

Member Function Documentation

template<typename T>

BVHTree< T > * BVHTree_BinarySphere< T >::BSphereBuild	(	TransformationSupport< T > &	transform,
		const std::list< HEFace< T > * > &	heFaceList,
		BVHTree< T > *	cdtree
	)			[inline, static, private]

O/P: pointer to BVHTree.

Parameters:

transform	I/O: Transform
heFaceList	I/P: half-edge face list

Definition at line 1816 of file TAPsBVHTree_BinarySphere.cpp.

                                                          : Transform
        const std::list< HEFace<T>* > & heFaceList, // I/P half-edge face list
        BVHTree<T> * cdtree )                       // O/P pointer to BVHTree
{
    //std::cout << "BSphereBuild (before): " << cdtree << std::endl;
    BVHNode<T> *node = CreateBVHNodeBSphere( NULL, heFaceList );
//  node->listHEFace  = heFaceList;         // DEBUG
    cdtree = new BVHTree<T>( transform, Enum::BVH_TREE_BINARY_SPHERE, 1, node );
    //FindOBBOfFaceList( heFaceList, node );
    Vector3<T> U, V, W;
    FindOBBOfFaceList( heFaceList, node->GetCenter(), U, V, W );
    if ( node ) BSphereBuildChildren( node, heFaceList, U );
    //std::cout << "BSphereBuild (after): " << cdtree << std::endl;

    SetNumOfNodes( CountNodes() );
    return cdtree;
}

template<typename T>

void BVHTree_BinarySphere< T >::BSphereBuildChildren	(	BVHNode< T > *	pParentNode,
		const std::list< HEFace< T > * > &	heFaceList,
		Vector3< T > const &	principleVector
	)			[inline, static, private]

Definition at line 1837 of file TAPsBVHTree_BinarySphere.cpp.

{
    int size = static_cast<int>( heFaceList.size() );
    std::list< HEFace<T> * > leftGroup, rightGroup;
    //---------------------------------------------------------------
    // CASE: one face
    // This is a leaf node.
    assert( size > 0 );         // ASSERT
    if ( 1 == size ) {
        return;
    }
    //---------------------------------------------------------------
    assert( pParentNode );          // ASSERT
    BVHNode<T> * leftChild  = NULL;
    BVHNode<T> * rightChild = NULL;
    //---------------------------------------------------------------
    // CASE: two faces
    // Create Two Leaf Nodes
    if ( 2 == size ) {
        //-------------------------------------------------
        // Separate two faces into left and right groups
        std::list< HEFace<T> * >::const_iterator face = heFaceList.begin();
        leftGroup.push_back( *face );
        ++face;
        rightGroup.push_back( *face );
        //-------------------------------------------------
        // Create Left Leaf Node
        leftChild  = CreateBVHNodeBSphere( pParentNode, leftGroup );
//      leftChild->listHEFace  = leftGroup;         // DEBUG
        pParentNode->Child( 0, leftChild );
        //-------------------------------------------------
        // Create Right Leaf Node
        rightChild = CreateBVHNodeBSphere( pParentNode, rightGroup );
//      rightChild->listHEFace = rightGroup;        // DEBUG
        pParentNode->Child( 1, rightChild );
        return;
    }
    //---------------------------------------------------------------
    // CASE: more than two faces
    // Didive into two groups
    BSphereDivideToFaceGroups(  heFaceList, leftGroup, rightGroup, 
                                pParentNode->GetCenter(), 
                                principleVector );
    //---------------------------------------------------------------
    // CASE: more than two faces and the divider failed to divide the face list
    if (   static_cast<int>( leftGroup.size() )  == size 
        || static_cast<int>( rightGroup.size() ) == size ) {
        //std::cout << "Total    : " << size;
        //std::cout << "; Left  Grp: " << leftGroup.size();
        //std::cout << "; Right Grp: " << rightGroup.size() << std::endl;
        leftGroup.clear();
        rightGroup.clear();
        std::list< HEFace<T> * >::const_iterator face = heFaceList.begin();
        int i = 0;
        for ( ; i < size/2; ++i ) {
            leftGroup.push_back( *face );
            ++face;
        }
        for ( ; i < size; ++i ) {
            rightGroup.push_back( *face );
            ++face;
        }
    }
    Vector3<T> U, V, W;
    //---------------------------------------------------------------
    // Create Left Child Node
    leftChild  = CreateBVHNodeBSphere( pParentNode, leftGroup );
    FindOBBOfFaceList( leftGroup, leftChild->GetCenter(), U, V, W );
//  leftChild->listHEFace  = leftGroup;         // DEBUG
    pParentNode->Child( 0, leftChild );
    BSphereBuildChildren( leftChild, leftGroup, U );
    //---------------------------------------------------------------
    // Create Right Child Node
    rightChild = CreateBVHNodeBSphere( pParentNode, rightGroup );
    FindOBBOfFaceList( rightGroup, rightChild->GetCenter(), U, V, W );
//  rightChild->listHEFace = rightGroup;        // DEBUG
    pParentNode->Child( 1, rightChild );
    BSphereBuildChildren( rightChild, rightGroup, U );
}

template<typename T>

int BVHTree_BinarySphere< T >::BSphereDetermineFaceGroup	(	HEFace< T > *	face,
		const Vector3< T > &	center,
		const Vector3< T > &	direction
	)			[inline, static, private]

Definition at line 1922 of file TAPsBVHTree_BinarySphere.cpp.

{
    //-------------------------------------------------------------------------
    // Divided into an axis positive and negative
    //---------------------------------------------------------------
    // REMARK:
    //   To speed thing up, we can evaluate only the first vertex of the polygon.
    //---------------------------------------------------------------
    // Determine from all vertices
    int value = 0;
    HEHalfEdge<T> * firstHalfEdge = face->IncidentHalfEdge();
    HEHalfEdge<T> * halfEdge = firstHalfEdge;
    Vector3<T> vertex;
    do {
        /*
        vertex = halfEdge->Vertex()->GetPosition() - center;
        if ( vertex.GetY() >= 0 )   ++value;
        else                        --value;
        //*/
        //*
        if ( (halfEdge->Vertex()->GetPosition() - center) * direction >= 0 )
            ++value;
        else
            --value;
        //*/
        
        halfEdge = halfEdge->Next();
    } while ( halfEdge != firstHalfEdge );
    //---------------------------------------------------------------
    // Determine the group (left or right)
    return  value >= 0 ? 1 : 0;
}

template<typename T>

void BVHTree_BinarySphere< T >::BSphereDivideToFaceGroups	(	const std::list< HEFace< T > * > &	faces,
		std::list< HEFace< T > * > &	group1,
		std::list< HEFace< T > * > &	group2,
		const Vector3< T > &	center,
		const Vector3< T > &	direction
	)			[inline, static, private]

Definition at line 1958 of file TAPsBVHTree_BinarySphere.cpp.

{
    std::list< HEFace<T> * >::const_iterator face;
    for ( face = inputFaces.begin(); face != inputFaces.end(); ++face ) {
        if ( BSphereDetermineFaceGroup( *face, center, direction ) == 1 )
            group1.push_back( *face );
        else
            group2.push_back( *face );
    }
}

template<typename T>

static BVHTree<T>* BVHTree_BinarySphere< T >::Build	(	TransformationSupport< T > &	transform,
		std::list< HEFace< T > * > const *const	heFaceList,
		Enum::CD	treeType,
		BVHTree< T > *	cdtree
	)			[static]

O/P: pointer to BVHTree.

Parameters:

transform	I/O: Transform
heFaceList	I/P: half-edge face list
treeType	I/P: BVHTree type

template<typename T>

BVHNode< T > * BVHTree_BinarySphere< T >::CreateBVHNodeBSphere	(	BVHNode< T > *	pParentNode,
		const std::list< HEFace< T > * > &	heFaceList
	)			[inline, static, private]

Definition at line 1978 of file TAPsBVHTree_BinarySphere.cpp.

{
    //---------------------------------------------------------------
    Vector3<T> AABB[2];
    //HEVertex<T> * vertex = m_listVertex->Head();
    std::list< HEFace<T> * >::const_iterator face = heFaceList.begin();
    HEHalfEdge<T> * firstHalfEdge = (*face)->IncidentHalfEdge();
    HEHalfEdge<T> * halfEdge = firstHalfEdge;
    Vector3<T> vertex = halfEdge->Vertex()->GetPosition();
    AABB[0] = AABB[1] = vertex;
    //---------------------------------------------------------------
    // For Each Face
    for ( ; face != heFaceList.end(); ++face ) {
        halfEdge = firstHalfEdge = (*face)->IncidentHalfEdge();
        //-------------------------------------------------
        // For Each Vertex
        do {
            vertex = halfEdge->Vertex()->GetPosition();
            // Find the lowest an the highest of x, y, and z
            // AABB[0] is min and AABB[1] is max
            if      ( AABB[0][0] > vertex[0] )  AABB[0][0] = vertex[0];
            else if ( AABB[1][0] < vertex[0] )  AABB[1][0] = vertex[0];
            if      ( AABB[0][1] > vertex[1] )  AABB[0][1] = vertex[1];
            else if ( AABB[1][1] < vertex[1] )  AABB[1][1] = vertex[1];
            if      ( AABB[0][2] > vertex[2] )  AABB[0][2] = vertex[2];
            else if ( AABB[1][2] < vertex[2] )  AABB[1][2] = vertex[2];
            // Next vertex
            halfEdge = halfEdge->Next();
        } while ( halfEdge != firstHalfEdge );
    }
    //---------------------------------------------------------------
    // Find the bounding volume center from the AABB
    Vector3<T> vCenter( ( AABB[0][0] + AABB[1][0] ) / 2.0,
                        ( AABB[0][1] + AABB[1][1] ) / 2.0,
                        ( AABB[0][2] + AABB[1][2] ) / 2.0 );
    //---------------------------------------------------------------
    // Find the Sphere Bounding Volume
    T radius = 0, squaredLength;
    for ( face = heFaceList.begin(); face != heFaceList.end(); ++face ) {
        halfEdge = firstHalfEdge = (*face)->IncidentHalfEdge();
        //-------------------------------------------------
        do {
            vertex = halfEdge->Vertex()->GetPosition();
            //squaredLength = (vertex - vCenter).SquaredLength();
            squaredLength = (vertex - vCenter).Length();
            if ( squaredLength > radius )   radius = squaredLength;
            halfEdge = halfEdge->Next();
        } while ( halfEdge != firstHalfEdge );
    }
    //radius = sqrt( radius );
    //---------------------------------------------------------------
    // Make the root node
    //-------------------------------------------
    // BVHNode Constructor
    //   BVHNode<T>(    Enum::CD type,
    //                  int id, 
    //                  BVHNode<T> * parent, 
    //                  BVHNode<T> ** children )
    //-------------------------------------------
    //BVHNode<T> * node;
    if ( 1 == static_cast<int>( heFaceList.size() ) ) {
        /*
        node = new BVHNode<T>( Enum::BVH_NODE_BINARY_SPHERE, 
                                -1, pParentNode, NULL );
        //*/
        //*
        BVHNodeLeafHalfEdgeAPrim<T> * node = new BVHNodeLeafHalfEdgeAPrim<T>( 
                Enum::BVH_NODE_LEAF_SPHERE_HALFEDGE_APRIM, 
                -1, pParentNode );
        node->m_primHEFace = heFaceList.front();
//      BVHNodeLeafHalfEdgePrims<T> * node = new BVHNodeLeafHalfEdgePrims<T>( 
//              Enum::BVH_NODE_LEAF_SPHERE_HALFEDGE_PRIMS, 
//              -1, pParentNode );
        //node->listHEFace = heFaceList;
        node->SetCenter( vCenter );
        node->SetRadius( radius );
        return node;
        //*/
    }
    else {
        BVHNode<T> * node = new BVHNode<T>( Enum::BVH_NODE_BINARY_SPHERE, 
                                            -1, pParentNode, NULL );
        node->SetCenter( vCenter );
        node->SetRadius( radius );
        return node;
    }
}

template<typename T>

void BVHTree_BinarySphere< T >::ForBVCylinderTransformations	(	Matrix4x4< T > const &	nodeTransform_IP,
		BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > const &	bvTransformation,
		Matrix4x4< T > &	nodeTransform_OP
	)			[inline, protected]

Transform BV cylinder's center, radius, and height. Also find the transformation for the node.

Parameters:

nodeTransform_IP	I/P: node's transformation
pBV	I/P: cylinder bounding volume
bvTransformation	I/P: cylinder bounding volume's transformation
nodeTransform_OP	O/P: node's transformation

Definition at line 1079 of file TAPsBVHTree_BinarySphere.cpp.

                                                        : node's transformation
        BoundingVolume<T> const * const pBV,    //!< I/P: cylinder bounding volume
        Matrix4x4<T> const & bvTransformation,  //!< I/P: cylinder bounding volume's transformation
        Matrix4x4<T> & nodeTransform_OP         
)
{
    nodeTransform_OP = bvTransformation * Matrix4x4<T>( 1, 0, 0, pBV->GetCenter()[0], 
                                                        0, 1, 0, pBV->GetCenter()[1], 
                                                        0, 0, 1, pBV->GetCenter()[2], 
                                                        0, 0, 0, 1
                                                    );
    nodeTransform_OP = nodeTransform_OP.Inversed() * nodeTransform_IP;
}

template<typename T>

void BVHTree_BinarySphere< T >::ForBVCylinderTransformations	(	Matrix4x4< T > const &	nodeTransform_IP,
		BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > &	nodeTransform_OP
	)			[inline, protected]

Transform BV cylinder's center, radius, and height. Also find the transformation for the node.

Parameters:

nodeTransform_IP	I/P: node's transformation
pBV	I/P: cylinder bounding volume
nodeTransform_OP	O/P: node's transformation

Definition at line 1063 of file TAPsBVHTree_BinarySphere.cpp.

                                                        : node's transformation
        BoundingVolume<T> const * const pBV,    //!< I/P: cylinder bounding volume
        Matrix4x4<T> & nodeTransform_OP         //!< O/P: node's transformation
)
{
    nodeTransform_OP = Matrix4x4<T>(    1, 0, 0, -pBV->GetCenter()[0], 
                                        0, 1, 0, -pBV->GetCenter()[1], 
                                        0, 0, 1, -pBV->GetCenter()[2], 
                                        0, 0, 0, 1
                                    )
                    * nodeTransform_IP;
}

template<typename T>

void BVHTree_BinarySphere< T >::ForBVCylinderTransformations	(	BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > const &	bvTransformation,
		Matrix4x4< T > &	nodeTransform_OP
	)			[inline, protected]

Transform BV cylinder's center, radius, and height. Also find the transformation for the node.

Parameters:

pBV	I/P: cylinder bounding volume
bvTransformation	I/P: cylinder bounding volume's transformation
nodeTransform_OP	O/P: node's transformation

Definition at line 1047 of file TAPsBVHTree_BinarySphere.cpp.

                                                        : cylinder bounding volume
        Matrix4x4<T> const & bvTransformation,  
        Matrix4x4<T> & nodeTransform_OP         
)
{
    nodeTransform_OP = bvTransformation * Matrix4x4<T>( 1, 0, 0, pBV->GetCenter()[0], 
                                                        0, 1, 0, pBV->GetCenter()[1], 
                                                        0, 0, 1, pBV->GetCenter()[2], 
                                                        0, 0, 0, 1
                                                    );
    nodeTransform_OP.Inversed();
}

template<typename T>

void BVHTree_BinarySphere< T >::ForBVCylinderTransformations	(	BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > &	nodeTransform_OP
	)			[inline, protected]

Transform BV cylinder's center, radius, and height. Also find the transformation for the node.

Parameters:

pBV	I/P: cylinder bounding volume
nodeTransform_OP	O/P: node's transformation

Definition at line 1033 of file TAPsBVHTree_BinarySphere.cpp.

                                                        : cylinder bounding volume
        Matrix4x4<T> & nodeTransform_OP         
)
{
    nodeTransform_OP = Matrix4x4<T>(    1, 0, 0, -pBV->GetCenter()[0], 
                                        0, 1, 0, -pBV->GetCenter()[1], 
                                        0, 0, 1, -pBV->GetCenter()[2], 
                                        0, 0, 0, 1
                                    );
}

template<typename T>

void BVHTree_BinarySphere< T >::ForBVSphereTransformations	(	BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > const &	bvTransformation,
		Vector3< T > &	sphereCenter,
		T &	sphereRadius
	)			[inline, protected]

Transform BV sphere's center and radius.

Parameters:

pBV	I/P: sphere bounding volume
bvTransformation	I/P: sphere bounding volume's transformation
sphereCenter	O/P: sphere center
sphereRadius	O/P: sphere radius

Definition at line 995 of file TAPsBVHTree_BinarySphere.cpp.

                                                        : sphere bounding volume
        Matrix4x4<T> const & bvTransformation,  
        Vector3<T> & sphereCenter,              
        T & sphereRadius                        
)
{
    // Transform the pBV due to its transformation, center, and radius
    Vector3<T> C( pBV->GetCenter() );
    Matrix4x4<T> translation( 1, 0, 0, C[0], 
                              0, 1, 0, C[1],
                              0, 0, 1, C[2],
                              0, 0, 0, 1 );
    Vector3<T> S( pBV->GetRadius(), pBV->GetRadius(), pBV->GetRadius() );
    Matrix4x4<T> scale( S[0], 0,    0,    0, 
                        0,    S[1], 0,    0,
                        0,    0,    S[2], 0,
                        0,    0,    0,    1 );
    Matrix4x4<T> trx = bvTransformation * translation * scale;

    // Sphere's center and radius after the transformation
    sphereCenter = (trx * Vector4<T>(0,0,0,1)).GetVector3();
    sphereRadius = ( (trx * Vector4<T>(1,0,0,1)) - sphereCenter ).Length();

    /*
    // DEBUG
    std::cout << "(trx * Vector4<T>(S[0],0,0,1)): " << (trx * Vector4<T>(S[0],0,0,1)) << "\n";

    std::cout << "transformB: " << transformB;
    std::cout << "transformB * translation: " << transformB * translation;
    std::cout << "transformB * translation * scale: " << transformB * translation * scale;
    std::cout << "pBV: " << *pBV << "\n";
    std::cout << "Sphere: center " <<  sphereCenter << "; radius " << sphereRadius << "\n";
    //*/
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestIntersectionWithLineSegmentTillLeafNodes	(	Vector3< T > const *const	ptA,
		Vector3< T > const *const	ptB
	)			[inline, virtual]

Test intersection with a line segment (without primitive tests) The collided nodes of this BVH tree are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree.

Implements BVHTree< T >.

Definition at line 540 of file TAPsBVHTree_BinarySphere.cpp.

{
    m_svCollidedNode.clear();
    return TestIntersectionWithLineSegmentTillLeafNodesRecursive( Root(), ptA, ptB );
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestIntersectionWithLineSegmentTillLeafNodesRecursive	(	BVHNode< T > const *const	node,
		Vector3< T > const *const	ptA,
		Vector3< T > const *const	ptB
	)			[inline, protected]

< I/P: a point

< I/P: a line (start point)

< I/P: a line (end point)

< O/P: ratio

< O/P: q = p1 + ratio*(p1-p2)

< O/P: distance = |p - q|

Definition at line 548 of file TAPsBVHTree_BinarySphere.cpp.

{
    // Need to add transformation of the node into the computation !!!

    T ratio, distance;
    Vector3<T> projPt;
    CGMath<T>::FindProjectedPointOnALine ( 
            node->GetCenter(),  
            *ptA,   
            *ptB,   
            ratio,      
            projPt,     
            distance    
    );
    //---------------------------------------------------------------
    // Test overlapping
    if ( distance > node->GetRadius() || ratio < 0 || 1 < ratio ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    else if ( node->IsLeaf() ) {
        m_svCollidedNode.push_back( const_cast< BVHNode<T> * >( node ) );
        return true;
    }
    //---------------------------------------------------------------
    // If node A is not leaf
    else {
        bool overlap1 = false, overlap2 = false;
        if ( node->Child(0) ) {
            overlap1 = TestIntersectionWithLineSegmentTillLeafNodesRecursive( node->Child(0), ptA, ptB );
        }
        if ( node->Child(1) ) {
            overlap2 = TestIntersectionWithLineSegmentTillLeafNodesRecursive( node->Child(1), ptA, ptB );
        }
        if ( overlap1 || overlap2 ) {
            #ifdef  TAPs_DEBUG_COLLISION_DETECTION
                const_cast< BVHNode<T> * >( node )->flag = true;
            #endif//TAPs_DEBUG_COLLISION_DETECTION
            return true;
        }
        else {
            return false;
        }
    }
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BVHNode< T > const *const	nodeB,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 1415 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlap_vs_BinarySphere( BVHNode<T>, Matrix4x4<T>, BVHNode<T>, Matrix4x4<T> )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tCurrently call TestOverlap_vs_BinarySphere_TillLeafNodes( ... ) instead\n";

    bool bResult = TestOverlap_vs_BinarySphere_TillLeafNodes( nodeA, transformA, nodeB, transformB );
    if ( bResult ) {
        //-----------------------------------
        // Do Low-level Intersection Test HERE!
        //std::cout << "// Do Low-level Intersection Test HERE!\n";
        // E.g., Triangle-triangle intersection test
        //bResult = leaf node from nodeA->TestOverlapPrimitiveWithPrimitive( transformA, leaf node from nodeB, transformB );
    }
    return bResult;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BVHNode< T > const *const	nodeB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 1392 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlap_vs_BinarySphere( BVHNode<T>, Matrix4x4<T>, BVHNode<T> )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tCurrently call TestOverlap_vs_BinarySphere_TillLeafNodes( ... ) instead\n";

    bool bResult = TestOverlap_vs_BinarySphere_TillLeafNodes( nodeA, transformA, nodeB );
    if ( bResult ) {
        //-----------------------------------
        // Do Low-level Intersection Test HERE!
        //std::cout << "// Do Low-level Intersection Test HERE!\n";
        // E.g., Triangle-triangle intersection test
        //bResult = leaf node from nodeA->TestOverlapPrimitiveWithPrimitive( transformA, leaf node from nodeB );
    }
    return bResult;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere	(	BVHNode< T > const *const	nodeA,
		BVHNode< T > const *const	nodeB,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 1369 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlap_vs_BinarySphere( BVHNode<T>, BVHNode<T>, Matrix4x4<T> )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tCurrently call TestOverlap_vs_BinarySphere_TillLeafNodes( ... ) instead\n";

    bool bResult = TestOverlap_vs_BinarySphere_TillLeafNodes( nodeA, nodeB, transformB );
    if ( bResult ) {
        //-----------------------------------
        // Do Low-level Intersection Test HERE!
        //std::cout << "// Do Low-level Intersection Test HERE!\n";
        // E.g., Triangle-triangle intersection test
        //bResult = leaf node from nodeA->TestOverlapPrimitiveWithPrimitive( leaf node from nodeB, transformB );
    }
    return bResult;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere	(	BVHNode< T > const *const	nodeA,
		BVHNode< T > const *const	nodeB
	)			[inline, protected, virtual]

Currently Both TestOverlap_vs_BinarySphere is the same as TestOverlap_vs_BinarySphere_TillLeafNodes. So TestOverlap_vs_BinarySphere need to be complete!!!

Test overlap of a BVH tree with another binary sphere tree with primitive-primitive intersection test.

Implements BVHTree< T >.

Definition at line 1347 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlap_vs_BinarySphere( BVHNode<T>, BVHNode<T> )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tCurrently call TestOverlap_vs_BinarySphere_TillLeafNodes( ... ) instead\n";

    bool bResult = TestOverlap_vs_BinarySphere_TillLeafNodes( nodeA, nodeB );
    if ( bResult ) {
        //-----------------------------------
        // Do Low-level Intersection Test HERE!
        //std::cout << "// Do Low-level Intersection Test HERE!\n";
        // E.g., Triangle-triangle intersection test
        //bResult = leaf node from nodeA->TestOverlapPrimitiveWithPrimitive( leaf node from nodeB );
    }
    return bResult;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BVHNode< T > const *const	nodeB,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 1715 of file TAPsBVHTree_BinarySphere.cpp.

{
    //---------------------------------------------------------------
    // Test overlapping
    if ( nodeA->TestOverlapSphereWithSphere_TillLeafNodes( transformA, nodeB, transformB ) > Math<T>::ZERO ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    else if ( nodeA->IsLeaf() ) {
        //-------------------------------------------------
        // Both node A and node B are leaves
        if ( nodeB->IsLeaf() ) {
            //-----------------------------------
            // Do Low-level Intersection Test HERE!
            //std::cout << "// Do Low-level Intersection Test HERE!\n";
            //-----------------------------------
            //std::cout << "Distance (" << nodeA << "," << nodeB << "): " 
            //      << nodeA->TestOverlapSphereWithSphere_TillLeafNodes( nodeB ) << "\n";
            BVHNode<T> * nA = const_cast< BVHNode<T> * >( nodeA );
            BVHNode<T> * nB = const_cast< BVHNode<T> * >( nodeB );
            m_svCollidedNode.push_back( nA );
            m_svCollidedNodeThat.push_back( nB );
            //-----------------------------------
            return true;
        }
        //-------------------------------------------------
        // Node A is leaf, but node B is not
        else {
            bool overlap1 = false, overlap2 = false;
            if ( nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, transformA, nodeB->Child(0), transformB );
            }
            if ( nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, transformA, nodeB->Child(1), transformB );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
    }
    //---------------------------------------------------------------
    // If node A is not leaf
    else {
        //-------------------------------------------------
        // Node A is not leaf, but node B is
        if ( nodeB->IsLeaf() ) {
            bool overlap1 = false, overlap2 = false;
            if ( nodeA->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), transformA, nodeB, transformB );
            }
            if ( nodeA->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), transformA, nodeB, transformB );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
        //-------------------------------------------------
        // Both node A and node B are not leaves
        else {
            bool overlap1 = false, overlap2 = false, overlap3 = false, overlap4 = false;
            if ( nodeA->Child(0) && nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), transformA, nodeB->Child(0), transformB );
            }
            if ( nodeA->Child(0) && nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), transformA, nodeB->Child(1), transformB );
            }
            if ( nodeA->Child(1) && nodeB->Child(0) ) {
                overlap3 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), transformA, nodeB->Child(0), transformB );
            }
            if ( nodeA->Child(1) && nodeB->Child(1) ) {
                overlap4 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), transformA, nodeB->Child(1), transformB );
            }
            if ( overlap1 || overlap2 || overlap3 || overlap4 )
                return true;
            else
                return false;
        }
    }
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BVHNode< T > const *const	nodeB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 1621 of file TAPsBVHTree_BinarySphere.cpp.

{
    //---------------------------------------------------------------
    // Test overlapping
    if ( nodeA->TestOverlapSphereWithSphere_TillLeafNodes( transformA, nodeB ) > Math<T>::ZERO ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    else if ( nodeA->IsLeaf() ) {
        //-------------------------------------------------
        // Both node A and node B are leaves
        if ( nodeB->IsLeaf() ) {
            //-----------------------------------
            // Do Low-level Intersection Test HERE!
            //std::cout << "// Do Low-level Intersection Test HERE!\n";
            //-----------------------------------
            //std::cout << "Distance (" << nodeA << "," << nodeB << "): " 
            //      << nodeA->TestOverlapSphereWithSphere_TillLeafNodes( nodeB ) << "\n";
            BVHNode<T> * nA = const_cast< BVHNode<T> * >( nodeA );
            BVHNode<T> * nB = const_cast< BVHNode<T> * >( nodeB );
            m_svCollidedNode.push_back( nA );
            m_svCollidedNodeThat.push_back( nB );
            //-----------------------------------
            return true;
        }
        //-------------------------------------------------
        // Node A is leaf, but node B is not
        else {
            bool overlap1 = false, overlap2 = false;
            if ( nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, transformA, nodeB->Child(0) );
            }
            if ( nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, transformA, nodeB->Child(1) );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
    }
    //---------------------------------------------------------------
    // If node A is not leaf
    else {
        //-------------------------------------------------
        // Node A is not leaf, but node B is
        if ( nodeB->IsLeaf() ) {
            bool overlap1 = false, overlap2 = false;
            if ( nodeA->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), transformA, nodeB );
            }
            if ( nodeA->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), transformA, nodeB );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
        //-------------------------------------------------
        // Both node A and node B are not leaves
        else {
            bool overlap1 = false, overlap2 = false, overlap3 = false, overlap4 = false;
            if ( nodeA->Child(0) && nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), transformA, nodeB->Child(0) );
            }
            if ( nodeA->Child(0) && nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), transformA, nodeB->Child(1) );
            }
            if ( nodeA->Child(1) && nodeB->Child(0) ) {
                overlap3 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), transformA, nodeB->Child(0) );
            }
            if ( nodeA->Child(1) && nodeB->Child(1) ) {
                overlap4 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), transformA, nodeB->Child(1) );
            }
            if ( overlap1 || overlap2 || overlap3 || overlap4 )
                return true;
            else
                return false;
        }
    }
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		BVHNode< T > const *const	nodeB,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 1530 of file TAPsBVHTree_BinarySphere.cpp.

{
    //---------------------------------------------------------------
    // Test overlapping
    if ( nodeA->TestOverlapSphereWithSphere_TillLeafNodes( nodeB, transformB ) > Math<T>::ZERO ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    else if ( nodeA->IsLeaf() ) {
        //-------------------------------------------------
        // Both node A and node B are leaves
        if ( nodeB->IsLeaf() ) {
            //-----------------------------------
            //std::cout << "Distance (" << nodeA << "," << nodeB << "): " 
            //      << nodeA->TestOverlapSphereWithSphere_TillLeafNodes( nodeB ) << "\n";
            BVHNode<T> * nA = const_cast< BVHNode<T> * >( nodeA );
            BVHNode<T> * nB = const_cast< BVHNode<T> * >( nodeB );
            m_svCollidedNode.push_back( nA );
            m_svCollidedNodeThat.push_back( nB );
            //-----------------------------------
            return true;
        }
        //-------------------------------------------------
        // Node A is leaf, but node B is not
        else {
            bool overlap1 = false, overlap2 = false;
            if ( nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, nodeB->Child(0), transformB );
            }
            if ( nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, nodeB->Child(1), transformB );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
    }
    //------------------------------------------------------------------
    // If node A is not leaf
    else {
        //-------------------------------------------------
        // Node A is not leaf, but node B is
        if ( nodeB->IsLeaf() ) {
            bool overlap1 = false, overlap2 = false;
            if ( nodeA->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), nodeB, transformB );
            }
            if ( nodeA->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), nodeB, transformB );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
        //-------------------------------------------------
        // Both node A and node B are not leaves
        else {
            bool overlap1 = false, overlap2 = false, overlap3 = false, overlap4 = false;
            if ( nodeA->Child(0) && nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), nodeB->Child(0), transformB );
            }
            if ( nodeA->Child(0) && nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), nodeB->Child(1), transformB );
            }
            if ( nodeA->Child(1) && nodeB->Child(0) ) {
                overlap3 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), nodeB->Child(0), transformB );
            }
            if ( nodeA->Child(1) && nodeB->Child(1) ) {
                overlap4 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), nodeB->Child(1), transformB );
            }
            if ( overlap1 || overlap2 || overlap3 || overlap4 )
                return true;
            else
                return false;
        }
    }
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BinarySphere_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		BVHNode< T > const *const	nodeB
	)			[inline, protected, virtual]

Test overlap of a BVH tree with another binary sphere tree without primitive-primitive intersection test. I.e., stop at leaf-leaf-node intersection test.

Implements BVHTree< T >.

Definition at line 1440 of file TAPsBVHTree_BinarySphere.cpp.

{
    //---------------------------------------------------------------
    // Test overlapping
    if ( nodeA->TestOverlapSphereWithSphere_TillLeafNodes( nodeB ) > Math<T>::ZERO ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    else if ( nodeA->IsLeaf() ) {
        //-------------------------------------------------
        // Both node A and node B are leaves
        if ( nodeB->IsLeaf() ) {
            //-----------------------------------
            //std::cout << "Distance (" << nodeA << "," << nodeB << "): " 
            //      << nodeA->TestOverlapSphereWithSphere_TillLeafNodes( nodeB ) << "\n";
            BVHNode<T> * nA = const_cast< BVHNode<T> * >( nodeA );
            BVHNode<T> * nB = const_cast< BVHNode<T> * >( nodeB );
            m_svCollidedNode.push_back( nA );
            m_svCollidedNodeThat.push_back( nB );
            //-----------------------------------
            return true;
        }
        //-------------------------------------------------
        // Node A is leaf, but node B is not
        else {
            bool overlap1 = false, overlap2 = false;
            if ( nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, nodeB->Child(0) );
            }
            if ( nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA, nodeB->Child(1) );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
    }
    //---------------------------------------------------------------
    // If node A is not leaf
    else {
        //-------------------------------------------------
        // Node A is not leaf, but node B is
        if ( nodeB->IsLeaf() ) {
            bool overlap1 = false, overlap2 = false;
            if ( nodeA->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), nodeB );
            }
            if ( nodeA->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), nodeB );
            }
            if ( overlap1 || overlap2 ) return true;
            else                        return false;
        }
        //-------------------------------------------------
        // Both node A and node B are not leaves
        else {
            bool overlap1 = false, overlap2 = false, overlap3 = false, overlap4 = false;
            if ( nodeA->Child(0) && nodeB->Child(0) ) {
                overlap1 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), nodeB->Child(0) );
            }
            if ( nodeA->Child(0) && nodeB->Child(1) ) {
                overlap2 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(0), nodeB->Child(1) );
            }
            if ( nodeA->Child(1) && nodeB->Child(0) ) {
                overlap3 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), nodeB->Child(0) );
            }
            if ( nodeA->Child(1) && nodeB->Child(1) ) {
                overlap4 = TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                nodeA->Child(1), nodeB->Child(1) );
            }
            if ( overlap1 || overlap2 || overlap3 || overlap4 )
                return true;
            else
                return false;
        }
    }
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 746 of file TAPsBVHTree_BinarySphere.cpp.

{
    std::cout << "#4 BVHTree_BinarySphere<T>::TestOverlap_vs_BV( BVHNode<T>, Matrix4x4<T>, BoundingVolume<T>, Matrix4x4<T> )\n";

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            {
                Vector3<T>  sphereCenter;
                T           sphereRadius;
                ForBVSphereTransformations( pBV, transformB, sphereCenter, sphereRadius );

                // Collision Detection -- With Primitive-Primitive Test
                return TestOverlap_vs_BV_Sphere( nodeA, transformA, sphereCenter, sphereRadius );
            }
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( transformA, pBV, transformB, nodeTransformation );

                // Collision Detection -- With Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight()  );
            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 104)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BoundingVolume< T > const *const	pBV
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 705 of file TAPsBVHTree_BinarySphere.cpp.

{
    std::cout << "#3 BVHTree_BinarySphere<T>::TestOverlap_vs_BV( BVHNode<T>, Matrix4x4<T>, BoundingVolume<T> )\n";

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            return TestOverlap_vs_BV_Sphere( nodeA, transformA, pBV->GetCenter(), pBV->GetRadius() );
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( transformA, pBV, nodeTransformation );

                // Collision Detection -- With Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );
            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 103)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV	(	BVHNode< T > const *const	nodeA,
		BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 657 of file TAPsBVHTree_BinarySphere.cpp.

{
    std::cout << "#2 BVHTree_BinarySphere<T>::TestOverlap_vs_BV( BVHNode<T>, BoundingVolume<T>, Matrix4x4<T> )\n";

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            {
                Vector3<T>  sphereCenter;
                T           sphereRadius;
                ForBVSphereTransformations( pBV, transformB, sphereCenter, sphereRadius );

                // Collision Detection -- With Primitive-Primitive Test
                return TestOverlap_vs_BV_Sphere( nodeA, sphereCenter, sphereRadius );
            }
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( pBV, transformB, nodeTransformation );

                // Collision Detection -- With Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );
            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 102)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV	(	BVHNode< T > const *const	nodeA,
		BoundingVolume< T > const *const	pBV
	)			[inline, protected, virtual]

Currently Both TestOverlap_vs_BV is the same as TestOverlap_vs_BV_TillLeafNodes. So TestOverlap_vs_BV need to be complete!!!

Test overlap of a binary sphere tree with a bounding volume with primitive-primitive intersection test.

Implements BVHTree< T >.

Definition at line 617 of file TAPsBVHTree_BinarySphere.cpp.

{
    std::cout << "#1 BVHTree_BinarySphere<T>::TestOverlap_vs_BV( BVHNode<T>, BoundingVolume<T> )\n";

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            return TestOverlap_vs_BV_Sphere( nodeA, pBV->GetCenter(), pBV->GetRadius() );
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( pBV, nodeTransformation );

                // Collision Detection -- With Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );
            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 101)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_Cylinder_AtOrigin	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		T	cylinderRadius,
		T	cylinderHeight
	)			[inline, protected]

Remark:

Assume an existing transformB is already applied to cylinderCenter, cylinderRadius, and cylinderHeight

Definition at line 1257 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlap_vs_BV_Cylinder_AtOrigin( BVHNode<T>, Matrix4x4<T>, cylinderRadius, cylinderHeight )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tCurrently call TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( ... ) instead\n";

    return TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA, transformA, cylinderRadius, cylinderHeight );

    //---------------------------------------------------------------
    // Do low level here!!!
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		T	cylinderRadius,
		T	cylinderHeight
	)			[inline, protected]

Remark:

Assume an existing transformB is already applied to cylinderCenter, cylinderRadius, and cylinderHeight

Definition at line 1286 of file TAPsBVHTree_BinarySphere.cpp.

{
    //std::cout << "BVHTree_BinarySphere<T>::TestOverlap_vs_BV_Cylinder_TillLeafNodes( BVHNode<T>, Matrix4x4<T>, cylinderRadius, cylinderHeight )\n";

    //---------------------------------------------------------------
    // Test overlapping
    if ( nodeA->TestOverlapSphereWithBVCylinder_AtOrigin_TillLeafNodes( transformA, cylinderRadius, cylinderHeight ) == false ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    else if ( nodeA->IsLeaf() ) {
        #ifdef  TAPs_DEBUG_COLLISION_DETECTION
            const_cast< BVHNode<T> * >( nodeA )->flag = true;
        #endif//TAPs_DEBUG_COLLISION_DETECTION
        m_svCollidedNode.push_back( const_cast< BVHNode<T> * >( nodeA ) );
        //std::cout << "\tTRUE -- nodeA: " << nodeA << "\n";
        return true;
    }
    //---------------------------------------------------------------
    // If node A is not leaf
    else {
        bool overlap1 = false, overlap2 = false;
        if ( nodeA->Child(0) ) {
            overlap1 = TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA->Child(0), transformA, cylinderRadius, cylinderHeight );
        }
        if ( nodeA->Child(1) ) {
            overlap2 = TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA->Child(1), transformA, cylinderRadius, cylinderHeight );
        }
        if ( overlap1 || overlap2 ) {
            #ifdef  TAPs_DEBUG_COLLISION_DETECTION
                const_cast< BVHNode<T> * >( nodeA )->flag = true;
            #endif//TAPs_DEBUG_COLLISION_DETECTION
            return true;
        }
        else {
            return false;
        }
    }
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_Sphere	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		Vector3< T > const &	sphereCenter,
		T	sphereRadius
	)			[inline, protected]

Definition at line 1124 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "#2 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_Sphere( BVHNode<T>, Matrix4x4<T>, Vector3<T>, sphereCenter, sphereRadius )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tCurrently call TestOverlap_vs_BV_Sphere_TillLeafNodes( ... ) instead\n";

    return TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA, transformA, sphereCenter, sphereRadius );

    //---------------------------------------------------------------
    // Do low level here!!!
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_Sphere	(	BVHNode< T > const *const	nodeA,
		Vector3< T > const &	sphereCenter,
		T	sphereRadius
	)			[inline, protected]

Remark: existing transformB is already applied to sphereCenter and sphereRadius.

Definition at line 1105 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "#1 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_Sphere( BVHNode<T>, Vector3<T>, T )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tCurrently call TestOverlap_vs_BV_Sphere_TillLeafNodes( ... ) instead\n";

    return TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA, sphereCenter, sphereRadius );

    //---------------------------------------------------------------
    // Do low level here!!!
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_Sphere_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		Vector3< T > const &	sphereCenter,
		T	sphereRadius
	)			[inline, protected]

Definition at line 1200 of file TAPsBVHTree_BinarySphere.cpp.

{
    //std::cout << "#2 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_Sphere_TillLeafNodes( BVHNode<T>, Matrix4x4<T>, Vector3<T>, T )\n";
    //---------------------------------------------------------------
    // Test overlapping
    if ( nodeA->TestOverlapSphereWithBVSphere_TillLeafNodes( transformA, sphereCenter, sphereRadius ) > Math<T>::ZERO ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    else if ( nodeA->IsLeaf() ) {
        m_svCollidedNode.push_back( const_cast< BVHNode<T> * >( nodeA ) );
        //std::cout << "\tTRUE -- nodeA: " << nodeA << "\n";
        #ifdef  TAPs_DEBUG_COLLISION_DETECTION
            const_cast< BVHNode<T> * >( nodeA )->flag = true;
        #endif//TAPs_DEBUG_COLLISION_DETECTION
        return true;
    }
    //---------------------------------------------------------------
    // If node A is not leaf
    else {
        bool overlap1 = false, overlap2 = false;
        if ( nodeA->Child(0) ) {
            overlap1 = TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA->Child(0), transformA, sphereCenter, sphereRadius );
        }
        if ( nodeA->Child(1) ) {
            overlap2 = TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA->Child(1), transformA, sphereCenter, sphereRadius );
        }
        if ( overlap1 || overlap2 ) {
            #ifdef  TAPs_DEBUG_COLLISION_DETECTION
                const_cast< BVHNode<T> * >( nodeA )->flag = true;
            #endif//TAPs_DEBUG_COLLISION_DETECTION
            return true;
        }
        else {
            return false;
        }
    }
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_Sphere_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		Vector3< T > const &	sphereCenter,
		T	sphereRadius
	)			[inline, protected]

Remark: existing transformB is already applied to sphereCenter and sphereRadius.

Definition at line 1153 of file TAPsBVHTree_BinarySphere.cpp.

{
    //std::cout << "#1 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_Sphere_TillLeafNodes( BVHNode<T>, Vector3<T>, T )\n";

    //---------------------------------------------------------------
    // Test overlapping
    if ( nodeA->TestOverlapSphereWithBVSphere_TillLeafNodes( sphereCenter, sphereRadius ) > Math<T>::ZERO ) {
        return false;
    }
    //---------------------------------------------------------------
    // If node A is leaf
    if ( nodeA->IsLeaf() ) {
        m_svCollidedNode.push_back( const_cast< BVHNode<T> * >( nodeA ) );
        //std::cout << "\tTRUE -- nodeA: " << nodeA << "\n";
        #ifdef  TAPs_DEBUG_COLLISION_DETECTION
            const_cast< BVHNode<T> * >( nodeA )->flag = true;
        #endif//TAPs_DEBUG_COLLISION_DETECTION
        return true;
    }
    //---------------------------------------------------------------
    // If node A is not leaf
    else {
        bool overlap1 = false, overlap2 = false;
        if ( nodeA->Child(0) ) {
            overlap1 = TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA->Child(0), sphereCenter, sphereRadius );
        }
        if ( nodeA->Child(1) ) {
            overlap2 = TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA->Child(1), sphereCenter, sphereRadius );
        }
        if ( overlap1 || overlap2 ) {
            #ifdef  TAPs_DEBUG_COLLISION_DETECTION
                const_cast< BVHNode<T> * >( nodeA )->flag = true;
            #endif//TAPs_DEBUG_COLLISION_DETECTION
            return true;
        }
        else {
            return false;
        }
    }
    //---------------------------------------------------------------
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 939 of file TAPsBVHTree_BinarySphere.cpp.

{
    // TEST PASSED
    //std::cout << "#4 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes( BVHNode<T>, Matrix4x4<T>, BoundingVolume<T>, Matrix4x4<T> )\n";

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            {
                Vector3<T>  sphereCenter;
                T           sphereRadius;
                ForBVSphereTransformations( pBV, transformB, sphereCenter, sphereRadius );

                // Collision Detection -- W/O Primitive-Primitive Test
                return TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA, transformA, sphereCenter, sphereRadius );
            }
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( transformA, pBV, transformB, nodeTransformation );

                // Collision Detection -- W/O Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );
            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 204)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		Matrix4x4< T > const &	transformA,
		BoundingVolume< T > const *const	pBV
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 898 of file TAPsBVHTree_BinarySphere.cpp.

{
    std::cout << "#3 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes( BVHNode<T>, Matrix4x4<T>, BoundingVolume<T> )\n";

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            return TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA, transformA, pBV->GetCenter(), pBV->GetRadius() );
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( transformA, pBV, nodeTransformation );

                // Collision Detection -- W/O Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );
            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 203)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		BoundingVolume< T > const *const	pBV,
		Matrix4x4< T > const &	transformB
	)			[inline, protected, virtual]

Implements BVHTree< T >.

Definition at line 840 of file TAPsBVHTree_BinarySphere.cpp.

{
    //std::cout << "#2 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes( BVHNode<T>, BoundingVolume<T>, Matrix4x4<T> )\n";

    //std::cout << "Matrix4x4<T>: " << transformB;

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            {
                Vector3<T>  sphereCenter;
                T           sphereRadius;
                ForBVSphereTransformations( pBV, transformB, sphereCenter, sphereRadius );

                //std::cout << "\tCall TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA, sphereCenter, sphereRadius );\n";

                // Collision Detection -- W/O Primitive-Primitive Test
                return TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA, sphereCenter, sphereRadius );
            }
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( pBV, transformB, nodeTransformation );

                //std::cout << "Inv: " << nodeTransformation;

                //std::cout << "\tCall TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );\n";
                //std::cout << "pBV->GetName(): " << pBV->GetName() << "\n";

                // Collision Detection -- W/O Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );

            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 202)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlap_vs_BV_TillLeafNodes	(	BVHNode< T > const *const	nodeA,
		BoundingVolume< T > const *const	pBV
	)			[inline, protected, virtual]

Test overlap of a binary sphere tree with a bounding volume without primitive-primitive intersection test. I.e., stop at leaf-leaf-node intersection test.

Implements BVHTree< T >.

Definition at line 800 of file TAPsBVHTree_BinarySphere.cpp.

{
    std::cout << "#1 BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes( BVHNode<T>, BoundingVolume<T> )\n";

    //---------------------------------------------------------------
    switch ( pBV->GetType() ) {
        case Enum::BOUNDING_SPHERE:
            return TestOverlap_vs_BV_Sphere_TillLeafNodes( nodeA, pBV->GetCenter(), pBV->GetRadius() );
            break;
        case Enum::BOUNDING_CYLINDER:
            {
                Matrix4x4<T> nodeTransformation;
                ForBVCylinderTransformations( pBV, nodeTransformation );

                // Collision Detection -- W/O Primitive-Primitive Test
                return TestOverlap_vs_BV_Cylinder_AtOrigin_TillLeafNodes( nodeA, nodeTransformation, pBV->GetRadius(), pBV->GetHeight() );
            }
            break;
        case Enum::BOUNDING_BOX:
        case Enum::BOUNDING_ELLIPSOID:
        case Enum::BOUNDING_HALF_SPHERE:
        case Enum::BOUNDING_HALF_ELLIPSOID:
        case Enum::BOUNDING_CONE:
        case Enum::BOUNDING_CAPSULE:
        case Enum::BOUNDING_POLYTOPE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 201)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlap_vs_BV_TillLeafNodes Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWith

(

BoundingVolume< T > const *const

pBV

)

[inline, virtual]

Test overlap with a Bounding Volume object (with primitive tests) The collided nodes of this BVH tree are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree.

Implements BVHTree< T >.

Definition at line 249 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlapWith( BoundingVolume<T> const * const " << pBV << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR

    // After finish the content in m_svCollidedNodeThat will be moved into m_svCollidedNode.
    // m_svCollidedNode must be priorly cleared by a caller function.

    m_svCollidedNode.clear();
    //m_svCollidedNodeThat.clear();
    // m_svCollidedBVAndNodeList is not cleared, so that this fn can be used for overlap test with MBV.

    int val = pBV->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
    val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;
    bool bResult = false;
    switch ( val ) {
        case 0:
            bResult = TestOverlap_vs_BV( m_pRoot, pBV );
            break;
        case 1:
            bResult = TestOverlap_vs_BV( m_pRoot, pBV, pBV->GetTransform().GetMatrixTransform() );
            break;
        case 2:
            bResult = TestOverlap_vs_BV( m_pRoot, GetTransform().GetMatrixTransform(), pBV );
            break;
        case 3:
            bResult = TestOverlap_vs_BV( m_pRoot, GetTransform().GetMatrixTransform(), pBV, pBV->GetTransform().GetMatrixTransform() );
            break;
    }
    //---------------------------------------------------------------
    //if ( bResult ) {
    //  m_svCollidedNode = m_svCollidedNodeThat;
    //}
    //---------------------------------------------------------------
    return bResult;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWith

(

MultiBoundingVolume< T > const *const

pMBV

)

[inline, virtual]

Test overlap with a Multi Bounding Volume object (with primitive tests) The collided nodes of this BVH tree and the collided bounding volume of the multi bounding volume are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree. Call GetListOfCollidedBoundingVolume() to get the collided bounding volumes of the MultiBoundingVolume object.

Implements BVHTree< T >.

Definition at line 149 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlapWith( MultiBoundingVolume<T> const * const " << pMBV << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR

    m_svCollidedNode.clear();
    //m_svCollidedNodeThat.clear();
    m_svCollidedBVAndNodeList.clear();

    bool bResult = false;
    //---------------------------------------------------------------
    // Traverse the list of bounding volumes
    std::vector< BoundingVolume<T> * >::iterator pos = const_cast< MultiBoundingVolume<T> * >( pMBV )->GetBoundingVolumeList().begin();
    if ( pMBV->GetTransform().GetStatusApplyTransformation() ) {
        // The multi bounding volume's transformation is on.
        while ( pos != pMBV->GetBoundingVolumeList().end() ) {
            assert( *pos != NULL );
            // Store the transformation of the bounding volume
            TransformationSupport<T> trx = (*pos)->GetTransform();
            (*pos)->GetTransform().EnableStatusApplyTransformation();
            (*pos)->GetTransform().SetMatrixTransform( pMBV->GetTransform().GetMatrixTransform() * trx.GetMatrixTransform() );
            // Collision Detection
            int val = (*pos)->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
            val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;
            bool result = false;
            switch ( val ) {
                case 0:
                    result = TestOverlap_vs_BV( m_pRoot, *pos );
                    break;
                case 1:
                    result = TestOverlap_vs_BV( m_pRoot, *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
                case 2:
                    result = TestOverlap_vs_BV( m_pRoot, GetTransform().GetMatrixTransform(), *pos );
                    break;
                case 3:
                    result = TestOverlap_vs_BV( m_pRoot, GetTransform().GetMatrixTransform(), *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
            }
            // Restore the transformation of the bounding volume
            (*pos)->GetTransform().SetMatrixTransform( trx.GetMatrixTransform() );
            // Set result and keep records
            if ( result ) {
                bResult = true;
                //for ( int i = 0; i < static_cast<int>( m_svCollidedNodeThat.size() ); ++i ) {
                //  m_svCollidedNode.push_back( m_svCollidedNodeThat[i] );
                //  m_svCollidedBVList.push_back( *pos );
                //}
                m_svCollidedBVAndNodeList.push_back( BVsAndNodesList<T>( *pos, m_svCollidedNode ) );
            }
            // Next Bounding Volume
            ++pos;

            //pos = const_cast< MultiBoundingVolume<T> * >( pMBV )->GetBoundingVolumeList().end();
        }
    }
    else {
        // The multi bounding volume's transformation is off.
        while ( pos != pMBV->GetBoundingVolumeList().end() ) {
            assert( *pos != NULL );
            // Collision Detection
            int val = (*pos)->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
            val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;
            bool result = false;
            switch ( val ) {
                case 0:
                    result = TestOverlap_vs_BV( m_pRoot, *pos );
                    break;
                case 1:
                    result = TestOverlap_vs_BV( m_pRoot, *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
                case 2:
                    result = TestOverlap_vs_BV( m_pRoot, GetTransform().GetMatrixTransform(), *pos );
                    break;
                case 3:
                    result = TestOverlap_vs_BV( m_pRoot, GetTransform().GetMatrixTransform(), *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
            }
            // Set result and keep records
            if ( result ) {
                bResult = true;
                //for ( int i = 0; i < static_cast<int>( m_svCollidedNodeThat.size() ); ++i ) {
                //  m_svCollidedNode.push_back( m_svCollidedNodeThat[i] );
                //  m_svCollidedBVList.push_back( *pos );
                //}
                m_svCollidedBVAndNodeList.push_back( BVsAndNodesList<T>( *pos, m_svCollidedNode ) );
            }
            // Next Bounding Volume
            ++pos;

            //pos = const_cast< MultiBoundingVolume<T> * >( pMBV )->GetBoundingVolumeList().end();
        }
    }
    //---------------------------------------------------------------
    return bResult;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWith

(

BVHNode< T > const *const

node

)

[inline, virtual]

Test overlap with a BVH node (with primitive tests) The collided nodes of this BVH tree are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree.

Implements BVHTree< T >.

Definition at line 121 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlapWith( BVHNode<T> const * const " << node << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tNOT IMPLEMENTED YET!\n";

    m_svCollidedNode.clear();
    m_svCollidedNodeThat.clear();
    //---------------------------------------------------------------
    switch ( node->GetType() ) {
        case Enum::BVH_NODE_BINARY_SPHERE:
        case Enum::BVH_NODE_QUAD_SPHERE:
        case Enum::BVH_NODE_OCTANT_SPHERE:
        case Enum::BVH_NODE_GENERIC_SPHERE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 004)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlapWith Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWith

(

BVHTree< T > const *const

that

)

[inline, virtual]

Test overlap with another BVH tree (with primitive tests) The collided nodes of both BVH trees are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree. Call GetListOfCollidedNodesThat() to get the collided nodes of the other BVH tree.

Implements BVHTree< T >.

Definition at line 65 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlapWith( BVHTree<T> const * const " << that << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR

    m_svCollidedNode.clear();
    m_svCollidedNodeThat.clear();

    int val = that->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
    val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;

    //---------------------------------------------------------------
    switch ( that->GetType() ) {
        case Enum::BVH_TREE_BINARY_SPHERE:
            switch ( val ) {
                case 0:
                    return TestOverlap_vs_BinarySphere( 
                                m_pRoot, 
                                that->Root() );
                    break;
                case 1:
                    return TestOverlap_vs_BinarySphere( 
                                m_pRoot, 
                                that->Root(), that->GetTransform().GetMatrixTransform() );
                    break;
                case 2:
                    return TestOverlap_vs_BinarySphere( 
                                m_pRoot, GetTransform().GetMatrixTransform(), 
                                that->Root() );
                    break;
                case 3:
                    return TestOverlap_vs_BinarySphere( 
                                m_pRoot, GetTransform().GetMatrixTransform(), 
                                that->Root(), that->GetTransform().GetMatrixTransform() );
                    break;
            }
            break;

        case Enum::BVH_TREE_QUAD_SPHERE:
        case Enum::BVH_TREE_OCTANT_SPHERE:
        case Enum::BVH_TREE_GENERIC_SPHERE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 002)" << std::endl;
            break;

        default:
            std::cout << "Error: BVHTree_BinarySphere<T>::TestOverlapWith Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWithTillLeafNodes

(

BoundingVolume< T > const *const

pBV

)

[inline, virtual]

Test overlap with a Bounding Volume object (without primitive tests) The collided nodes of this BVH tree are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree.

Implements BVHTree< T >.

Definition at line 494 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlapWithTillLeafNodes( BoundingVolume<T> const * const " << pBV << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR

    // After finish the content in m_svCollidedNodeThat will be moved into m_svCollidedNode.
    // m_svCollidedNode must be priorly cleared by a caller function.

    m_svCollidedNode.clear();
    //m_svCollidedNodeThat.clear();
    // m_svCollidedBVAndNodeList is not cleared, so that this fn can be used for overlap test with MBV.

    int val = pBV->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
    val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;
    bool bResult = false;
    switch ( val ) {
        case 0:
            bResult = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, pBV );
            break;
        case 1:
            bResult = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, pBV, pBV->GetTransform().GetMatrixTransform() );
            break;
        case 2:
            bResult = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, GetTransform().GetMatrixTransform(), pBV );
            break;
        case 3:
            bResult = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, GetTransform().GetMatrixTransform(), pBV, pBV->GetTransform().GetMatrixTransform() );
            break;
    }
    //---------------------------------------------------------------
    //if ( bResult ) {
    //  m_svCollidedNode = m_svCollidedNodeThat;
    //}
    //---------------------------------------------------------------
    return bResult;

}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWithTillLeafNodes

(

MultiBoundingVolume< T > const *const

pMBV

)

[inline, virtual]

Test overlap with a Multi Bounding Volume object (without primitive tests) The collided nodes of this BVH tree and the collided bounding volume of the multi bounding volume are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree. Call GetListOfCollidedBoundingVolume() to get the collided bounding volumes of the MultiBoundingVolume object.

Implements BVHTree< T >.

Definition at line 376 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    //std::cout << "BVHTree_BinarySphere<T>::TestOverlapWithTillLeafNodes( MultiBoundingVolume<T> const * const " << pMBV << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR

    // After finish the content in m_svCollidedNodeThat will be moved into m_svCollidedNode.
    // m_svCollidedNode must be priorly cleared by a caller function.

    m_svCollidedNode.clear();
    //m_svCollidedNodeThat.clear();
    m_svCollidedBVAndNodeList.clear();

    bool bResult = false;
    //---------------------------------------------------------------
    // Traverse the list of bounding volumes
    std::vector< BoundingVolume<T> * >::iterator pos = const_cast< MultiBoundingVolume<T> * >( pMBV )->GetBoundingVolumeList().begin();

    // MBV is transformed
    if ( pMBV->GetTransform().GetStatusApplyTransformation() ) {

        //std::cout << "From BVHTree_BinarySphere<T>::TestOverlapWithTillLeafNodes ( MultiBoundingVolume<T> const * const pMBV )\n";
        //std::cout << "\tpMBV->GetTransform().GetStatusApplyTransformation() is TRUE\n";

        // The multi bounding volume's transformation is on.
        while ( pos != pMBV->GetBoundingVolumeList().end() ) {
            assert( *pos != NULL );
            // Store the transformation of the bounding volume
            TransformationSupport<T> trx = (*pos)->GetTransform();
            (*pos)->GetTransform().EnableStatusApplyTransformation();
            (*pos)->GetTransform().SetMatrixTransform( pMBV->GetTransform().GetMatrixTransform() * trx.GetMatrixTransform() );
            // Collision Detection
            int val = (*pos)->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
            val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;
            bool result = false;
            switch ( val ) {
                case 0:
                    std::cout << "CASE 0-0\n";  // WILL NEVER REACHED, BECUASE OF (*pos)->GetTransform().EnableStatusApplyTransformation(); ABOVE
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, *pos );
                    break;
                case 1:
                    //std::cout << "CASE 0-1\n";    // TEST PASSED
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
                case 2:
                    std::cout << "CASE 0-2\n";  // WILL NEVER REACHED, BECUASE OF (*pos)->GetTransform().EnableStatusApplyTransformation(); ABOVE
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, GetTransform().GetMatrixTransform(), *pos );
                    break;
                case 3:
                    //std::cout << "CASE 0-3\n";    // TEST PASSED
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, GetTransform().GetMatrixTransform(), *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
            }
            // Restore the transformation of the bounding volume
            (*pos)->GetTransform().SetMatrixTransform( trx.GetMatrixTransform() );
            // Set result and keep records
            if ( result ) {
                bResult = true;
                //for ( int i = 0; i < static_cast<int>( m_svCollidedNodeThat.size() ); ++i ) {
                //  m_svCollidedNode.push_back( m_svCollidedNodeThat[i] );
                //  m_svCollidedBVList.push_back( *pos );
                //}
                m_svCollidedBVAndNodeList.push_back( BVsAndNodesList<T>( *pos, m_svCollidedNode ) );
            }
            // Next Bounding Volume
            ++pos;
        }
    }
    // MBV is NOT transformed
    else {

        std::cout << "From BVHTree_BinarySphere<T>::TestOverlapWithTillLeafNodes ( MultiBoundingVolume<T> const * const pMBV )\n";
        std::cout << "\tpMBV->GetTransform().GetStatusApplyTransformation() is FALSE\n";

        // The multi bounding volume's transformation is off.
        while ( pos != pMBV->GetBoundingVolumeList().end() ) {
            assert( *pos != NULL );
            // Collision Detection
            int val = (*pos)->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
            val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;
            bool result = false;
            switch ( val ) {
                case 0:
                    std::cout << "CASE 1-0\n";
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, *pos );
                    break;
                case 1:
                    std::cout << "CASE 1-1\n";
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
                case 2:
                    std::cout << "CASE 1-2\n";
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, GetTransform().GetMatrixTransform(), *pos );
                    break;
                case 3:
                    std::cout << "CASE 1-3\n";
                    result = TestOverlap_vs_BV_TillLeafNodes( m_pRoot, GetTransform().GetMatrixTransform(), *pos, (*pos)->GetTransform().GetMatrixTransform() );
                    break;
            }
            // Set result and keep records
            if ( result ) {
                bResult = true;
                //for ( int i = 0; i < static_cast<int>( m_svCollidedNodeThat.size() ); ++i ) {
                //  m_svCollidedNode.push_back( m_svCollidedNodeThat[i] );
                //  m_svCollidedBVList.push_back( *pos );
                //}
                m_svCollidedBVAndNodeList.push_back( BVsAndNodesList<T>( *pos, m_svCollidedNode ) );
            }
            // Next Bounding Volume
            ++pos;
        }
    }
    //---------------------------------------------------------------
    return bResult;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWithTillLeafNodes

(

BVHNode< T > const *const

node

)

[inline, virtual]

Test overlap with a BVH node (without primitive tests) The collided nodes of this BVH tree are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree.

Implements BVHTree< T >.

Definition at line 348 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlapWithTillLeafNodes( BVHNode<T> const * const " << node << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "\tNOT IMPLEMENTED YET!\n";

    m_svCollidedNode.clear();
    m_svCollidedNodeThat.clear();
    //---------------------------------------------------------------
    switch ( node->GetType() ) {
        case Enum::BVH_NODE_BINARY_SPHERE:
        case Enum::BVH_NODE_QUAD_SPHERE:
        case Enum::BVH_NODE_OCTANT_SPHERE:
        case Enum::BVH_NODE_GENERIC_SPHERE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree<T> 012)" << std::endl;
            break;
        default:
            std::cout << "Error: BVHNode<T>::TestOverlapWithTillLeafNodes Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

template<typename T>

bool BVHTree_BinarySphere< T >::TestOverlapWithTillLeafNodes

(

BVHTree< T > const *const

that

)

[inline, virtual]

Test overlap with another BVH tree (without primitive tests) The collided nodes of both BVH trees are stored. Call GetListOfCollidedNodes() to get the collided nodes of this BVH tree. Call GetListOfCollidedNodesThat() to get the collided nodes of the other BVH tree.

Implements BVHTree< T >.

Definition at line 292 of file TAPsBVHTree_BinarySphere.cpp.

{
    #ifdef  TAPs_DEBUG_BINARY_SPHERE_TREE_CDR
    std::cout << "BVHTree_BinarySphere<T>::TestOverlapWithTillLeafNodes( BVHTree<T> const * const " << that << " )\n";
    #endif//TAPs_DEBUG_BINARY_SPHERE_TREE_CDR

    m_svCollidedNode.clear();
    m_svCollidedNodeThat.clear();

    int val = that->GetTransform().GetStatusApplyTransformation() ? 1 : 0;
    val += this->GetTransform().GetStatusApplyTransformation() ? 2 : 0;

    //---------------------------------------------------------------
    switch ( that->GetType() ) {
        case Enum::BVH_TREE_BINARY_SPHERE:
            switch ( val ) {
                case 0:
                    return TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                m_pRoot, 
                                that->Root() );
                    break;
                case 1:
                    return TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                m_pRoot, 
                                that->Root(), that->GetTransform().GetMatrixTransform() );
                    break;
                case 2:
                    return TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                m_pRoot, GetTransform().GetMatrixTransform(), 
                                that->Root() );
                    break;
                case 3:
                    return TestOverlap_vs_BinarySphere_TillLeafNodes( 
                                m_pRoot, GetTransform().GetMatrixTransform(), 
                                that->Root(), that->GetTransform().GetMatrixTransform() );
                    break;
            }
            break;

        case Enum::BVH_TREE_QUAD_SPHERE:
        case Enum::BVH_TREE_OCTANT_SPHERE:
        case Enum::BVH_TREE_GENERIC_SPHERE:
            std::cout << "NOT IMPLEMENTED YET! (ID: BVHTree_BinarySphere<T> 010)" << std::endl;
            break;

        default:
            std::cout << "Error: BVHNode_BinarySphere<T>::TestOverlapWithTillLeafNodes Fn!" << std::endl;
            assert( false );
            break;
    }
    //---------------------------------------------------------------
    return false;
}

---

Friends And Related Function Documentation

template<typename T>

std::ostream& operator<<	(	std::ostream &	output,
		BVHTree_BinarySphere< T > const &	obj
	)			[friend]

Definition at line 31 of file TAPsBVHTree_BinarySphere.hpp.

    {
        output  << "BVHTree_BinarySphere<" << typeid(T).name() << "> ID:"
                << " with " << obj.m_iTotalNodes << " nodes"
                << " and the root ptr is " << obj.m_pRoot 
                << "\n";
        return output;
    }

---

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

• G:/spunak_xp/Works/TAPs/Include/TAPs/CD/TAPsBVHTree_BinarySphere.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/CD/TAPsBVHTree_BinarySphere.cpp