TAPsBoundingCylinder.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsBoundingCylinder.hpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (08/22/2006)
UPDATE          (12/30/2010)
******************************************************************************/
#include "TAPsBoundingCylinder.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>
BoundingCylinder<T>::BoundingCylinder ()
    : BoundingVolume<T>( Enum::BOUNDING_CYLINDER ),
      m_tRadius( 1 ),
      m_tHeight( 1 )
{}
//-----------------------------------------------------------------------------
template <typename T>
BoundingCylinder<T>::BoundingCylinder ( int id )
    : BoundingVolume<T>( Enum::BOUNDING_CYLINDER, id ),
      m_tRadius( 1 ),
      m_tHeight( 1 )
{}
//-----------------------------------------------------------------------------
template <typename T>
BoundingCylinder<T>::BoundingCylinder ( BoundingCylinder<T> const & orig )
    : BoundingVolume<T>( orig ),
      m_tRadius( orig.m_tRadius ),
      m_tHeight( orig.m_tHeight )
{
    m_vCenter = orig.m_vCenter;
}
//-----------------------------------------------------------------------------
template <typename T>
BoundingCylinder<T>::~BoundingCylinder ()
{}
//-----------------------------------------------------------------------------
// Return this object info as a string
template <typename T>
std::string BoundingCylinder<T>::StrInfo () const
{
    std::string str = BoundingVolume<T>::StrInfo();
    std::ostringstream ss;
    ss << "\n  Radius: " << m_tRadius;
    ss << "\n  Height: " << m_tHeight;
    return str + ss.str() + "\n";
}
//-----------------------------------------------------------------------------
// Assignment Operator
template <typename T>
inline TAPs::BoundingCylinder<T> & TAPs::BoundingCylinder<T>::operator= ( 
    TAPs::BoundingCylinder<T> const & orig )
{   
    if ( this != &orig ) {
        m_vCenter = orig.m_vCenter;
        m_tRadius = orig.m_tRadius;
        m_tHeight = orig.m_tHeight;
    }
    return *this;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// virtual void TransformByTranslationRatationAndScale ();
//template <typename T>
//void BoundingCylinder<T>::TransformByTranslationRatationAndScale ()
//{}
//-----------------------------------------------------------------------------
template <typename T>
void BoundingCylinder<T>::ScaledBy ( T val )
{
    assert( 0.0 <= val );
    GetTransform().PreApplyUniformScale( val );
}
//-----------------------------------------------------------------------------
//=============================================================================
// Operations
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingCylinder<T>::TestPointLocation ( 
    Vector3<T> const & point,
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheCylinder = false;
    //---------------------------------------------------------------
    // In the local coordinate of the bounding cylinder, 
    // the cylinder axis is parallel to z-axis 
    // where it is shifted by the cylinder center.
    // The cylinder has radius, height and center.
    // Its height is measured from -z and +z axis
    // where its center is situated between height/2 in -z and +z axis.
    //---------------------------------------------------------------
    // Transform point to the cylinder BV local coordinate
    Vector3<T> location = point;
    location = (GetTransform().GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    // Shift the location of point by the cylinder BV center
    // i.e. shift the cylinder BV to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the cylinder BV is centered at the origin with its axis on the z-axis
    // where its height is from -height/2 to +height/2.
    // And the input point has been transformed into the cylinder coordinate.
    // The test can be performed below
    T   halfHeight = GetHeight()/2.0;
    T   ptRadius = sqrt( location[0]*location[0] + location[1]*location[1] );
    //===============================================================
    // If the point is INSIDE the cylinder
    //---------------------------------------------------------------
    // If the point is within the cylinder radius
    if ( ptRadius <= GetRadius() ) { 
        // If the point is within the cylinder height
        if ( -halfHeight <= location[2] && location[2] <= halfHeight ) {
            // Find the shortest distance vector from the point to the surface 
            // of the cylinder
            if ( pvDistance ) {
                T   difRadius = GetRadius() - ptRadius;
                T   difHeight = halfHeight - fabs( location[2] );
                if ( difRadius <= difHeight ) {
                    // If the point is on the z-axis (degenerate case)
                    if ( difRadius >= GetRadius() ) {
                        (*pvDistance).SetXYZ( 0, GetRadius(), 0 );
                    }
                    // If the point is NOT on the z-axis
                    else {
                        Vector2<T> difDirection = Vector2<T>( location[0], location[1] );
                        difDirection.Normalized();
                        difDirection *= difRadius;
                        (*pvDistance).SetXYZ( difDirection[0], difDirection[1], 0 );
                    }
                }
                else {
                    (*pvDistance).SetXYZ( 0, 0, location[2] >= 0 ? difHeight : -difHeight );
                }
                //-------------------------
                // 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 cylinder surface.
                (*pvDistance) = GetTransform().GetMatrixRotation() * (*pvDistance);
            }
            //-------------------------
            isThePointInsideTheCylinder = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the cylinder radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheCylinder;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingCylinder<T>::TestPointLocation ( 
    Vector3<T> const & point,
    TransformationSupport<T> const * const pTransform, 
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheCylinder = 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 cylinder, 
    // the cylinder axis is parallel to z-axis 
    // where it is shifted by the cylinder center.
    // The cylinder has radius, height and center.
    // Its height is measured from -z and +z axis
    // where its center is situated between height/2 in -z and +z axis.
    //---------------------------------------------------------------
    // Transform point to the cylinder 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 cylinder center
    // i.e. shift the cylinder to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the cylinder is centered at the origin with its axis on the z-axis
    // where its height is from -height/2 to +height/2.
    // And the input point has been transformed into the cylinder coordinate.
    // The test can be performed below
    T   halfHeight = GetHeight()/2.0;
    T   ptRadius = sqrt( location[0]*location[0] + location[1]*location[1] );
    //===============================================================
    // If the point is INSIDE the cylinder
    //---------------------------------------------------------------
    // If the point is within the cylinder radius
    if ( ptRadius <= GetRadius() ) { 
        // If the point is within the cylinder height
        if ( -halfHeight <= location[2] && location[2] <= halfHeight ) {
            // Find the shortest distance vector from the point to the surface 
            // of the cylinder
            if ( pvDistance ) {
                //(*pvDistance).SetXYZ( 0, 0, 0 );
                T   difRadius = GetRadius() - ptRadius;
                T   difHeight = halfHeight - fabs( location[2] );
                if ( difRadius <= difHeight ) {
                    // If the point is on the z-axis (degenerate case)
                    if ( difRadius >= GetRadius() ) {
                        (*pvDistance).SetXYZ( 0, GetRadius(), 0 );
                    }
                    // If the point is NOT on the z-axis
                    else {
                        Vector2<T> difDirection = Vector2<T>( location[0], location[1] );
                        difDirection.Normalized();
                        difDirection *= difRadius;
                        (*pvDistance).SetXYZ( difDirection[0], difDirection[1], 0 );
                    }
                }
                else {
                    (*pvDistance).SetXYZ( 0, 0, location[2] >= 0 ? difHeight : -difHeight );
                }
                //-------------------------
                // 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 cylinder surface.
                (*pvDistance) = transform.GetMatrixRotation() * (*pvDistance);
                //(*pvDistance) = pureRotation * (*pvDistance);
            }
            //-------------------------
            isThePointInsideTheCylinder = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the cylinder radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheCylinder;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingCylinder<T>::TestSphereLocation ( 
    Vector3<T> const & sphereCenter,
    T   sphereRadius,
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheCylinder = false;
    //---------------------------------------------------------------
    // In the local coordinate of the bounding cylinder, 
    // the cylinder axis is parallel to z-axis 
    // where it is shifted by the cylinder center.
    // The cylinder has radius, height and center.
    // Its height is measured from -z and +z axis
    // where its center is situated between height/2 in -z and +z axis.
    //---------------------------------------------------------------
    // Transform the sphere center to the cylinder BV local coordinate
    Vector3<T> location = sphereCenter;
    location = (GetTransform().GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    // Shift the location of sphere center by the cylinder BV center
    // i.e. shift the cylinder BV to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the cylinder BV is centered at the origin with its axis on the z-axis
    // where its height is from -height/2 to +height/2.
    // And the input sphere center has been transformed into the cylinder coordinate.
    // The test can be performed below
    T   halfHeight = GetHeight()/2.0;
    T   ptRadius = sqrt( location[0]*location[0] + location[1]*location[1] ) - sphereRadius;
    //===============================================================
    // If the point is INSIDE the cylinder
    //---------------------------------------------------------------
    // If the point is within the cylinder radius
    if ( ptRadius <= GetRadius() ) { 
        // If the point is within the cylinder height
        if ( -halfHeight <= location[2] && location[2] <= halfHeight ) {
            // Find the shortest distance vector from the point to the surface 
            // of the cylinder
            if ( pvDistance ) {
                T   difRadius = GetRadius() - ptRadius;
                T   difHeight = halfHeight - fabs( location[2] - sphereRadius );
                if ( difRadius <= difHeight ) {
                    // If the point is on the z-axis (degenerate case)
                    if ( difRadius >= GetRadius() ) {
                        (*pvDistance).SetXYZ( 0, GetRadius(), 0 );
                    }
                    // If the point is NOT on the z-axis
                    else {
                        Vector2<T> difDirection = Vector2<T>( location[0], location[1] );
                        difDirection.Normalized();
                        difDirection *= difRadius;
                        (*pvDistance).SetXYZ( difDirection[0], difDirection[1], 0 );
                    }
                }
                else {
                    (*pvDistance).SetXYZ( 0, 0, location[2] + sphereRadius >= 0 ? difHeight + sphereRadius : -difHeight - sphereRadius );
                }
                //-------------------------
                // 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 cylinder surface.
                (*pvDistance) = GetTransform().GetMatrixRotation() * (*pvDistance);
            }
            //-------------------------
            isThePointInsideTheCylinder = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the cylinder radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheCylinder;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingCylinder<T>::TestSphereLocation ( 
    Vector3<T> const & sphereCenter,
    T   sphereRadius,
    TransformationSupport<T> const * const pTransform, 
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheCylinder = 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 cylinder, 
    // the cylinder axis is parallel to z-axis 
    // where it is shifted by the cylinder center.
    // The cylinder has radius, height and center.
    // Its height is measured from -z and +z axis
    // where its center is situated between height/2 in -z and +z axis.
    //---------------------------------------------------------------
    // Transform the sphere center to the cylinder local coordinate
    Vector3<T> location = sphereCenter;
    location = (transform.GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    // Shift the location of sphere center by the cylinder center
    // i.e. shift the cylinder to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the cylinder is centered at the origin with its axis on the z-axis
    // where its height is from -height/2 to +height/2.
    // And the input sphere center has been transformed into the cylinder coordinate.
    // The test can be performed below
    T   halfHeight = GetHeight()/2.0;
    T   ptRadius = sqrt( location[0]*location[0] + location[1]*location[1] ) - sphereRadius;
    //===============================================================
    // If the point is INSIDE the cylinder
    //---------------------------------------------------------------
    // If the point is within the cylinder radius
    if ( ptRadius <= GetRadius() ) { 
        // If the point is within the cylinder height
        if ( -halfHeight <= location[2] && location[2] <= halfHeight ) {
            // Find the shortest distance vector from the point to the surface 
            // of the cylinder
            if ( pvDistance ) {
                //(*pvDistance).SetXYZ( 0, 0, 0 );
                T   difRadius = GetRadius() - ptRadius;
                T   difHeight = halfHeight - fabs( location[2] );
                if ( difRadius <= difHeight ) {
                    // If the point is on the z-axis (degenerate case)
                    if ( difRadius >= GetRadius() ) {
                        (*pvDistance).SetXYZ( 0, GetRadius(), 0 );
                    }
                    // If the point is NOT on the z-axis
                    else {
                        Vector2<T> difDirection = Vector2<T>( location[0], location[1] );
                        difDirection.Normalized();
                        difDirection *= difRadius;
                        (*pvDistance).SetXYZ( difDirection[0], difDirection[1], 0 );
                    }
                }
                else {
                    (*pvDistance).SetXYZ( 0, 0, location[2] + sphereRadius >= 0 ? difHeight + sphereRadius : -difHeight - sphereRadius );
                }
                //-------------------------
                // 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 cylinder surface.
                (*pvDistance) = transform.GetMatrixRotation() * (*pvDistance);
                //(*pvDistance) = pureRotation * (*pvDistance);
            }
            //-------------------------
            isThePointInsideTheCylinder = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the cylinder radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheCylinder;
}
//-----------------------------------------------------------------------------
// TestOverlapWith
template <typename T>
T BoundingCylinder<T>::TestOverlapWith ( BoundingVolume<T> const * const that ) const
{
    std::cout << "BoundingCylinder<T>::TestOverlapWith( BoundingVolume<T> ) -- NOT IMPLEMENTED YET!!!\n";

    switch ( that->GetType() ) {
    case Enum::BOUNDING_CYLINDER:
        break;
    case Enum::BOUNDING_SPHERE:
        break;
    case Enum::BOUNDING_BOX:
        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 BoundingCylinder<T>::g_uiDisplayList = 0;
template <typename T> GLenum BoundingCylinder<T>::g_eDrawStyle = GLU_FILL;
//-----------------------------------------------------------------------------
template <typename T>
void BoundingCylinder<T>::Draw ( GLenum drawStyle, Vector4<T> color )
{
    //-----------------------------------------------------
    //std::cout << "Draw CYLINDER Bounding Volume\n";
    if ( drawStyle != g_eDrawStyle ) {
        g_eDrawStyle = drawStyle;
        if ( g_uiDisplayList ) {
            glDeleteLists( g_uiDisplayList, 1 );
            g_uiDisplayList = 0;
        }
    }
    if ( !g_uiDisplayList ) {
        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 );
                    glVertex3f( 0, 0, -0.5 );
                    glVertex3f( 0, 0,  0.5 );
                glEnd();
                //--------------------------
                // Draw Bottom Cap
                glTranslatef( 0.0, 0.0, -0.5 );
                gluDisk( 
                    qObj,
                    0,      // Inner Radius
                    1,      // Outer Radius
                    20,     // #slices (#subdivisions around the z axis)
                    10      // #loops (#concentric rings about the origin)
                );
                //--------------------------
                // Draw Cylinder
                gluCylinder( 
                    qObj, 
                    1,      // Base Radius
                    1,      // Top  Radius
                    1,      // Height
                    20,     // #slices
                    1       // #stacks
                );
                //--------------------------
                glTranslatef( 0.0, 0.0, 1.0 );
                // Draw Top Cap
                gluDisk( 
                    qObj,
                    0,      // Inner Radius
                    1,      // Outer Radius
                    20,     // #slices (#subdivisions around the z axis)
                    10      // #loops (#concentric rings about the origin)
                );
            //-----------------------------------
            //glPopMatrix();
        glEndList();
        gluDeleteQuadric( qObj );
    }
    //-----------------------------------------------------
    glPushMatrix();
        //---------------------------------------
        GetTransform().TransformByOpenGLForDrawing();
        //---------------------------------------
        glColor4fv( color.GetDataFloat() );
        glTranslatef( GetCenter()[0], GetCenter()[1], GetCenter()[2] );
        glScalef( GetRadius(), GetRadius(), GetHeight() );
        glCallList( g_uiDisplayList );
    glPopMatrix();
}
//-----------------------------------------------------------------------------
#endif
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----