TAPsBoundingBox.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsBoundingBox.hpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (08/26/2010)
UPDATE          (09/07/2010)
******************************************************************************/
#include "TAPsBoundingBox.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>
BoundingBox<T>::BoundingBox ()
    : BoundingVolume<T>( Enum::BOUNDING_BOX )
    , m_tHalfWidth_x( 0.5 )
    , m_tHalfHeight_y( 0.5 )
    , m_tHalfDepth_z( 0.5 )
{}
//-----------------------------------------------------------------------------
template <typename T>
BoundingBox<T>::BoundingBox ( int id )
    : BoundingVolume<T>( Enum::BOUNDING_BOX, id )
    , m_tHalfWidth_x( 0.5 )
    , m_tHalfHeight_y( 0.5 )
    , m_tHalfDepth_z( 0.5 )
{}
//-----------------------------------------------------------------------------
template <typename T>
BoundingBox<T>::BoundingBox ( BoundingBox<T> const & orig )
    : BoundingVolume<T>( orig ),
    , m_tHalfWidth_x( orig.m_tHalfWidth_x )
    , m_tHalfHeight_y( orig.m_tHalfHeight_y )
    , m_tHalfDepth_z( orig.m_tHalfDepth_z )
{
    m_vCenter = orig.m_vCenter;
}
//-----------------------------------------------------------------------------
template <typename T>
BoundingBox<T>::~BoundingBox ()
{}
//-----------------------------------------------------------------------------
// Return this object info as a string
template <typename T>
std::string BoundingBox<T>::StrInfo () const
{
    std::string str = BoundingVolume<T>::StrInfo();
    std::ostringstream ss;
    ss << "\n  Width:  " << GetWidth();
    ss << "\n  Height: " << GetHeight();
    ss << "\n  Depth:  " << GetDepth();
    return str + ss.str() + "\n";
}
//-----------------------------------------------------------------------------
// Assignment Operator
template <typename T>
inline TAPs::BoundingBox<T> & TAPs::BoundingBox<T>::operator= ( 
    TAPs::BoundingBox<T> const & orig )
{   
    if ( this != &orig ) {
        m_vCenter = orig.m_vCenter;
        m_tWidth_x = orig.m_tWidth_x;
        m_tHeight_y = orig.m_tHeight_y;
        m_tDepth_z = orig.m_tDepth_z;
    }
    return *this;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// virtual void TransformByTranslationRatationAndScale ();
//template <typename T>
//void BoundingBox<T>::TransformByTranslationRatationAndScale ()
//{}
//-----------------------------------------------------------------------------
template <typename T>
void BoundingBox<T>::ScaledBy ( T val )
{
    assert( 0.0 <= val );
    GetTransform().PreApplyUniformScale( val );
}
//-----------------------------------------------------------------------------
//=============================================================================
// Operations
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingBox<T>::TestPointLocation ( 
    Vector3<T> const & point,
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheBox = false;
    //---------------------------------------------------------------
    // In the local coordinate of the bounding box, 
    // the box is aligned with xyz-axes
    // where it is shifted by the box center.
    // The box has width, height, and depth are aligned with x, y, and z axis, respectively.
    //---------------------------------------------------------------
    // Transform point to the box local coordinate
    Vector3<T> location = point;
    //location -= GetTransform().GetTranslation();
    //location = GetTransform().GetMatrixRotation().GetInverse() * location;
    location = (GetTransform().GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    // Shift the location of point by the box center
    // i.e. shift the box to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the box is centered at the origin.
    // And the input point has been transformed into the box coordinate.
    // The test can be performed below
    T distance[3];
    bool plusSigns[3];
    if ( location[0] > 0 ) {
        distance[0] = m_tHalfWidth_x - location[0];
        plusSigns[0] = true;
    }
    else {
        distance[0] = location[0] + m_tHalfWidth_x;
        plusSigns[0] = false;
    }
    if ( location[1] > 0 ) {
        distance[1] = m_tHalfHeight_y - location[1];
        plusSigns[1] = true;
    }
    else {
        distance[1] = location[1] + m_tHalfHeight_y;
        plusSigns[1] = false;
    }
    if ( location[2] > 0 ) {
        distance[2] = m_tHalfDepth_z - location[2];
        plusSigns[2] = true;
    }
    else {
        distance[2] = location[2] + m_tHalfDepth_z;
        plusSigns[2] = false;
    }

    if ( distance[0] >= 0 && distance[1] >= 0 && distance[2] >= 0 ) {
        if ( pvDistance ) {
            // Find the shortest distance vector from the point to the surface
            if ( distance[0] < distance[1] ) {
                if ( distance[0] < distance[2] ) {
                    if ( plusSigns[0] ) pvDistance->SetXYZ(  distance[0], 0, 0 );
                    else                pvDistance->SetXYZ( -distance[0], 0, 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }
            else {
                if ( distance[1] < distance[2] ) {
                    if ( plusSigns[1] ) pvDistance->SetXYZ( 0,  distance[1], 0 );
                    else                pvDistance->SetXYZ( 0, -distance[1], 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }

            //-------------------------
            // Now rotate it back by the rotation matrix (from the transform matrix).
            // REMARK: Translation (from the transform matrix) is NOT applied back, 
            //         because pvDistance represents a displacement vector from 
            //         the input point to the box surface.
            (*pvDistance) = GetTransform().GetMatrixRotation() * (*pvDistance);
        }

        isThePointInsideTheBox = true;
    }
    //===============================================================
    // If the point is NOT INSIDE the box
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            pvDistance->SetXYZ( 0, 0, 0 );
        }
    }

    return isThePointInsideTheBox;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingBox<T>::TestPointLocation ( 
    Vector3<T> const & point,
    TransformationSupport<T> const * const pTransform, 
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheBox = false;
    //---------------------------------------------------------------
    TransformationSupport<T> transform; // default ctor is an identity
    Matrix4x4<T> pureRotation;
    pureRotation *= pTransform->GetMatrixRotation();
    transform.RefToMatrixTransform() *= pTransform->GetMatrixTransform();
    // The above statement is equivalent to the below statement
    //transform.ReturnMatrixTransform() = transform.GetMatrixTransform() * pTransform->GetMatrixTransform();
    pureRotation *= GetTransform().GetMatrixRotation();
    transform.RefToMatrixTransform() *= GetTransform().GetMatrixTransform();
    // The above statement is equivalent to the below statement
    //transform.ReturnMatrixTransform() = transform.GetMatrixTransform() * GetTransform().GetMatrixTransform();
    //---------------------------------------------------------------
    // In the local coordinate of the bounding box, 
    // the box is aligned with xyz-axes
    // where it is shifted by the box center.
    // The box has width, height, and depth are aligned with x, y, and z axis, respectively.
    //---------------------------------------------------------------
    // Transform point to the box local coordinate
    Vector3<T> location = point;
    //location -= transform.GetTranslation();
    //location = transform.GetMatrixRotation().GetInverse() * location;
    location = (transform.GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    // Shift the location of point by the box center
    // i.e. shift the box to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the box is centered at the origin.
    // And the input point has been transformed into the box coordinate.
    // The test can be performed below
    T distance[3];
    bool plusSigns[3];
    if ( location[0] > 0 ) {
        distance[0] = m_tHalfWidth_x - location[0];
        plusSigns[0] = true;
    }
    else {
        distance[0] = location[0] + m_tHalfWidth_x;
        plusSigns[0] = false;
    }
    if ( location[1] > 0 ) {
        distance[1] = m_tHalfHeight_y - location[1];
        plusSigns[1] = true;
    }
    else {
        distance[1] = location[1] + m_tHalfHeight_y;
        plusSigns[1] = false;
    }
    if ( location[2] > 0 ) {
        distance[2] = m_tHalfDepth_z - location[2];
        plusSigns[2] = true;
    }
    else {
        distance[2] = location[2] + m_tHalfDepth_z;
        plusSigns[2] = false;
    }

    if ( distance[0] >= 0 && distance[1] >= 0 && distance[2] >= 0 ) {
        if ( pvDistance ) {
            // Find the shortest distance vector from the point to the surface
            if ( distance[0] < distance[1] ) {
                if ( distance[0] < distance[2] ) {
                    if ( plusSigns[0] ) pvDistance->SetXYZ(  distance[0], 0, 0 );
                    else                pvDistance->SetXYZ( -distance[0], 0, 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }
            else {
                if ( distance[1] < distance[2] ) {
                    if ( plusSigns[1] ) pvDistance->SetXYZ( 0,  distance[1], 0 );
                    else                pvDistance->SetXYZ( 0, -distance[1], 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }

            //-------------------------
            // Now rotate it back by the rotation matrix (from the transform matrix).
            // REMARK: Translation (from the transform matrix) is NOT applied back, 
            //         because pvDistance represents a displacement vector from 
            //         the input point to the box surface.
            (*pvDistance) = pureRotation * (*pvDistance);
        }

        isThePointInsideTheBox = true;
    }
    //===============================================================
    // If the point is NOT INSIDE the box
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            pvDistance->SetXYZ( 0, 0, 0 );
        }
    }

    return isThePointInsideTheBox;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingBox<T>::TestSphereLocation ( 
    Vector3<T> const & sphereCenter,
    T   sphereRadius,
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheBox = false;
    //---------------------------------------------------------------
    // In the local coordinate of the bounding box, 
    // the box is aligned with xyz-axes
    // where it is shifted by the box center.
    // The box has width, height, and depth are aligned with x, y, and z axis, respectively.
    //---------------------------------------------------------------
    // Transform the sphere center to the box local coordinate
    Vector3<T> location = sphereCenter;
    location = (GetTransform().GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    // Shift the location of sphere center by the box center
    // i.e. shift the box to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the box is centered at the origin.
    // And the input sphere center has been transformed into the box coordinate.
    // The test can be performed below
    T distance[3];
    bool plusSigns[3];
    if ( location[0] > 0 ) {
        distance[0] = m_tHalfWidth_x - location[0] + sphereRadius;
        plusSigns[0] = true;
    }
    else {
        distance[0] = location[0] + m_tHalfWidth_x + sphereRadius;
        plusSigns[0] = false;
    }
    if ( location[1] > 0 ) {
        distance[1] = m_tHalfHeight_y - location[1] + sphereRadius;
        plusSigns[1] = true;
    }
    else {
        distance[1] = location[1] + m_tHalfHeight_y + sphereRadius;
        plusSigns[1] = false;
    }
    if ( location[2] > 0 ) {
        distance[2] = m_tHalfDepth_z - location[2] + sphereRadius;
        plusSigns[2] = true;
    }
    else {
        distance[2] = location[2] + m_tHalfDepth_z + sphereRadius;
        plusSigns[2] = false;
    }

    if ( distance[0] >= 0 && distance[1] >= 0 && distance[2] >= 0 ) {
        if ( pvDistance ) {
            // Find the shortest distance vector from the point to the surface
            if ( distance[0] < distance[1] ) {
                if ( distance[0] < distance[2] ) {
                    if ( plusSigns[0] ) pvDistance->SetXYZ(  distance[0], 0, 0 );
                    else                pvDistance->SetXYZ( -distance[0], 0, 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }
            else {
                if ( distance[1] < distance[2] ) {
                    if ( plusSigns[1] ) pvDistance->SetXYZ( 0,  distance[1], 0 );
                    else                pvDistance->SetXYZ( 0, -distance[1], 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }

            //-------------------------
            // Now rotate it back by the rotation matrix (from the transform matrix).
            // REMARK: Translation (from the transform matrix) is NOT applied back, 
            //         because pvDistance represents a displacement vector from 
            //         the input point to the box surface.
            (*pvDistance) = GetTransform().GetMatrixRotation() * (*pvDistance);
        }

        isThePointInsideTheBox = true;
    }
    //===============================================================
    // If the point is NOT INSIDE the box
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            pvDistance->SetXYZ( 0, 0, 0 );
        }
    }

    return isThePointInsideTheBox;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingBox<T>::TestSphereLocation ( 
    Vector3<T> const & sphereCenter,
    T   sphereRadius,
    TransformationSupport<T> const * const pTransform, 
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheBox = false;
    //---------------------------------------------------------------
    TransformationSupport<T> transform; // default ctor is an identity
    Matrix4x4<T> pureRotation;
    pureRotation *= pTransform->GetMatrixRotation();
    transform.RefToMatrixTransform() *= pTransform->GetMatrixTransform();
    // The above statement is equivalent to the below statement
    //transform.ReturnMatrixTransform() = transform.GetMatrixTransform() * pTransform->GetMatrixTransform();
    pureRotation *= GetTransform().GetMatrixRotation();
    transform.RefToMatrixTransform() *= GetTransform().GetMatrixTransform();
    // The above statement is equivalent to the below statement
    //transform.ReturnMatrixTransform() = transform.GetMatrixTransform() * GetTransform().GetMatrixTransform();
    //---------------------------------------------------------------
    // In the local coordinate of the bounding box, 
    // the box is aligned with xyz-axes
    // where it is shifted by the box center.
    // The box has width, height, and depth are aligned with x, y, and z axis, respectively.
    //---------------------------------------------------------------
    // Transform the sphere center to the box local coordinate
    Vector3<T> location = sphereCenter;
    location = (transform.GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    // Shift the location of sphere center by the box center
    // i.e. shift the box to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the box is centered at the origin.
    // And the input sphere center has been transformed into the box coordinate.
    // The test can be performed below
    T distance[3];
    bool plusSigns[3];
    if ( location[0] > 0 ) {
        distance[0] = m_tHalfWidth_x - location[0] + sphereRadius;
        plusSigns[0] = true;
    }
    else {
        distance[0] = location[0] + m_tHalfWidth_x + sphereRadius;
        plusSigns[0] = false;
    }
    if ( location[1] > 0 ) {
        distance[1] = m_tHalfHeight_y - location[1] + sphereRadius;
        plusSigns[1] = true;
    }
    else {
        distance[1] = location[1] + m_tHalfHeight_y + sphereRadius;
        plusSigns[1] = false;
    }
    if ( location[2] > 0 ) {
        distance[2] = m_tHalfDepth_z - location[2] + sphereRadius;
        plusSigns[2] = true;
    }
    else {
        distance[2] = location[2] + m_tHalfDepth_z + sphereRadius;
        plusSigns[2] = false;
    }

    if ( distance[0] >= 0 && distance[1] >= 0 && distance[2] >= 0 ) {
        if ( pvDistance ) {
            // Find the shortest distance vector from the point to the surface
            if ( distance[0] < distance[1] ) {
                if ( distance[0] < distance[2] ) {
                    if ( plusSigns[0] ) pvDistance->SetXYZ(  distance[0], 0, 0 );
                    else                pvDistance->SetXYZ( -distance[0], 0, 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }
            else {
                if ( distance[1] < distance[2] ) {
                    if ( plusSigns[1] ) pvDistance->SetXYZ( 0,  distance[1], 0 );
                    else                pvDistance->SetXYZ( 0, -distance[1], 0 );
                }
                else {
                    if ( plusSigns[2] ) pvDistance->SetXYZ( 0, 0,  distance[2] );
                    else                pvDistance->SetXYZ( 0, 0, -distance[2] );
                }
            }

            //-------------------------
            // Now rotate it back by the rotation matrix (from the transform matrix).
            // REMARK: Translation (from the transform matrix) is NOT applied back, 
            //         because pvDistance represents a displacement vector from 
            //         the input point to the box surface.
            (*pvDistance) = pureRotation * (*pvDistance);
        }

        isThePointInsideTheBox = true;
    }
    //===============================================================
    // If the point is NOT INSIDE the box
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            pvDistance->SetXYZ( 0, 0, 0 );
        }
    }

    return isThePointInsideTheBox;
}
//-----------------------------------------------------------------------------
// TestOverlapWith
template <typename T>
T BoundingBox<T>::TestOverlapWith ( BoundingVolume<T> const * const that ) const
{
    std::cout << "BoundingBox<T>::TestOverlapWith( BoundingVolume<T> ) -- NOT IMPLEMENTED YET!!!\n";

    switch ( that->GetType() ) {
    case Enum::BOUNDING_BOX:
        break;
    case Enum::BOUNDING_SPHERE:
        break;
    case Enum::BOUNDING_CYLINDER:
        break;
    }

    return 0;
}
/*
//-----------------------------------------------------------------------------
// TestOverlapWith
template <typename T>
T BVHNode<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_HALFEDGE_APRIM:
        case Enum::BVH_NODE_LEAF_SPHERE_HALFEDGE_PRIMS:
            switch ( that->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_HALFEDGE_APRIM:
                    return    ( GetCenter() - that->GetCenter() ).Length() 
                            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
                    break;
                case Enum::BVH_NODE_LEAF_SPHERE_HALFEDGE_PRIMS:
                    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
}
//*/
/*
//-----------------------------------------------------------------------------
// TestOverlapWithTillLeafNodes
template <typename T>
T BVHNode<T>::TestOverlapWithTillLeafNodes ( 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_HALFEDGE_APRIM:
        case Enum::BVH_NODE_LEAF_SPHERE_HALFEDGE_PRIMS:
            switch ( that->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_HALFEDGE_APRIM:
                    return    ( GetCenter() - that->GetCenter() ).Length() 
                            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
                    break;
                case Enum::BVH_NODE_LEAF_SPHERE_HALFEDGE_PRIMS:
                    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 BVHNode<T>::TestOverlapSphereWithSphere ( BVHNode<T> const * const that ) const
{
    return    ( GetCenter() - that->GetCenter() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #2
template <typename T>
T BVHNode<T>::TestOverlapSphereWithSphere ( 
                    BVHNode<T> const * const that, 
                    Matrix4x4<T> const & thatTransform ) const
{
    return    (    GetCenter() 
                - (thatTransform*that->GetCenter()).GetVector3() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #3
template <typename T>
T BVHNode<T>::TestOverlapSphereWithSphere ( 
                    Matrix4x4<T> const & thisTransform, 
                    BVHNode<T> const * const that ) const
{
    return    (  (thisTransform*GetCenter()).GetVector3() 
                - that->GetCenter() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #4
template <typename T>
T BVHNode<T>::TestOverlapSphereWithSphere ( 
                    Matrix4x4<T> const & thisTransform, 
                    BVHNode<T> const * const that, 
                    Matrix4x4<T> const & thatTransform ) const
{
    return    (   (thisTransform*GetCenter()).GetVector3() 
                - (thatTransform*that->GetCenter()).GetVector3() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphereTillLeafNodes #1
template <typename T>
T BVHNode<T>::TestOverlapSphereWithSphereTillLeafNodes ( BVHNode<T> const * const that ) const
{
    return    ( GetCenter() - that->GetCenter() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphereTillLeafNodes #2
template <typename T>
T BVHNode<T>::TestOverlapSphereWithSphereTillLeafNodes ( 
                    BVHNode<T> const * const that, 
                    Matrix4x4<T> const & thatTransform ) const
{
    return    (    GetCenter() 
                - (thatTransform*that->GetCenter()).GetVector3() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphereTillLeafNodes #3
template <typename T>
T BVHNode<T>::TestOverlapSphereWithSphereTillLeafNodes ( 
                    Matrix4x4<T> const & thisTransform, 
                    BVHNode<T> const * const that ) const
{
    return    (  (thisTransform*GetCenter()).GetVector3() 
                - that->GetCenter() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphereTillLeafNodes #4
template <typename T>
T BVHNode<T>::TestOverlapSphereWithSphereTillLeafNodes ( 
                    Matrix4x4<T> const & thisTransform, 
                    BVHNode<T> const * const that, 
                    Matrix4x4<T> const & thatTransform ) const
{
    return    (   (thisTransform*GetCenter()).GetVector3() 
                - (thatTransform*that->GetCenter()).GetVector3() ).Length() 
            - ( GetRadius() + that->GetRadius() );  // m_vW[0] is m_tRadius
}
//*/
//-----------------------------------------------------------------------------
#if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
// DrawByOpenGL
//-----------------------------------------------------------------------------
template <typename T> GLuint BoundingBox<T>::g_uiDisplayList = 0;
template <typename T> GLenum BoundingBox<T>::g_eDrawStyle = GLU_FILL;
//-----------------------------------------------------------------------------
template <typename T>
void BoundingBox<T>::Draw ( GLenum drawStyle, Vector4<T> color )
{
    //-----------------------------------------------------
    //std::cout << "Draw BOX Bounding Volume\n";
    if ( drawStyle != g_eDrawStyle ) {
        g_eDrawStyle = drawStyle;
        if ( g_uiDisplayList ) {
            glDeleteLists( g_uiDisplayList, 1 );
            g_uiDisplayList = 0;
        }
    }
    if ( !g_uiDisplayList ) {
        const T s = 0.5;
        g_uiDisplayList = glGenLists( 1 );
        GLUquadricObj *qObj = gluNewQuadric();
        glNewList( g_uiDisplayList, GL_COMPILE );
            // GLenum drawStyle
            //  GLU_FILL
            //  GLU_LINE
            //  GLU_SILHOUETTE
            //  GLU_POINT
            gluQuadricDrawStyle( qObj, drawStyle ); // wireframe
            //glPushMatrix();
            //-----------------------------------
                //--------------------------
                // Draw Center Point
                gluSphere( qObj, 0.02, 9, 9 );
                //--------------------------
                // Draw Axis Line
                glBegin( GL_LINES );
                    glColor3f( 1, 0, 0 );
                    glVertex3f( -s, 0, 0 );
                    glVertex3f(  s, 0, 0 );
                    glColor3f( 0, 1, 0 );
                    glVertex3f( 0, -s, 0 );
                    glVertex3f( 0,  s, 0 );
                    glColor3f( 0, 0, 1 );
                    glVertex3f( 0, 0, -s );
                    glVertex3f( 0, 0,  s );
                glEnd();
                //--------------------------
                // Draw Box
                glBegin( GL_LINE_LOOP );
                    glNormal3f(  0,  0,  1 );
                    glVertex3f( -s, -s,  s );
                    glVertex3f(  s, -s,  s );
                    glVertex3f(  s,  s,  s );
                    glVertex3f(  s,  s,  s );
                    glVertex3f( -s,  s,  s );
                    glVertex3f( -s, -s,  s );

                    glNormal3f(  0,  0, -1 );
                    glVertex3f( -s, -s, -s );
                    glVertex3f(  s,  s, -s );
                    glVertex3f(  s, -s, -s );
                    glVertex3f( -s, -s, -s );
                    glVertex3f( -s,  s, -s );
                    glVertex3f(  s,  s, -s );

                    glNormal3f(  0,  1,  0 );
                    glVertex3f( -s,  s,  s );
                    glVertex3f(  s,  s,  s );
                    glVertex3f(  s,  s, -s );
                    glVertex3f(  s,  s, -s );
                    glVertex3f( -s,  s, -s );
                    glVertex3f( -s,  s,  s );

                    glNormal3f(  0,  1,  0 );
                    glVertex3f( -s, -s,  s );
                    glVertex3f(  s, -s, -s );
                    glVertex3f(  s, -s,  s );
                    glVertex3f( -s, -s,  s );
                    glVertex3f( -s, -s, -s );
                    glVertex3f(  s, -s, -s );

                    glNormal3f(  1,  0,  0 );
                    glVertex3f(  s, -s,  s );
                    glVertex3f(  s, -s, -s );
                    glVertex3f(  s,  s, -s );
                    glVertex3f(  s,  s, -s );
                    glVertex3f(  s,  s,  s );
                    glVertex3f(  s, -s,  s );

                    glNormal3f( -1,  0,  0 );
                    glVertex3f( -s, -s,  s );
                    glVertex3f( -s,  s, -s );
                    glVertex3f( -s, -s, -s );
                    glVertex3f( -s, -s,  s );
                    glVertex3f( -s,  s,  s );
                    glVertex3f( -s,  s, -s );
                glEnd();
            //-----------------------------------
            //glPopMatrix();
        glEndList();
        gluDeleteQuadric( qObj );
    }
    //-----------------------------------------------------
    glPushMatrix();
        //---------------------------------------
        GetTransform().TransformByOpenGLForDrawing();
        //---------------------------------------
        glTranslatef( GetCenter()[0], GetCenter()[1], GetCenter()[2] );
        glScalef( GetWidth(), GetHeight(), GetDepth() );
        glCallList( g_uiDisplayList );
    glPopMatrix();
}
//-----------------------------------------------------------------------------
#endif
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----