TAPsBVHNodeLeafALinkFormedByTwoPointMasses.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsBVHNodeLeafALinkFormedByTwoPointMasses.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (08/16/2010)
UPDATE          (08/20/2010)
******************************************************************************/
#include "TAPsBVHNodeLeafALinkFormedByTwoPointMasses.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>
BVHNodeLeafALinkFormedByTwoPointMasses<T>::BVHNodeLeafALinkFormedByTwoPointMasses (
    Enum::CD            type, 
    int                 id, 
    BVHNode<T> *        parent )
    : BVHNode<T>( id, type, parent ), 
      m_pPointMass_1( NULL ), m_pPointMass_2( NULL )
{
    //m_bIsLeaf = true;
    m_iN = 0;
}
//-----------------------------------------------------------------------------
template <typename T>
BVHNodeLeafALinkFormedByTwoPointMasses<T>::~BVHNodeLeafALinkFormedByTwoPointMasses ()
{}
//-----------------------------------------------------------------------------
// StrInfo
template <typename T>
std::string BVHNodeLeafALinkFormedByTwoPointMasses<T>::StrInfo () const
{
    std::stringstream output;
    output  <<  "TAPs::BVHNodeLeafALinkFormedByTwoPointMasses<"
            <<  typeid(T).name() << "> Class:";
    //-------------------------------------------------
    output  << "contain the link formed by two point masses\n"
            << "PointMass 1: " << GetPtrToPrimitive_1() << "\n"
            << "PointMass 2: " << GetPtrToPrimitive_2() << "\n"
            << "\n";
    return output.str();
}
//-----------------------------------------------------------------------------
//=============================================================================
// Node Operations
//-----------------------------------------------------------------------------
// Update
// update only this node
template <typename T>
void BVHNodeLeafALinkFormedByTwoPointMasses<T>::Update ()
{
    //---------------------------------------------------------------
    switch ( m_eType ) {
        case Enum::BVH_NODE_LEAF_SPHERE_TWO_POINT_MASSES:
            UpdateSphere();
            break;
        case Enum::BVH_NODE_LEAF_AABB_TWO_POINT_MASSES:
            break;
        case Enum::BVH_NODE_LEAF_OBB_TWO_POINT_MASSES:
            break;
        default:
            assert( false );
            break;
    }
}
//-----------------------------------------------------------------------------
// UpdateSphere
template <typename T>
void BVHNodeLeafALinkFormedByTwoPointMasses<T>::UpdateSphere ()
{
    SetRadius( ( GetPtrToPrimitive_1()->GetPosition() - GetPtrToPrimitive_2()->GetPosition() ).Length() * T(0.5) );
    SetCenter( ( GetPtrToPrimitive_1()->GetPosition() + GetPtrToPrimitive_2()->GetPosition() ) * T(0.5) );
}

