TAPsBoundingSphere.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsBoundingSphere.hpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (08/22/2006)
UPDATE          (12/30/2010)
******************************************************************************/
#include "TAPsBoundingSphere.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>
BoundingSphere<T>::BoundingSphere ()
    : BoundingVolume<T>( Enum::BOUNDING_SPHERE ),
      m_tRadius( 1 )
{}
//-----------------------------------------------------------------------------
template <typename T>
BoundingSphere<T>::BoundingSphere ( int id )
    : BoundingVolume<T>( Enum::BOUNDING_SPHERE, id ),
      m_tRadius( 1 )
{}
//-----------------------------------------------------------------------------
template <typename T>
BoundingSphere<T>::BoundingSphere ( const BoundingSphere<T> & orig )
    : BoundingVolume<T>( orig ),
      m_vCenter( orig.m_vCenter ),
      m_tRadius( orig.m_tRadius )
{
    m_vCenter = orig.m_vCenter;
}
//-----------------------------------------------------------------------------
template <typename T>
BoundingSphere<T>::~BoundingSphere ()
{}
//-----------------------------------------------------------------------------
// Return this object info as a string
template <typename T>
std::string BoundingSphere<T>::StrInfo () const
{
    std::string str = BoundingVolume<T>::StrInfo();
    std::ostringstream ss;
    ss << "\n  Radius: " << m_tRadius;
    return str + ss.str() + "\n";
}
//-----------------------------------------------------------------------------
// Assignment Operator
template <typename T>
inline TAPs::BoundingSphere<T> & TAPs::BoundingSphere<T>::operator= ( 
    TAPs::BoundingSphere<T> const & orig )
{   
    if ( this != &orig ) {
        m_vCenter = orig.m_vCenter;
        m_tRadius = orig.m_tRadius;
    }
    return *this;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// virtual void TransformByTranslationRatationAndScale ();
//template <typename T>
//void BoundingSphere<T>::TransformByTranslationRatationAndScale ()
//{}
//-----------------------------------------------------------------------------
template <typename T>
void BoundingSphere<T>::ScaledBy ( T val )
{
    assert( 0.0 <= val );
    GetTransform().PreApplyUniformScale( val );
}
//-----------------------------------------------------------------------------
//=============================================================================
// Operations
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingSphere<T>::TestPointLocation ( 
    Vector3<T> const & point,
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheSphere = false;
    //---------------------------------------------------------------
    // In the local coordinate of the bounding sphere, 
    // the sphere's center is at the origin. 
    // The sphere has radius and center.
    //---------------------------------------------------------------
    // Transform point to the sphere BV local coordinate
    Vector3<T> location = point;
    location = (GetTransform().GetMatrixTransform().GetInverse() * Vector4<T>(location)).GetVector3();
    // Shift the location of point by the sphere BV center
    // i.e. shift the sphere BV to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the sphere BV is centered at the origin.
    // And the input point has been transformed into the sphere BV coordinate.
    // The test can be performed below.
    T   ptRadius = location.Length();
    //===============================================================
    // If the point is INSIDE the sphere
    //---------------------------------------------------------------
    // If the point is within the sphere radius
    T distance = GetRadius() - ptRadius;
    if ( distance >= 0 ) { 
        if ( pvDistance ) {
            (*pvDistance) = location.Normalized() * distance;
            //-------------------------
            // 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 sphere surface.
            (*pvDistance) = GetTransform().GetMatrixRotation() * (*pvDistance);
            //-------------------------
            isThePointInsideTheSphere = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the sphere radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheSphere;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingSphere<T>::TestPointLocation ( 
    Vector3<T> const & point,
    TransformationSupport<T> const * const pTransform, 
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheSphere = 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 sphere, 
    // the sphere's center is at the origin. 
    // The sphere has radius and center.
    //---------------------------------------------------------------
    // Transform point to the sphere BV local coordinate
    Vector3<T> location = point;
    location = (transform.GetMatrixTransform().GetInverse() * Vector4<T>(location)).GetVector3();
    // Shift the location of point by the sphere BV center
    // i.e. shift the sphere BV to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the sphere is centered at the origin.
    // And the input point has been transformed into the sphere coordinate.
    // The test can be performed below.
    T   ptRadius = location.Length();
    //===============================================================
    // If the point is INSIDE the sphere
    //---------------------------------------------------------------
    // If the point is within the sphere radius
    T distance = GetRadius() - ptRadius;
    if ( distance >= 0 ) { 
        if ( pvDistance ) {
            (*pvDistance) = location.Normalized() * distance;
            //-------------------------
            // 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 sphere surface.
            (*pvDistance) = transform.GetMatrixRotation() * (*pvDistance);
            //(*pvDistance) = pureRotation * (*pvDistance);
            //-------------------------
            isThePointInsideTheSphere = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the sphere radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheSphere;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingSphere<T>::TestSphereLocation ( 
    Vector3<T> const & sphereCenter,
    T   sphereRadius,
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheSphere = false;
    //---------------------------------------------------------------
    // In the local coordinate of the bounding sphere, 
    // the sphere's center is at the origin. 
    // The sphere has radius and center.
    //---------------------------------------------------------------
    // Transform the sphere center to the sphere BV local coordinate
    Vector3<T> location = sphereCenter;
    location = (GetTransform().GetMatrixTransform().GetInverse() * Vector4<T>(location)).GetVector3();
    // Shift the location of sphere center by the sphere BV center
    // i.e. shift the sphere BV to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the sphere BV is centered at the origin.
    // And the input point has been transformed into the sphere BV coordinate.
    // The test can be performed below.
    T   ptRadius = location.Length() - sphereRadius;
    //===============================================================
    // If the point is INSIDE the sphere
    //---------------------------------------------------------------
    // If the point is within the sphere radius
    T distance = GetRadius() - ptRadius;
    if ( distance >= 0 ) { 
        if ( pvDistance ) {
            (*pvDistance) = location.Normalized() * distance;
            //-------------------------
            // 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 sphere surface.
            (*pvDistance) = GetTransform().GetMatrixRotation() * (*pvDistance);
            //-------------------------
            isThePointInsideTheSphere = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the sphere radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheSphere;
}
//-----------------------------------------------------------------------------
template <typename T>
bool BoundingSphere<T>::TestSphereLocation ( 
    Vector3<T> const & sphereCenter,
    T   sphereRadius,
    TransformationSupport<T> const * const pTransform, 
    Vector3<T> * const pvDistance ) const
{
    bool isThePointInsideTheSphere = 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 sphere, 
    // the sphere's center is at the origin. 
    // The sphere has radius and center.
    //---------------------------------------------------------------
    // Transform the sphere center to the sphere BV local coordinate
    Vector3<T> location = sphereCenter;
    location = (transform.GetMatrixTransform().GetInverse() * Vector4<T>(location)).GetVector3();
    // Shift the location of point by the sphere BV center
    // i.e. shift the sphere BV to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the sphere is centered at the origin.
    // And the input point has been transformed into the sphere coordinate.
    // The test can be performed below.
    T   ptRadius = location.Length() - sphereRadius;
    //===============================================================
    // If the point is INSIDE the sphere
    //---------------------------------------------------------------
    // If the point is within the sphere radius
    T distance = GetRadius() - ptRadius;
    if ( distance >= 0 ) { 
        if ( pvDistance ) {
            (*pvDistance) = location.Normalized() * distance;
            //-------------------------
            // 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 sphere surface.
            (*pvDistance) = transform.GetMatrixRotation() * (*pvDistance);
            //(*pvDistance) = pureRotation * (*pvDistance);
            //-------------------------
            isThePointInsideTheSphere = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the sphere radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }
    //---------------------------------------------------------------
    return isThePointInsideTheSphere;
}
//-----------------------------------------------------------------------------
// TestOverlapWith
template <typename T>
T BoundingSphere<T>::TestOverlapWith ( BoundingVolume<T> const * const that ) const
{
    std::cout << "BoundingSphere<T>::TestOverlapWith( BoundingVolume<T> ) -- NOT IMPLEMENTED YET!!!\n";

    switch ( that->GetType() ) {
    case Enum::BOUNDING_SPHERE:
        break;
    case Enum::BOUNDING_BOX:
        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 BoundingSphere<T>::g_uiDisplayList = 0;
template <typename T> GLenum BoundingSphere<T>::g_eDrawStyle = GLU_LINE;
//-----------------------------------------------------------------------------
template <typename T>
void BoundingSphere<T>::Draw ( GLenum drawStyle, Vector4<T> color )
{
    //-----------------------------------------------------
    //std::cout << "Draw SPHERE 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
            //gluSphere( qObj, 1, 9, 9 );
            //gluSphere( qObj, 1, 12, 12 );
            gluSphere( qObj, 1, 20, 20 );
        glEndList();
        gluDeleteQuadric( qObj );
    }
    //-----------------------------------------------------
    glPushMatrix();

        /*
        // DEBUG
        //---------------------------------------
        glPushMatrix();
        GLfloat mat[16];

        glLoadIdentity();

        std::cout << "Center and Radius: " << GetCenter() << "; " << GetRadius() << "\n";

        glGetFloatv( GL_MODELVIEW_MATRIX, mat );
        Matrix4x4<GLfloat> MAT1( mat );
        std::cout << "MAT 1: " << MAT1.Transposed();

        GetTransform().TransformByOpenGLForDrawing();

        glGetFloatv( GL_MODELVIEW_MATRIX, mat );
        Matrix4x4<GLfloat> MAT2( mat );
        std::cout << "MAT 2: " << MAT2.Transposed();

        std::cout << "TTT: " << GetTransform();
        //---------------------------------------
        glTranslatef( GetCenter()[0], GetCenter()[1], GetCenter()[2] );

        glGetFloatv( GL_MODELVIEW_MATRIX, mat );
        Matrix4x4<GLfloat> MAT3( mat );
        std::cout << "MAT 3: " << MAT3.Transposed();

        glScalef( GetRadius(), GetRadius(), GetRadius() );

        glGetFloatv( GL_MODELVIEW_MATRIX, mat );
        Matrix4x4<GLfloat> MAT4( mat );
        std::cout << "MAT 4: " << MAT4.Transposed();
        glPopMatrix();
        //*/

        //---------------------------------------
        GetTransform().TransformByOpenGLForDrawing();
        //---------------------------------------
        glColor4fv( color.GetDataFloat() );
        glTranslatef( GetCenter()[0], GetCenter()[1], GetCenter()[2] );
        glScalef( GetRadius(), GetRadius(), GetRadius() );
        //---------------------------------------
        glCallList( g_uiDisplayList );

    glPopMatrix();
}
//-----------------------------------------------------------------------------
#endif
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----