TAPsBVHNodeLeaf.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsBVHNodeLeaf.cpp

BVHNodeLeaf class is for a Boundary Volume Hierarchy Leaf Node.
It does not contain any primitive.

SUKITTI PUNAK   (10/14/2009)
UPDATE          (10/08/2010)
******************************************************************************/
#include "TAPsBVHNodeLeaf.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Constructor(s) and Destructor
//-----------------------------------------------------------------------------
template <typename T>
BVHNodeLeaf<T>::BVHNodeLeaf (
    Enum::CD            type, 
    int                 id, 
    BVHNode<T> *        parent )
    : BVHNode<T>( id, type, parent )
{}
//-----------------------------------------------------------------------------
template <typename T>
BVHNodeLeaf<T>::~BVHNodeLeaf ()
{}
//-----------------------------------------------------------------------------
// StrInfo
template <typename T>
std::string BVHNodeLeaf<T>::StrInfo () const
{
    std::stringstream output;
    output  <<  "TAPs::BVHNodeLeaf<"
            <<  typeid(T).name() << "> Class\n";
    return output.str();
}
//-----------------------------------------------------------------------------
//=============================================================================
// Node Operations
//-----------------------------------------------------------------------------
// Update
// update only this node
template <typename T>
void BVHNodeLeaf<T>::Update ()
{
    //---------------------------------------------------------------
    switch ( m_eType ) {
        case Enum::BVH_NODE_LEAF_SPHERE:
            UpdateSphere();
            break;
        case Enum::BVH_NODE_LEAF_AABB:
            break;
        case Enum::BVH_NODE_LEAF_OBB:
            break;
        default:
            assert( false );
            break;
    }
}
//-----------------------------------------------------------------------------
// UpdateSphere
template <typename T>
void BVHNodeLeaf<T>::UpdateSphere ()
{
    //std::cout << "UpdateSphere Node: " << this << "\n";

    /*
    //---------------------------------------------------------------
    Vector3<T> AABB[2];
    //HEVertex<T> * vertex = m_listVertex->Head();
    HEHalfEdge<T> * firstHalfEdge = m_primHEFace->IncidentHalfEdge();
    HEHalfEdge<T> * halfEdge = firstHalfEdge->Next();
    Vector3<T> vertex = firstHalfEdge->Vertex()->GetPosition();
    AABB[0] = AABB[1] = vertex;
    //---------------------------------------------------------------
    // For Each Vertex
     while ( halfEdge != firstHalfEdge ) {
        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();
    }
    //---------------------------------------------------------------
    // 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;
    halfEdge = firstHalfEdge = m_primHEFace->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 );
    //---------------------------------------------------------------
    SetCenter( vCenter );
    SetRadius( radius );
    //*/
}
//-----------------------------------------------------------------------------
// TestOverlapWith
template <typename T>
T BVHNodeLeaf<T>::TestOverlapWith ( BVHNode<T> const * const that ) const
{
    switch ( m_eType ) {
        case Enum::BVH_NODE_BINARY_SPHERE:
        case Enum::BVH_NODE_QUAD_SPHERE:
        case Enum::BVH_NODE_OCTANT_SPHERE:
        case Enum::BVH_NODE_GENERIC_SPHERE:
        case Enum::BVH_NODE_LEAF_SPHERE:
            switch ( that->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:
                case Enum::BVH_NODE_LEAF_SPHERE:
                    return    ( GetCenter() - that->GetCenter() ).Length() 
                            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
                    break;
                default:
                    std::cout << "Error: BVHNode<T>::TestOverlapWith Fn!" << std::endl;
                    assert( false );
                    break;
            }
            break;
        default:
            std::cout << "Error: BVHNode<T>::TestOverlapWith Fn!" << std::endl;
            assert( false );
            break;
    }
    return -777;    // -777 is an Error Code
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #1
template <typename T>
T BVHNodeLeaf<T>::TestOverlapSphereWithSphere ( 
            BVHNode<T> const * const that ) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithSphere( #1 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( that );
        return distance;
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( that );
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #2
template <typename T>
T BVHNodeLeaf<T>::TestOverlapSphereWithSphere ( 
            BVHNode<T> const * const that, 
            Matrix4x4<T> const & thatTransform ) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithSphere( #2 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( that, thatTransform );
        return distance;
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( that, thatTransform );
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #3
template <typename T>
T BVHNodeLeaf<T>::TestOverlapSphereWithSphere ( 
            Matrix4x4<T> const & thisTransform, 
            BVHNode<T> const * const that ) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithSphere( #3 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that );
        return distance;
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that );
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #4
template <typename T>
T BVHNodeLeaf<T>::TestOverlapSphereWithSphere ( 
            Matrix4x4<T> const & thisTransform, 
            BVHNode<T> const * const that, 
            Matrix4x4<T> const & thatTransform ) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithSphere( #4 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that, thatTransform );
        return distance;
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that, thatTransform );
    }
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVSphere #1
template <typename T>
T BVHNodeLeaf<T>::TestOverlapSphereWithBVSphere ( 
    Vector3<T> const & centerOfBVSphere,    
    T radiusOfBVSphere                      
) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithBVSphere( #1 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVSphere( centerOfBVSphere, radiusOfBVSphere );
    return distance;
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVSphere #2
template <typename T>
T BVHNodeLeaf<T>::TestOverlapSphereWithBVSphere ( 
    Matrix4x4<T> const & transformA,        
    Vector3<T> const & centerOfBVSphere,    
    T radiusOfBVSphere                      
) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithBVSphere( #2 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVSphere( transformA, centerOfBVSphere, radiusOfBVSphere );
    return distance;
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVCylinder #1
template <typename T>
bool BVHNodeLeaf<T>::TestOverlapSphereWithBVCylinder_AtOrigin ( 
    Vector3<T> const & centerOfBVCylinder,  
    T radiusOfBVCylinder,                   
    T heightOfBVCylinder                    
) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithBVCylinder( #1 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVCylinder_AtOrigin( radiusOfBVCylinder, heightOfBVCylinder );
    if ( distance > Math<T>::ZERO ) return false;
    else                            return true;
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVCylinder #2
template <typename T>
bool BVHNodeLeaf<T>::TestOverlapSphereWithBVCylinder_AtOrigin ( 
    Matrix4x4<T> const & transformA,        
    Vector3<T> const & centerOfBVCylinder,  
    T radiusOfBVCylinder,                   
    T heightOfBVCylinder                    
) const
{
    std::cout << "BVHNodeLeaf<T>::TestOverlapSphereWithBVCylinder( #2 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVCylinder_AtOrigin( transformA, radiusOfBVCylinder, heightOfBVCylinder );
    return ( distance > Math<T>::ZERO );
}
//-----------------------------------------------------------------------------


#if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
// DrawByOpenGL
//-----------------------------------------------------------------------------
template <typename T>
void BVHNodeLeaf<T>::DrawByOpenGL () const
{
    DrawBV();
}
//-----------------------------------------------------------------------------
template <typename T>
void BVHNodeLeaf<T>::DrawByOpenGL ( 
        int currentLevel, int startLevel, int endLevel ) const
{
    if ( startLevel <= currentLevel && currentLevel <= endLevel ) {
        DrawBV();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void BVHNodeLeaf<T>::DrawBV ( GLenum drawStyle ) const
{
    switch ( m_eType ) {
        //-----------------------------------------------------------
        // DRAW SPHERE BVH
        case Enum::BVH_NODE_LEAF_SPHERE:
            DrawSphereBV( drawStyle );
            break;
        //-----------------------------------------------------------
        // DRAW AABB BVH
        case Enum::BVH_NODE_LEAF_AABB:
            DrawAABBBV( drawStyle );
            break;
        //-----------------------------------------------------------
        // DRAW OBB BVH
        case Enum::BVH_NODE_LEAF_OBB:
            DrawOBBBV( drawStyle );
            break;

        //-----------------------------------------------------------
        // DRAW SPHERE BVH
        case Enum::BVH_NODE_BINARY_SPHERE:
        case Enum::BVH_NODE_QUAD_SPHERE:
        case Enum::BVH_NODE_OCTANT_SPHERE:
        case Enum::BVH_NODE_GENERIC_SPHERE:
            DrawSphereBV();
            break;
        //-----------------------------------------------------------
        // DRAW AABB BVH
        case Enum::BVH_NODE_BINARY_AABB:
        case Enum::BVH_NODE_QUAD_AABB:
        case Enum::BVH_NODE_OCTANT_AABB:
        case Enum::BVH_NODE_GENERIC_AABB:
            DrawAABBBV();
            break;
        //-----------------------------------------------------------
        // DRAW OBB BVH
        case Enum::BVH_NODE_BINARY_OBB:
        case Enum::BVH_NODE_QUAD_OBB:
        case Enum::BVH_NODE_OCTANT_OBB:
        case Enum::BVH_NODE_GENERIC_OBB:
            DrawOBBBV();
            break;
    }
}
//-----------------------------------------------------------------------------
#endif // #if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----