/*
//-----------------------------------------------------------------------------
// TestOverlapWith
template <typename T>
T BVHNodeLeafALinkFormedByTwoPointMasses<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->GetType() ) {
                case Enum::BVH_NODE_BINARY_SPHERE:
                case Enum::BVH_NODE_QUAD_SPHERE:
                case Enum::BVH_NODE_OCTANT_SPHERE:
                case Enum::BVH_NODE_GENERIC_SPHERE:
                case Enum::BVH_NODE_LEAF_SPHERE_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 BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere ( 
            BVHNode<T> const * const that ) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere( #1 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( that );
        if ( distance > Math<T>::ZERO ) return distance;
        else {
            //-----------------------------------
            // Triangle Case
            HEFace<T> * face1 = this->GetAPrimitiveHalfEdgeFace();
            HEFace<T> * face2 = that->GetAPrimitiveHalfEdgeFace();
            if ( face1 && face2 ) {
                // Assume Triangles
                std::vector< Vector3<T> > tri1, tri2;
                tri1 = face1->GetCopyOfVertexPositions( 3 );
                tri2 = face2->GetCopyOfVertexPositions( 3 );
                bool isIntersect = CGMath<T>::FindIntersectionTriangleTriangle( 
                        tri1[0], tri1[1], tri1[2], tri2[0], tri2[1], tri2[2] );
                if ( isIntersect )  return -1;
                else                return  1;
            }
            //-----------------------------------
            return distance;
        }
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( that );
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #2
template <typename T>
T BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere ( 
            BVHNode<T> const * const that, 
            Matrix4x4<T> const & thatTransform ) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere( #2 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( that, thatTransform );
        if ( distance > Math<T>::ZERO ) return distance;
        else {
            //-----------------------------------
            // Triangle Case
            HEFace<T> * face1 = this->GetAPrimitiveHalfEdgeFace();
            HEFace<T> * face2 = that->GetAPrimitiveHalfEdgeFace();
            if ( face1 && face2 ) {
                // Assume Triangles
                std::vector< Vector3<T> > tri1, tri2;
                tri1 = face1->GetCopyOfVertexPositions( 3 );
                tri2 = face2->GetCopyOfVertexPositions( 3 );
                //---------------------
                // Transforms
                tri2[0] = (thatTransform * Vector4<T>(tri2[0])).GetVector3();
                tri2[1] = (thatTransform * Vector4<T>(tri2[1])).GetVector3();
                tri2[2] = (thatTransform * Vector4<T>(tri2[2])).GetVector3();
                //--------------------------
                bool isIntersect = CGMath<T>::FindIntersectionTriangleTriangle( 
                        tri1[0], tri1[1], tri1[2], tri2[0], tri2[1], tri2[2] );
                if ( isIntersect )  return -1;
                else                return  1;
            }
            //-----------------------------------
            return distance;
        }
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( that, thatTransform );
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #3
template <typename T>
T BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere ( 
            Matrix4x4<T> const & thisTransform, 
            BVHNode<T> const * const that ) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere( #3 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that );
        if ( distance > Math<T>::ZERO ) return distance;
        else {
            //-----------------------------------
            // Triangle Case
            HEFace<T> * face1 = this->GetAPrimitiveHalfEdgeFace();
            HEFace<T> * face2 = that->GetAPrimitiveHalfEdgeFace();
            if ( face1 && face2 ) {
                // Assume Triangles
                std::vector< Vector3<T> > tri1, tri2;
                tri1 = face1->GetCopyOfVertexPositions( 3 );
                tri2 = face2->GetCopyOfVertexPositions( 3 );
                //---------------------
                // Transforms
                tri1[0] = (thisTransform * Vector4<T>(tri1[0])).GetVector3();
                tri1[1] = (thisTransform * Vector4<T>(tri1[1])).GetVector3();
                tri1[2] = (thisTransform * Vector4<T>(tri1[2])).GetVector3();
                //---------------------
                bool isIntersect = CGMath<T>::FindIntersectionTriangleTriangle( 
                        tri1[0], tri1[1], tri1[2], tri2[0], tri2[1], tri2[2] );
                if ( isIntersect )  return -1;
                else                return  1;
            }
            //-----------------------------------
            return distance;
        }
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that );
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithSphere #4
template <typename T>
T BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere ( 
            Matrix4x4<T> const & thisTransform, 
            BVHNode<T> const * const that, 
            Matrix4x4<T> const & thatTransform ) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithSphere( #4 )\n";

    if ( that->IsLeaf() ) {
        T distance = BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that, thatTransform );
        if ( distance > Math<T>::ZERO ) return distance;
        else {
            //-----------------------------------
            // Triangle Case
            HEFace<T> * face1 = this->GetAPrimitiveHalfEdgeFace();
            HEFace<T> * face2 = that->GetAPrimitiveHalfEdgeFace();
            if ( face1 && face2 ) {
                // Assume Triangles
                std::vector< Vector3<T> > tri1, tri2;
                tri1 = face1->GetCopyOfVertexPositions( 3 );
                tri2 = face2->GetCopyOfVertexPositions( 3 );
                //---------------------
                // Transforms
                tri1[0] = (thisTransform * Vector4<T>(tri1[0])).GetVector3();
                tri1[1] = (thisTransform * Vector4<T>(tri1[1])).GetVector3();
                tri1[2] = (thisTransform * Vector4<T>(tri1[2])).GetVector3();
                tri2[0] = (thatTransform * Vector4<T>(tri2[0])).GetVector3();
                tri2[1] = (thatTransform * Vector4<T>(tri2[1])).GetVector3();
                tri2[2] = (thatTransform * Vector4<T>(tri2[2])).GetVector3();
                //---------------------
                bool isIntersect = CGMath<T>::FindIntersectionTriangleTriangle( 
                        tri1[0], tri1[1], tri1[2], tri2[0], tri2[1], tri2[2] );
                if ( isIntersect )  return -1;
                else                return  1;
            }
            //-----------------------------------
            return distance;
        }
    }
    else {
        return BVHNode<T>::TestOverlapSphereWithSphere( thisTransform, that, thatTransform );
    }
}
//-----------------------------------------------------------------------------
//*/

