TAPsBVHNodeLeafElasticRodNode.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsBVHNodeLeafElasticRodNode.cpp

BVHNodeLeafElasticRodNode class is for a Boundary Volume Hierarchy Leaf Node 
containing a link to an elastic rod node.

SUKITTI PUNAK   (08/21/2009)
******************************************************************************/
#include "TAPsBVHNodeLeafElasticRodNode.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>
BVHNodeLeafElasticRodNode<T>::BVHNodeLeafElasticRodNode (
    Enum::CD            type, 
    int                 id, 
    BVHNode<T> *        parent )
    : BVHNode<T>( id, type, parent ), 
      m_pERnode_1( NULL ), m_pERnode_2( NULL )
{
    //m_bIsLeaf = true;
    m_iN = 0;
}
//-----------------------------------------------------------------------------
template <typename T>
BVHNodeLeafElasticRodNode<T>::~BVHNodeLeafElasticRodNode ()
{}
//-----------------------------------------------------------------------------
// StrInfo
template <typename T>
std::string BVHNodeLeafElasticRodNode<T>::StrInfo () const
{
    std::stringstream output;
    output  <<  "TAPs::BVHNodeLeafElasticRodNode<"
            <<  typeid(T).name() << "> Class:";
    //-------------------------------------------------
    output  << "contain the link from elastic rod's node i to node j\n"
            << "Node i: " << GetPtrToPrimitive_1() << "\n"
            << "Node j: " << GetPtrToPrimitive_2() << "\n"
            << "\n";
    
    return output.str();
}
//-----------------------------------------------------------------------------
//=============================================================================
// Node Operations
//-----------------------------------------------------------------------------
// Update
// update only this node
/*
template <typename T>
void BVHNodeLeafElasticRodNode<T>::Update ()
{
    //---------------------------------------------------------------
    switch ( m_eType ) {
        case Enum::BVH_NODE_LEAF_SPHERE_TWO_ELASTIC_ROD_NODES:
            //UpdateSphere();
            break;
        case Enum::BVH_NODE_LEAF_AABB_TWO_ELASTIC_ROD_NODES:
            break;
        case Enum::BVH_NODE_LEAF_OBB_TWO_ELASTIC_ROD_NODES:
            break;
        default:
            assert( false );
            break;
    }
}
//*/
//-----------------------------------------------------------------------------
// UpdateSphere
//template <typename T>
//void BVHNodeLeafElasticRodNode<T>::UpdateSphere ()
//{
    //std::cout << "UpdateSphere Node: " << this << "\n";

    /*
    //---------------------------------------------------------------
    Vector3<T> AABB[2];
    //HEVertex<T> * vertex = m_listVertex->Head();
    HEHalfEdge<T> * firstHalfEdge = m_primHEFace->IncidentHalfEdge();
    HEHalfEdge<T> * halfEdge = firstHalfEdge->Next();
    Vector3<T> vertex = firstHalfEdge->Vertex()->GetPosition();
    AABB[0] = AABB[1] = vertex;
    //---------------------------------------------------------------
    // For Each Vertex
     while ( halfEdge != firstHalfEdge ) {
        vertex = halfEdge->Vertex()->GetPosition();
        // Find the lowest an the highest of x, y, and z
        // AABB[0] is min and AABB[1] is max
        if      ( AABB[0][0] > vertex[0] )  AABB[0][0] = vertex[0];
        else if ( AABB[1][0] < vertex[0] )  AABB[1][0] = vertex[0];
        if      ( AABB[0][1] > vertex[1] )  AABB[0][1] = vertex[1];
        else if ( AABB[1][1] < vertex[1] )  AABB[1][1] = vertex[1];
        if      ( AABB[0][2] > vertex[2] )  AABB[0][2] = vertex[2];
        else if ( AABB[1][2] < vertex[2] )  AABB[1][2] = vertex[2];
        // Next vertex
        halfEdge = halfEdge->Next();
    }
    //---------------------------------------------------------------
    // Find the bounding volume center from the AABB
    Vector3<T> vCenter( ( AABB[0][0] + AABB[1][0] ) / 2.0,
                        ( AABB[0][1] + AABB[1][1] ) / 2.0,
                        ( AABB[0][2] + AABB[1][2] ) / 2.0 );
    //---------------------------------------------------------------
    // Find the Sphere Bounding Volume
    T radius = 0, squaredLength;
    halfEdge = firstHalfEdge = m_primHEFace->IncidentHalfEdge();
    //-----------------------------------------------------
    do {
        vertex = halfEdge->Vertex()->GetPosition();
        //squaredLength = (vertex - vCenter).SquaredLength();
        squaredLength = (vertex - vCenter).Length();
        if ( squaredLength > radius )   radius = squaredLength;
        halfEdge = halfEdge->Next();
    } while ( halfEdge != firstHalfEdge );
    //radius = sqrt( radius );
    //---------------------------------------------------------------
    SetCenter( vCenter );
    SetRadius( radius );
    //*/
//}
//-----------------------------------------------------------------------------
// TestOverlapWith
/*
template <typename T>
T BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<T>::TestOverlapSphereWithSphere ( 
            BVHNode<T> const * const that ) const
{
    std::cout << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<T>::TestOverlapSphereWithSphere ( 
            BVHNode<T> const * const that, 
            Matrix4x4<T> const & thatTransform ) const
{
    std::cout << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<T>::TestOverlapSphereWithSphere ( 
            Matrix4x4<T> const & thisTransform, 
            BVHNode<T> const * const that ) const
{
    std::cout << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<T>::TestOverlapSphereWithSphere ( 
            Matrix4x4<T> const & thisTransform, 
            BVHNode<T> const * const that, 
            Matrix4x4<T> const & thatTransform ) const
{
    std::cout << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<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 << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<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 << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<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 << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<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 << "BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<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 BVHNodeLeafElasticRodNode<T>::DrawBV ( GLenum drawStyle ) const
{
    switch ( m_eType ) {
        //-----------------------------------------------------------
        // DRAW SPHERE BVH
        case Enum::BVH_NODE_LEAF_SPHERE_TWO_ELASTIC_ROD_NODES:
        case Enum::BVH_NODE_LEAF_SPHERE_UNSPECIFIED_PRIMS:
            DrawSphereBV( drawStyle );
            break;
        //-----------------------------------------------------------
        // DRAW AABB BVH
        case Enum::BVH_NODE_LEAF_AABB_TWO_ELASTIC_ROD_NODES:
        case Enum::BVH_NODE_LEAF_AABB_UNSPECIFIED_PRIMS:
            DrawAABBBV( drawStyle );
            break;
        //-----------------------------------------------------------
        // DRAW OBB BVH
        case Enum::BVH_NODE_LEAF_OBB_TWO_ELASTIC_ROD_NODES:
        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 BVHNodeLeafElasticRodNode<T>::DrawPrim ( GLenum drawStyle ) const
{
    if ( m_pERnode_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----+----