/*
//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVSphere #1
template <typename T>
T BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVSphere ( 
    Vector3<T> const & centerOfBVSphere,    //!< I/P: the center of the 2nd sphere
    T radiusOfBVSphere                      //!< I/P: the radius of the 2nd sphere
) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVSphere( #1 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVSphere( centerOfBVSphere, radiusOfBVSphere );
    if ( distance > Math<T>::ZERO ) return distance;
    else {
        //---------------------------------------
        // Triangle Case
        HEFace<T> * face = this->GetAPrimitiveHalfEdgeFace();
        if ( face ) {
            // Assume Triangles
            std::vector< Vector3<T> > tri;
            tri = face->GetCopyOfVertexPositions( 3 );
            //-------------------------
            bool isIntersect = CGMath<T>::FindIntersectionSphereTriangle( 
                    centerOfBVSphere, radiusOfBVSphere, tri[0], tri[1], tri[2] );
            if ( isIntersect )  return -1;
            else                return  1;
        }
        //---------------------------------------
        return distance;
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVSphere #2
template <typename T>
T BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVSphere ( 
    Matrix4x4<T> const & transformA,        //!< I/P: the transformation for the 1st sphere
    Vector3<T> const & centerOfBVSphere,    //!< I/P: the center of the 2nd sphere
    T radiusOfBVSphere                      //!< I/P: the radius of the 2nd sphere
) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVSphere( #2 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVSphere( transformA, centerOfBVSphere, radiusOfBVSphere );
    if ( distance > Math<T>::ZERO ) return distance;
    else {
        //---------------------------------------
        // Triangle Case
        HEFace<T> * face = this->GetAPrimitiveHalfEdgeFace();
        if ( face ) {
            // Assume Triangles
            std::vector< Vector3<T> > tri;
            tri = face->GetCopyOfVertexPositions( 3 );
            //-------------------------
            // Transforms
            tri[0] = (transformA * Vector4<T>(tri[0])).GetVector3();
            tri[1] = (transformA * Vector4<T>(tri[1])).GetVector3();
            tri[2] = (transformA * Vector4<T>(tri[2])).GetVector3();
            //-------------------------
            bool isIntersect = CGMath<T>::FindIntersectionSphereTriangle( 
                    centerOfBVSphere, radiusOfBVSphere, tri[0], tri[1], tri[2] );
            if ( isIntersect )  return -1;
            else                return  1;
        }
        //---------------------------------------
        return distance;
    }
}
//-----------------------------------------------------------------------------
//*/


/*
//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVCylinder #1
template <typename T>
bool BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVCylinder_AtOrigin ( 
    Vector3<T> const & centerOfBVCylinder,  //!< I/P: the center of the cylinder bounding volume
    T radiusOfBVCylinder,                   //!< I/P: the radius of the cylinder bounding volume
    T heightOfBVCylinder                    //!< I/P: the height of the cylinder bounding volume
) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVCylinder( #1 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVCylinder_AtOrigin( radiusOfBVCylinder, heightOfBVCylinder );
    if ( distance > Math<T>::ZERO ) return false;
    else {
        //---------------------------------------
        // Triangle Case
        HEFace<T> * face = this->GetAPrimitiveHalfEdgeFace();
        if ( face ) {
            // Assume Triangles
            std::vector< Vector3<T> > tri;
            tri = face->GetCopyOfVertexPositions( 3 );
            //-------------------------
            T halfHeight = heightOfBVCylinder / 2;
            bool isIntersect = CGMath<T>::FindIntersectionCylinderTriangle( 
                    Vector3<T>(0,0,halfHeight), Vector3<T>(0,0,-halfHeight), radiusOfBVCylinder, tri[0], tri[1], tri[2] );
            if ( isIntersect )  return true;
            else                return false;
        }
        //---------------------------------------
        return true;
    }
}
//-----------------------------------------------------------------------------
// TestOverlapSphereWithBVCylinder #2
template <typename T>
bool BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVCylinder_AtOrigin ( 
    Matrix4x4<T> const & transformA,        //!< I/P: the transformation for the node's sphere
    Vector3<T> const & centerOfBVCylinder,  //!< I/P: the center of the cylinder bounding volume
    T radiusOfBVCylinder,                   //!< I/P: the radius of the cylinder bounding volume
    T heightOfBVCylinder                    //!< I/P: the height of the cylinder bounding volume
) const
{
    std::cout << "BVHNodeLeafALinkFormedByTwoPointMasses<T>::TestOverlapSphereWithBVCylinder( #2 )\n";

    T distance = BVHNode<T>::TestOverlapSphereWithBVCylinder_AtOrigin( transformA, radiusOfBVCylinder, heightOfBVCylinder );
    if ( distance > Math<T>::ZERO ) return false;
    else {
        //---------------------------------------
        // Triangle Case
        HEFace<T> * face = this->GetAPrimitiveHalfEdgeFace();
        if ( face ) {
            // Assume Triangles
            std::vector< Vector3<T> > tri;
            tri = face->GetCopyOfVertexPositions( 3 );
            //-------------------------
            // Transforms
            tri[0] = (transformA * Vector4<T>(tri[0])).GetVector3();
            tri[1] = (transformA * Vector4<T>(tri[1])).GetVector3();
            tri[2] = (transformA * Vector4<T>(tri[2])).GetVector3();
            //-------------------------
            T halfHeight = heightOfBVCylinder / 2;
            bool isIntersect = CGMath<T>::FindIntersectionCylinderTriangle( 
                    Vector3<T>(0,0,halfHeight), Vector3<T>(0,0,-halfHeight), radiusOfBVCylinder, tri[0], tri[1], tri[2] );
            if ( isIntersect )  return true;
            else                return false;
        }
        //---------------------------------------
        return true;
    }
}
//-----------------------------------------------------------------------------
//*/


#if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
// DrawByOpenGL
//-----------------------------------------------------------------------------
template <typename T>
void BVHNodeLeafALinkFormedByTwoPointMasses<T>::DrawByOpenGL () const
{
    //static OpenGL::Material mat;
    //mat.SetMaterial( OpenGL::Enum::METAL_BRONZE );
    //mat.ApplyMaterial( OpenGL::Enum::FRONT );

    //glDisable( GL_LIGHTING );
    //glColor3f( 0.3, 0.4, 0.5 );
    //---------------------------------------------------------------
    //if ( bDraw ) {    // DEBUG
    //  DrawBV();
    //  DrawPrim();         // DEBUG
    //  return;
    //}
    DrawBV();
    DrawPrim();         // DEBUG
    //---------------------------------------------------------------
    //glEnable( GL_LIGHTING );
}
//-----------------------------------------------------------------------------
template <typename T>
void BVHNodeLeafALinkFormedByTwoPointMasses<T>::DrawByOpenGL ( 
        int currentLevel, int startLevel, int endLevel ) const
{
    if ( startLevel <= currentLevel && currentLevel <= endLevel ) {
        //static OpenGL::Material mat;
        //mat.SetMaterial( OpenGL::Enum::METAL_BRONZE );
        //mat.ApplyMaterial( OpenGL::Enum::FRONT );

        //glDisable( GL_LIGHTING );
        //glColor3f( 0.3, 0.4, 0.5 );
        //-----------------------------------------------------------
        //if ( listHEFace.size() == 1 )
        DrawBV();
        DrawPrim();     // DEBUG
    }
    //---------------------------------------------------------------
    //glEnable( GL_LIGHTING );
}
//-----------------------------------------------------------------------------
template <typename T>
void BVHNodeLeafALinkFormedByTwoPointMasses<T>::DrawBV ( GLenum drawStyle ) const
{
    switch ( m_eType ) {
        //-----------------------------------------------------------
        // DRAW SPHERE BVH
        case Enum::BVH_NODE_LEAF_SPHERE_TWO_POINT_MASSES:
        case Enum::BVH_NODE_LEAF_SPHERE_UNSPECIFIED_PRIMS:
            DrawSphereBV( drawStyle );
            break;
        //-----------------------------------------------------------
        // DRAW AABB BVH
        case Enum::BVH_NODE_LEAF_AABB_TWO_POINT_MASSES:
        case Enum::BVH_NODE_LEAF_AABB_UNSPECIFIED_PRIMS:
            DrawAABBBV( drawStyle );
            break;
        //-----------------------------------------------------------
        // DRAW OBB BVH
        case Enum::BVH_NODE_LEAF_OBB_TWO_POINT_MASSES:
        case Enum::BVH_NODE_LEAF_OBB_UNSPECIFIED_PRIMS:
            DrawOBBBV( drawStyle );
            break;
    }
}
//-----------------------------------------------------------------------------
//DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG
template <typename T>
void BVHNodeLeafALinkFormedByTwoPointMasses<T>::DrawPrim ( GLenum drawStyle ) const
{
    if ( GetPtrToPrimitive_1() == NULL ) return;

    /*
    glDisable( GL_LIGHTING );
    //float div = RAND_MAX;
    //glColor3f( rand()/div, rand()/div, rand()/div );
    //glColor3f( 0.8, 0.8, 0.8 );
    glPushMatrix();
        HEHalfEdge<T> * firstHalfEdge, * halfEdge;
        Vector3<T> vertex;
        //-------------------------------------------
        // Draw The Half-Edge Face
        glBegin( GL_POLYGON );
        //glBegin( GL_LINE_LOOP );
            halfEdge = firstHalfEdge = m_primHEFace->IncidentHalfEdge();
            do {
                vertex = halfEdge->Vertex()->GetPosition();
                glVertex3f( vertex[0], vertex[1], vertex[2] );
                halfEdge = halfEdge->Next();
            } while ( halfEdge != firstHalfEdge );
        glEnd();
        //-------------------------------------------
    glPopMatrix();
    glEnable( GL_LIGHTING );
    //*/
}
//DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG-DEBUG
//-----------------------------------------------------------------------------
#endif // #if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----