TAPsHETriMeshOneModelMultiParts.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsHETriMeshOneModelMultiParts.cpp

SUKITTI PUNAK   (10/02/2009)
UPDATE          (10/02/2009)
******************************************************************************/

#include "TAPsHETriMeshOneModelMultiParts.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__OpenGL
//=============================================================================
#ifdef  TAPs_ADVANCED_SIMULATION
template <typename T> unsigned int HETriMeshOneModelMultiParts<T>::TotalModels = 0;
#endif//TAPs_ADVANCED_SIMULATION
//-----------------------------------------------------------------------------
// default constructor
template <typename T>
HETriMeshOneModelMultiParts<T>::HETriMeshOneModelMultiParts ()
    : HalfEdgeModel<T>(), 
      m_iRigidity( 1 ), 
      m_tPtMass( 1 ), 
      m_tKStiffness( 1 ), 
      m_tKDamper( 0.5 ), 
      m_tHomeKStiffness( 1 ), 
      m_tHomeKDamper( 0.5 ) 

#ifdef  TAPs_ADVANCED_SIMULATION
      //, AdvSimID( TotalModels++ )
#endif//TAPs_ADVANCED_SIMULATION

#ifdef  TAPs_USE_WXWIDGETS
      , pDialogs( NULL )
#endif//TAPs_USE_WXWIDGETS

{
    //---------------------------------------------------------------
    //std::cout << "Number of Vertex: " << GetNoVertices();
    //std::cout << "Number of Vertex: " << GetNoVertices();
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "HETriMeshOneModelMultiParts<" << typeid(T).name() << "> Constructor\n";
    #endif//TAPs_ENABLE_DEBUG

#ifdef  TAPs_USE_CUDA
    // Data Members for CUDA
    m_cudaVertexList            = NULL;
    m_cudaPrevVertexList        = NULL;
    m_cudaHomeVertexList        = NULL;
    m_cudaVertexConnectionList  = NULL;
    m_cudaMaxConnectionSize     = 0;
    m_cudaID                    = 0;
#endif//TAPs_USE_CUDA

}
//-----------------------------------------------------------------------------
// destructor
template <typename T>
HETriMeshOneModelMultiParts<T>::~HETriMeshOneModelMultiParts ()
{
    DeleteAllData();
    //---------------------------------------------------------------
    // For simulation
    delete m_prODESolver;
    //---------------------------------------------------------------
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "HETriMeshOneModelMultiParts<" << typeid(T).name() << "> Destructor\n";
    #endif//TAPs_ENABLE_DEBUG
}
//-----------------------------------------------------------------------------
// Initialize
// a virtual fn from Model class
template <typename T>
void HETriMeshOneModelMultiParts<T>::Initialize ()
{
    HalfEdgeModel<T>::Initialize();
    //---------------------------------------------------------------
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "++++++++++++++Initialize HALF-EDGE SPRING MODEL++++++++++++++\n";
    #endif//TAPs_ENABLE_DEBUG
}
//-----------------------------------------------------------------------------
// Create Mesh Springs
template <typename T>
void HETriMeshOneModelMultiParts<T>::CreateMeshSprings ( 
        T mass,         
        T Ks,           
        T Kd,           
        T HKs,          
        T HKd,          
        int rigidity,   
        T predefinedTimeStep,       
        int numSimSubSteps,         
        bool enableColDet,          
        bool enableSimulation       
)
{
    PrepareData();

    //---------------------------------------------------------------
    // For Simulation
    if ( ( m_prODESolver = new Simulation::ODESolverEuler<T>() ) == NULL ) {
    //if ( ( m_prODESolver = new Simulation::ODESolverMidpoint<T>() ) == NULL ) {
    //if ( ( m_prODESolver = new Simulation::ODESolverRungeKutta4<T>() ) == NULL ) {
        #ifdef TAPs_ENABLE_DEBUG
        std::cerr   << "ERROR => HETriMeshOneModelMultiParts Constructor:" 
                    << " Cannot allocate memory for an ODE solver!" 
                    << std::endl;
        #endif
        delete this;
        return;
    }
    //---------------------------------------------------------------
    // Create ODE Solver
    m_iStateSize = static_cast<int>( m_pHEVertexList->size() );
    m_prODESolver->SetSize( m_iStateSize * 6 );
    x0   = &xData_1;
    xEnd = &xData_2;
    x0->resize(   m_iStateSize * 6 );
    xEnd->resize( m_iStateSize * 6 );
    StateToArray( &(*xEnd)[0] );
    //---------------------------------------------------------------
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "++++++++++++++HALF-EDGE SPRING MODEL++++++++++++++\n";
    std::cout << "++++++++++++++ --> m_iStateSize = " << m_iStateSize << "\n";
    std::cout << "++++++++++++++HALF-EDGE SPRING MODEL++++++++++++++\n";
    #endif//TAPs_ENABLE_DEBUG
    //---------------------------------------------------------------
    SetListOf1RingVertices();
    SetMassOfParticles( mass );
    //---------------------------------------------------------------
    // Create Multiparts

    // Have to come after SetListOf1RingVertices()
    SeparateIntoParts(
        mass,       
        Ks,         
        Kd,         
        HKs,        
        HKd,        
        rigidity,   
        predefinedTimeStep,     
        numSimSubSteps,         
        enableColDet,           
        enableSimulation        
    );
    //---------------------------------------------------------------
    // Create home spring of each HEVertexPtrWithExtraInfo in m_pHEVertexList
    for ( int p = 0; p < static_cast<int>( m_Parts.size() ); ++p ) {
        for ( int i = 0; i < static_cast<int>( m_Parts[p].GetVertexList().size() ); ++i ) {
            // Create home spring from a particle
            //*
            SpringRef<T> * newSpring = new SpringRef<T>( 
                                            (m_Parts[ p ].GetVertexList()[i]->GetHomeParticle()), 
                                            *(m_Parts[ p ].GetVertexList()[i]->GetParticleRef()), 
                                            HKs, HKd, 
                                            //0, 0,
                                            0           // # of hops (0 means home spring)
            );
            m_vpSpringRef.push_back( newSpring );
            m_Parts[ p ].GetSpringList().push_back( newSpring );
            //*/
        }
    }

    //---------------------------------------------------------------
    CreateSprings( Ks, Kd, rigidity );  // A recursive method for creating springs on mesh
    //CreateSprings( 0, 0, rigidity );  // A recursive method for creating springs on mesh

    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "Spring Mesh Rigidity: " << m_iRigidity << "\n";
    std::cout << "The Total Number of Springs is " << static_cast<int>(m_vpSpringRef.size()) << "\n";
    #endif//TAPs_ENABLE_DEBUG

    /*
    // DEBUG
    for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
        std::cout << "Part# " << i << "contains " << m_Parts[i].GetVertexList().size() << " vertices\n";
        for ( int j = 0; j < static_cast<int>( m_Parts[i].GetVertexList().size() ); ++j ) {
            std::cout << *(m_Parts[i].GetVertexList()[j]);
        }
        std::cout << "\n";
    }
    //*/

    #ifdef  TAPs_USE_CUDA
    for ( int p = 0; p < static_cast<int>( m_Parts.size() ); ++p ) {
        m_Parts[p].CUDA_Initialize();
    }
    CUDA_Initialize_All();
    #endif//TAPs_USE_CUDA

    #ifdef  TAPs_USE_WXWIDGETS
    pDialogs = new WX::WXHETriMeshOneModelMultiPartsParameters( & m_Parts );
    #endif//TAPs_USE_WXWIDGETS

}
//-----------------------------------------------------------------------------
//*****************************************************************************

//*****************************************************************************
// Helper Fn(s)
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::ChangeConstantStiffnessOfAllSprings ( T val )
{
    std::vector< SpringRef<T> * >::iterator pos;
    for ( pos = m_vpSpringRef.begin(); pos < m_vpSpringRef.end(); ++pos ) {
        (*pos)->SetConstantK( val );
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::ChangeConstantDampingOfAllSprings ( T val )
{
    std::vector< SpringRef<T> * >::iterator pos;
    for ( pos = m_vpSpringRef.begin(); pos < m_vpSpringRef.end(); ++pos ) {
        (*pos)->SetDampingD( val );
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::ChangeMassOfAllPoints ( T val )
{
    std::vector< HEvertexPtrWithExtraInfo<T> >::iterator pos;
    for ( pos = m_pHEVertexList->begin(); pos < m_pHEVertexList->end(); ++pos ) {
        (*pos).GetListParticleRef()->SetMass( val );
    }
}
//-----------------------------------------------------------------------------
//*****************************************************************************

//*****************************************************************************
// Helper Fn(s)
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::DeleteAllData ()
{
    // Clear spring references
    for ( int i = 0; i < static_cast<int>( m_vpSpringRef.size() ); ++i ) {
        delete m_vpSpringRef[i];
    }
    m_vpSpringRef.clear();

    // Clear vertex list
    for ( int i = 0; i < static_cast<int>( m_HEVertexList_1.size() ); ++i ) {
        delete m_HEVertexList_1[i];
    }
    m_HEVertexList_1.clear();

    // Clear particle references
    for ( int i = 0; i < static_cast<int>( m_svpParticleRef.size() ); ++i ) {
        delete m_svpParticleRef[i];
    }
    m_svpParticleRef.clear();

    // Clear multi-parts
    m_Parts.clear();

    #ifdef  TAPs_USE_CUDA
    CUDA_Cleanup_All();
    #endif//TAPs_USE_CUDA
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::SetListOf1RingVertices ()
{
    HEHalfEdge<T> * firstHalfEdge, * currentHalfEdge;
    HEVertex<T> *   heVertex = GetVertexList()->Head();
    HEVertex<T> *   currentVertex;

    /* Doesn't Work???
    for ( int v = 0; v < static_cast<int>( GetVertexList()->Size() ); ++v ) {
        m_HEVertexList[v].CreateListVertexFirstRing( GetVertexList() );

        for ( int i = 0; i < static_cast<int>( m_HEVertexList[v].GetListVertexFirstRing().size() ); ++i ) {
            m_pviListVertexRing1[v].push_back( i );
        }
    }
    //*/

    int size = static_cast<int>( m_pHEVertexList->size() );
    for ( int v = 0; v < size; ++v ) {
        currentHalfEdge = firstHalfEdge = heVertex->IncidentHalfEdge();
        do {
            currentVertex = currentHalfEdge->Pair()->Vertex();
            for ( int i = 0; i < size; ++i ) {
                if ( currentVertex == (*m_pHEVertexList)[i]->GetHEVertexPtr() ) {
                    (*m_pHEVertexList)[v]->GetListVertexFirstRing().push_back( i );
                    break;
                }
            }
            currentHalfEdge = currentHalfEdge->Pair()->Next();
        } while ( firstHalfEdge != currentHalfEdge );
        heVertex = heVertex->Next();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::PrepareData ()
{
    m_pHEVertexList     = &m_HEVertexList_1;

    // Setup pointers to HEVertex
    HEVertex<T> * heVertex = GetVertexList()->Head();

    int i = 0;
    while ( heVertex ) {
        m_svpParticleRef.push_back( new ParticleRef<T>( heVertex->GetProtectedPosition() ) );

        // The position in the particle reference will be set as a home position 
        // when HEVertexPtrWithExtraInfo constructor below is called.
        m_pHEVertexList->push_back( new HEVertexPtrWithExtraInfo<T>( heVertex, m_svpParticleRef[i] ) );

        ++i;
        heVertex = heVertex->Next();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::SeparateIntoParts ( 
        T mass,         
        T Ks,           
        T Kd,           
        T HKs,          
        T HKd,          
        int rigidity,   
        T predefinedTimeStep,       
        int numSimSubSteps,         
        bool enableColDet,          
        bool enableSimulation       
)
{
    // Set Data Members of this object
    m_tPtMass       = mass;
    m_tKStiffness   = Ks;
    m_tKDamper      = Kd;
    m_tHomeKStiffness   = HKs;
    m_tHomeKDamper      = HKd;
    m_tPredefinedTimeStep = predefinedTimeStep;
    m_iNumSimSubSteps = numSimSubSteps;

    m_Parts.push_back( SimPropForMultiPartMeshModel_HalfEdge<T>( mass, Ks, Kd, TAPs::Enum::MODEL_DEFORM, predefinedTimeStep, numSimSubSteps, enableColDet, enableSimulation ) );
    m_Parts.push_back( SimPropForMultiPartMeshModel_HalfEdge<T>( mass, Ks, Kd, TAPs::Enum::MODEL_DEFORM, predefinedTimeStep, numSimSubSteps, enableColDet, enableSimulation ) );

    int size = static_cast<int>( m_pHEVertexList->size() );

    m_tmpForPuttingSpringRefIntoParts.clear();

    for ( int i = 0; i < size; ++i ) {
        if ( (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[1] > 0 ) {
            m_Parts[0].GetVertexList().push_back( (*m_pHEVertexList)[i] );
            m_tmpForPuttingSpringRefIntoParts.push_back( 0 );
        }
        else {
            m_Parts[1].GetVertexList().push_back( (*m_pHEVertexList)[i] );
            m_tmpForPuttingSpringRefIntoParts.push_back( 1 );
        }
    }

    for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
        m_Parts[i].SetODESolver( TAPs::Enum::EULER );
        //m_Parts[i].SetODESolver( TAPs::Enum::MIDPOINT );
        //m_Parts[i].SetODESolver( TAPs::Enum::RUNGE_KUTTA_4 );
        
        if ( i % 2 == 0 ) {
            m_Parts[i].SetModelType( TAPs::Enum::MODEL_DEFORM );
        }
        else {
            m_Parts[i].SetModelType( TAPs::Enum::MODEL_DEFORM_ELASTIC );
        }

        std::cout << "m_Parts[" << i << "] size: " << m_Parts[i].Size() << "\n";
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::SetMassOfParticles ( T mass )
{
    for ( int i = 0; i < static_cast<int>( m_pHEVertexList->size() ); ++i ) {
        (*m_pHEVertexList)[i]->GetParticleRef()->SetMass( mass );
    }
}
//-----------------------------------------------------------------------------
template <typename T>
bool HETriMeshOneModelMultiParts<T>::CheckASpringExistance ( int p1, int p2 )
{
    int size = static_cast<int>( (*m_pHEVertexList)[p1]->GetListConnectedVertices().size() );
    for ( int i = 0; i < size; ++i ) {
        if ( (*m_pHEVertexList)[p1]->GetListConnectedVertices()[i] == p2 )  return true;
    }
    return false;
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::CreateASpring ( 
                T Ks, T Kd, int p1, int p2, int hops )
{
    SpringRef<T> * newSpring = new SpringRef<T>( 
                                    *((*m_pHEVertexList)[p1]->GetParticleRef()), 
                                    *((*m_pHEVertexList)[p2]->GetParticleRef()), 
                                    Ks, Kd, 
                                    hops );
    m_vpSpringRef.push_back( newSpring );
    (*m_pHEVertexList)[p1]->GetListConnectedVertices().push_back( p2 );
    (*m_pHEVertexList)[p2]->GetListConnectedVertices().push_back( p1 );
    //std::cout << "# of Hops: " << hops << "\n";
    //std::cout << "Create Spring with " << hops << " hop(s)\n";

    m_Parts[ m_tmpForPuttingSpringRefIntoParts[p1] ].GetSpringList().push_back( newSpring );
    m_Parts[ m_tmpForPuttingSpringRefIntoParts[p2] ].GetSpringList().push_back( newSpring );
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::CreateSprings ( T Ks, T Kd, int rigidity )
{
    m_iRigidity = rigidity;
    int size = static_cast<int>( m_pHEVertexList->size() );
    bool * isMark = new bool[size];
    //---------------------------------------------------------------
    for ( int i = 0; i < size; ++i ) {
        isMark[i] = false;      // prepare for spring creation
    }
    // Create springs on the object's surface
    for ( int i = 0; i < size; ++i ) {
        std::vector<int> particleSet;       // start as empty set
        BFSCreateSprings(   Ks, Kd, 0, 
                            i, i,           // particle#1, particle#2
                            particleSet, 
                            isMark );
        for ( int j = 0; j < static_cast<int>( particleSet.size() ); ++j ) {
            isMark[ particleSet[j] ] = false;
        }
    }

    /*
    //---------------------------------------------------------------
    for ( int i = 0; i < size; ++i ) {
        isMark[i] = false;      // prepare for spring creation
    }
    // Create opposite springs inside the object
    for ( int i = 0; i < size; ++i ) {
        std::cout << "isMark["<<i<<"]" << isMark[i] << "\n";
        if ( isMark[i] ) continue;
        T maxDist = 0;
        int idx1 = -1;
        int idx2 = -1;
        int idx3 = -1;
        int idx4 = -1;
        for ( int j = 0; j < size; ++j ) {
            T dist = ((*m_pHEVertexList)[i]->GetParticleRef()->GetPosition() - (*m_pHEVertexList)[j]->GetParticleRef()->GetPosition()).Length();
            if ( dist > maxDist ) {
                maxDist = dist;
                idx4 = idx3;
                idx3 = idx2;
                idx2 = idx1;
                idx1 = j;

                std::cout << i << "\t\tindices: " << idx1 << ", " << idx2 << ", " << idx3 << ", " << idx4 << "\n";
            }
        }
        bool bCreated = false;
        T Ks_opp = Ks / 10;
        if ( !bCreated && idx1 > -1 && !isMark[idx1] ) {
            if ( !CheckASpringExistance( i, idx1 ) ) 
            {
                isMark[idx1] = true;
                CreateASpring( Ks_opp, Kd, i, idx1, 1 );
                bCreated = true;
                std::cout << "opposite: " << i << " and " << idx1 << "\n";
            }
        }
        if ( !bCreated && idx2 > -1 && !isMark[idx2] ) {
            if ( !CheckASpringExistance( i, idx2 ) )
            {
                isMark[idx2] = true;
                CreateASpring( Ks_opp, Kd, i, idx2, 1 );
                bCreated = true;
                std::cout << "opposite: " << i << " and " << idx2 << "\n";
            }
        }
        if ( !bCreated && idx3 > -1 && !isMark[idx3] ) {
            if ( !CheckASpringExistance( i, idx3 ) )
            {
                isMark[idx3] = true;
                CreateASpring( Ks_opp, Kd, i, idx3, 1 );
                bCreated = true;
                std::cout << "opposite: " << i << " and " << idx3 << "\n";
            }
        }
        if ( !bCreated && idx4 > -1 ) {
            if ( !CheckASpringExistance( i, idx4 ) )
            {
                isMark[idx4] = true;
                CreateASpring( Ks_opp, Kd, i, idx4, 1 );
                bCreated = true;
                std::cout << "opposite: " << i << " and " << idx4 << "\n";
            }
        }
    }
    //*/

    m_tmpForPuttingSpringRefIntoParts.clear();
}
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::BFSCreateSprings ( 
                T Ks, T Kd, int rigidity,       // Ks, Kd, & hop distance
                int p1, int p2,                 // particle#1 & #2
                std::vector<int> & particleSet, // set of connected particles
                bool * isMark )                 // marked particles in particleSet
{
    if ( rigidity >= m_iRigidity ) return;
    //---------------------------------------------------------------
    // Keep the particle reference in particleSet
    // And mark it as visited
    particleSet.push_back( p2 );
    isMark[ p2 ] = true;
    //---------------------------------------------------------------
    // Traverse each edge of p1
    ++rigidity;
    int p3;
    for ( int i = 0; i < static_cast<int>( (*m_pHEVertexList)[p2]->GetListVertexFirstRing().size() ); ++i ) {
        p3 = (*m_pHEVertexList)[p2]->GetListVertexFirstRing()[i];
        if ( !isMark[ p3 ] ) {
            if ( !CheckASpringExistance( p1, p3 ) ) {
                CreateASpring( Ks, Kd, p1, p3, rigidity );
            }
        }
    }
    // This makes it become Breadth First Search
    for ( int i = 0; i < static_cast<int>( (*m_pHEVertexList)[p2]->GetListVertexFirstRing().size() ); ++i ) {
        p3 = (*m_pHEVertexList)[p2]->GetListVertexFirstRing()[i];
        BFSCreateSprings( Ks, Kd, rigidity, p1, p3, particleSet, isMark );
    }
    //---------------------------------------------------------------
}
/*
//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::DFSCreateSprings ( 
                T Ks, T Kd, int rigidity,       // Ks, Kd, & hop distance
                int p1, int p2,                 // particle#1 & #2
                std::vector<int> & particleSet, // set of connected particles
                bool * isMark )                 // marked particles in particleSet
{
    if ( rigidity >= m_iRigidity ) return;
    //---------------------------------------------------------------
    // Keep the particle reference in particleSet
    // And mark it as visited
    particleSet.push_back( p2 );
    isMark[ p2 ] = true;
    //---------------------------------------------------------------
    // Traverse each edge of p1
    ++rigidity;
    int p3;
    for ( int i = 0; i < static_cast<int>( m_pviListVertexRing1[p2].size() ); ++i ) {
        p3 = m_pviListVertexRing1[p2][i];
        if ( !isMark[ p3 ] ) {
            if ( !CheckASpringExistance( p1, p3 ) ) {
                CreateASpring( Ks, Kd, p1, p3, rigidity );
            }
            DFSCreateSprings( Ks, Kd, rigidity, p1, p3, particleSet, isMark );
        }
    }
    //---------------------------------------------------------------
}
//*/
//-----------------------------------------------------------------------------
//*****************************************************************************


//-----------------------------------------------------------------------------
template <typename T>
void HETriMeshOneModelMultiParts<T>::ApplyAndResetTransform ()
{
    // Apply to each home position
    std::vector< HEVertexPtrWithExtraInfo<T> * >::iterator pos = m_pHEVertexList->begin();
    while ( pos != m_pHEVertexList->end() ) {
        (*pos)->SetHomePosition( 
            ( GetTransform().RefToMatrixTransform() * Vector4<T>( (*pos)->GetHomePosition() ) ).GetVector3()
        );
        ++pos;
    }

    // Apply to the whole mesh of HalfEdgeModel
    // After this statement the transformation matrix is reset to identity
    HalfEdgeModel<T>::ApplyAndResetTransform();

    // Have to come after HalfEdgeModel<T>::ApplyAndResetTransform();
    for ( int p = 0; p < static_cast<int>( m_Parts.size() ); ++p ) {
        m_Parts[p].UpdateStateToArray();
    }

    // Update Springs
    std::vector< SpringRef<T> * >::iterator sprPos = m_vpSpringRef.begin();
    while ( sprPos != m_vpSpringRef.end() ) {
        (*sprPos)->SetRestLengthL( (*sprPos)->GetCurrentLength() );
        ++sprPos;
    }
}
//-----------------------------------------------------------------------------


//=============================================================================
// For Simulation
//-----------------------------------------------------------------------------
// Advance Simulation
template <typename T>
void HETriMeshOneModelMultiParts<T>::AdvanceSimulation ( T tCurrent, T tNext )
{
    #ifdef  TAPs_USE_CUDA

    std::cout << __FILE__ << " " << __LINE__ << " -- ";
    std::cout << "HETriMeshOneModelMultiParts<T>::AdvanceSimulation ( T tCurrent, T tNext ) IS NOT IMPLEMENTED YET!\n";

        /*
        CUDA_CopyVertexToMem();
        Global__HETriMeshOneModelMultiParts_AdvSim( 
            m_pHEVertexList->size(),    //!< number of vertices
            64,                         //!< number of threads
            tCurrent, tNext, 
            m_cudaVertexList, 
            m_cudaPrevVertexList, 
            m_cudaHomeVertexList, 
            m_cudaVertexConnectionList, 
            m_cudaMaxConnectionSize 
        );
        CUDA_CopyMemToVertex();

        GetBVHTree()->Update(); // commented out to rely on CDR to update the collided BVNodes
        CalAndSetNormals();
        //*/

    #else //TAPs_USE_CUDA

        for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
            m_Parts[i].AdvSim( tCurrent, tNext );
        }
        GetBVHTree()->Update(); // commented out to rely on CDR to update the collided BVNodes
        CalAndSetNormals();

    #endif//TAPs_USE_CUDA
}
//-----------------------------------------------------------------------------
// Advance Simulation
template <typename T>
void HETriMeshOneModelMultiParts<T>::AdvanceSimulation ( T tCurrent )
{
    //GetTransform().SetMatrixTransform( GetTransform().GetMatrixTransform() * Matrix4x4<T>( 1, 0, 0, 0.1, 0, 1, 0, 0.1, 0, 0, 1, 0.1, 0, 0, 0, 1 ) );

    #ifdef  TAPs_USE_CUDA

        //PrintDebug_ConnectionList();
        //PrintDebug();

        // Copy the (current) vertex positions of the object to memory for transfering to CUDA.
        CUDA_CopyVertexToMem();

        // Call the wrapper function for 
        TAPs::CUDA::Global__HETriMeshOneModelMultiParts_AdvSim( 
            m_cudaID,
            m_pHEVertexList->size(),    
            64,                         
            tCurrent,                   
            GetPredefinedTimeStep(),    
            GetNumSimSubSteps(),        
            GetKPointMass(),            
            GetKStiffness(),            
            GetKDamper(),               
            GetHomeKStiffness(),        
            GetHomeKDamper(),           
            m_cudaVertexList, 
            m_cudaPrevVertexList, 
            m_cudaHomeVertexList, 
            m_cudaVertexConnectionList, 
            m_cudaMaxConnectionSize 
        );

        // The new vertex positions are returned by CUDA to memory for previous vertex positions.
        // So the new vertex positions must be copied to the vertex positions of the object.
        CUDA_CopyMemToPrevVertex();
        // Then the previous and current vertex pointers (that point to memory for transfering to CUDA) are swapped.
        // So that now the previous becomes current and the current becomes previous.
        CUDA_SwapBuffers();

        GetBVHTree()->Update(); // commented out to rely on CDR to update the collided BVNodes
        CalAndSetNormals();

    #else //TAPs_USE_CUDA

        for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
            m_Parts[i].AdvSim( tCurrent );
            //std::cout << "AdvanceSimulation m_Parts[" << i << "]\n";
        }
        GetBVHTree()->Update(); // commented out to rely on CDR to update the collided BVNodes
        CalAndSetNormals();

    #endif//TAPs_USE_CUDA
}
//-----------------------------------------------------------------------------
// Advance Simulation
template <typename T>
void HETriMeshOneModelMultiParts<T>::AdvanceSimulation ( Simulation::SimClock<T> & simClock )
{
    std::cout << "HETriMeshOneModelMultiParts<T>::AdvanceSimulation ( Simulation::SimClock<T> & simClock ) -- NOT IMPLEMENTED YET!!!\n";
}
//-----------------------------------------------------------------------------
// DxDt
template <typename T>
bool HETriMeshOneModelMultiParts<T>::DxDt ( 
    T                       dt,         // I/P: time step
    Simulation::VectorSet<T> &  x,      // I/p: array  x = {pos, vel}
    Simulation::VectorSet<T> &  xdot,   // O/P: array xdot = {vel, accel}
    void *                  userData    // O/P: array of user data
)
{
    //-----------------------------------------------------
    // Convert userData ptr to ModelStrand ptr
    HETriMeshOneModelMultiParts<T> *pThis = static_cast<HETriMeshOneModelMultiParts<T> *>( userData );
    assert( pThis );

    //*
    pThis->ClearAllForces();
    //-----------------------------------------------------
    for ( int i = 0; i < static_cast<int>( pThis->m_vpSpringRef.size() ); ++i ) {
        pThis->m_vpSpringRef[i]->CalAndSetForce();
        //std::cout << "Force1: " << pThis->m_vpSpringRef[i]->GetForce1() << "\n";
        //std::cout << "Force2: " << pThis->m_vpSpringRef[i]->GetForce2() << "\n";
    }
    /*
    //-----------------------------------------------------
    for ( int i = 0; i < pThis->m_iStateSize; ++i ) {
//      pThis->(*m_pHEVertexList)[i]->GetListParticleRef()->SetVelocity( 0, 0, 0 );
//      pThis->(*m_pHEVertexList)[i]->GetListParticleRef()->SetForce( 0, 0, 0 );

        if ( (*pThis->m_pHEVertexList)[i]->GetParticleRef()->GetFixStatus() ) {
            (*pThis->m_pHEVertexList)[i]->GetParticleRef()->SetVelocity( 0, 0, 0 );
            (*pThis->m_pHEVertexList)[i]->GetParticleRef()->SetForce( 0, 0, 0 );
        }
        else {
//          (*pThis->m_pHEVertexList)[i]->GetListParticleRef()->SetForce( 0, 0, 0 );
//          pThis->m_prForce[i] = pThis->m_StructForce[i].gravity;
//          pThis->m_prVelocity[i][1] = pThis->m_prForce[i][1] * 
//                                      pThis->m_prVertex[i][1] *
//                                      dt;
            //Vector3<T> newForce = (*pThis->m_pHEVertexList)[i].GetParticleRef()->GetForce() / 10;
            //(*pThis->m_pHEVertexList)[i].GetParticleRef()->SetForce( newForce );
        }
    }
    //*/

    //-----------------------------------------------------
    pThis->DdtStateToArray( &xdot[0], dt );
    //-----------------------------------------------------
    return true;
}
//-----------------------------------------------------------------------------
// StateToArray
template <typename T>
void HETriMeshOneModelMultiParts<T>::StateToArray ( T *dst )
{
    //*
    for ( int i = 0; i < m_iStateSize; ++i ) {
        *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[0];
        *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[1];
        *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetPosition()[2];
        *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[0];
        *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[1];
        *(dst++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[2];
    }
    //*/
}
//-----------------------------------------------------------------------------
// ArrayToState
template <typename T>
void HETriMeshOneModelMultiParts<T>::ArrayToState ( T *src )
{
    //*
    for ( int i = 0; i < m_iStateSize; ++i ) {
        (*m_pHEVertexList)[i]->GetParticleRef()->SetPosition( *src, *(src+1), *(src+2) );
        src += 3;
        (*m_pHEVertexList)[i]->GetParticleRef()->SetVelocity( *src, *(src+1), *(src+2) );
        src += 3;
    }
    //*/
}
//-----------------------------------------------------------------------------
// DdtStateToArray
template <typename T>
void HETriMeshOneModelMultiParts<T>::DdtStateToArray ( T *xdot, T dt )
{
    //*
    for ( int i = 0; i < m_iStateSize; ++i ) {
        if ( (*m_pHEVertexList)[i]->GetParticleRef()->GetFixStatus() ) {
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 
            *(xdot++) = 0;
        }
        else {
            //m_prForce[i] = m_StructForce[i].gravity;
            //m_prVelocity[i][1] = m_prForce[i][1] * m_prVertex[i][1] * dt;
            //----------------------------------------
            *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[0];
            *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[1];
            *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetVelocity()[2];
            *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetForce()[0];
            *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetForce()[1];
            *(xdot++) = (*m_pHEVertexList)[i]->GetParticleRef()->GetForce()[2];
        }
    }
    //*/
}
//*/
//-----------------------------------------------------------------------------
// ClearForces
template <typename T>
void HETriMeshOneModelMultiParts<T>::ClearAllForces ()
{
    for ( int i = 0; i < static_cast<int>( m_pHEVertexList->size() ); ++i ) {
        (*m_pHEVertexList)[i]->GetParticleRef()->SetForce( 0, 0, 0 );
    }
}
//-----------------------------------------------------------------------------
//=============================================================================


//=============================================================================
#ifdef  TAPs_USE_CUDA
//-----------------------------------------------------------------------------

template <typename T>
bool HETriMeshOneModelMultiParts<T>::CUDA_Initialize_All ()
{
    bool result = true;
    if ( !CUDA_Initialize_VertexList() )            result = false;
    if ( !CUDA_Initialize_PrevVertexList() )        result = false;
    if ( !CUDA_Initialize_HomeVertexList() )        result = false;
    if ( !CUDA_Initialize_VertexConnectionList() )  result = false;

    std::cout << "# vertices: " << m_pHEVertexList->size() << "\tMax connection size: " << m_cudaMaxConnectionSize << "\n";

    /*
    m_cudaDeviceData = new TAPs_CUDA_DATA_HETriMeshOneModelMultiParts( 
        m_pHEVertexList->size(), m_cudaMaxConnectionSize 
    );
    if ( !m_cudaDeviceData )    result = false;
    //*/

    //std::cout << "m_cudaID: " << m_cudaID << "\n";

    TAPs::CUDA::InitailizeDataForVertexList( 
        m_cudaID,                   
        m_pHEVertexList->size(),    
        m_cudaMaxConnectionSize,    
        m_cudaVertexList,           
        m_cudaPrevVertexList,       
        m_cudaHomeVertexList,       
        m_cudaVertexConnectionList  
    );

    //std::cout << "m_cudaID: " << m_cudaID << "\n";

    return result;
}

template <typename T>
bool HETriMeshOneModelMultiParts<T>::CUDA_Initialize_VertexList ()
{
    CUDA_Cleanup_VertexList();

    std::cout << "m_cudaVertexList size: " << m_pHEVertexList->size() * 4 << "\n";

    unsigned int size = sizeof(float) * m_pHEVertexList->size() * 4;

    // Vertex List
    m_cudaVertexList = (float *)malloc( size );
    if ( m_cudaVertexList ) {
        CUDA_CopyVertexToMem();
    }
    else {
        std::cout << "ERROR: Could not allocate memory for (Vertex List) CUDA!" << std::endl;
        exit( -1 );
    }

    return true;    
}

template <typename T>
bool HETriMeshOneModelMultiParts<T>::CUDA_Initialize_PrevVertexList ()
{
    CUDA_Cleanup_PrevVertexList();

    std::cout << "m_cudaPrevVertexList size: " << m_pHEVertexList->size() * 4 << "\n";

    unsigned int size = sizeof(float) * m_pHEVertexList->size() * 4;

    // Previous Vertex List
    m_cudaPrevVertexList = (float *)malloc( size );
    if ( m_cudaPrevVertexList ) {
        CUDA_CopyPrevVertexToMem();
        //for ( int i = 0; i < 10; ++i ) {
        //  int p = i*4;
        //  printf( "V#%d: %g %g %g %g\n", i, m_cudaPrevVertexList[p], m_cudaPrevVertexList[p+1], m_cudaPrevVertexList[p+2], m_cudaPrevVertexList[p+3] );
        //}
    }
    else {
        std::cout << "ERROR: Could not allocate memory for (Previous Vertex List) CUDA!" << std::endl;
        exit( -1 );
    }

    return true;    
}

template <typename T>
bool HETriMeshOneModelMultiParts<T>::CUDA_Initialize_HomeVertexList ()
{
    CUDA_Cleanup_HomeVertexList();

    std::cout << "m_cudaHomeVertexList size: " << m_pHEVertexList->size() * 4 << "\n";

    unsigned int size = sizeof(float) * m_pHEVertexList->size() * 4;

    // Home Vertex List
    m_cudaHomeVertexList = (float *)malloc( size );
    if ( m_cudaHomeVertexList ) {
        CUDA_CopyHomeVertexToMem();
    }
    else {
        std::cout << "ERROR: Could not allocate memory for (Home Vertex List) CUDA!" << std::endl;
        exit( -1 );
    }

    return true;    
}

template <typename T>
bool HETriMeshOneModelMultiParts<T>::CUDA_Initialize_VertexConnectionList ()
{
    CUDA_Cleanup_VertexConnectionList();

    // Find the maximum connection list of a vertex
    m_cudaMaxConnectionSize = (*m_pHEVertexList)[0]->GetListConnectedVertices().size();
    for ( int i = 1; i < static_cast<int>( m_pHEVertexList->size() ); ++i ) {
        if ( m_cudaMaxConnectionSize < (*m_pHEVertexList)[i]->GetListConnectedVertices().size() ) {
            m_cudaMaxConnectionSize = (*m_pHEVertexList)[i]->GetListConnectedVertices().size();
        }
    }

    std::cout << "m_cudaMaxConnectionSize: " << m_cudaMaxConnectionSize << "\n";
    std::cout << "m_cudaVertexConnectionList size: " << m_pHEVertexList->size() * m_cudaMaxConnectionSize << "\n";

    unsigned int size;
#ifdef  TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS
    size = sizeof(float) * m_pHEVertexList->size() * m_cudaMaxConnectionSize * 4;
    m_cudaVertexConnectionList = (float *)malloc( size );
#else //TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS
    size = sizeof(int) * m_pHEVertexList->size() * m_cudaMaxConnectionSize;
    m_cudaVertexConnectionList = (int *)malloc( size );
#endif//TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS

    // Vertex Connection List
    if ( m_cudaVertexConnectionList ) {
        CUDA_CopyVertexConnectionToMem();
    }
    else {
        std::cout << "ERROR: Could not allocate memory for (Vertex Connection List) CUDA!" << std::endl;
        exit( -1 );
    }

    return true;    
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_Cleanup_All ()
{
    CUDA_Cleanup_VertexList();
    CUDA_Cleanup_PrevVertexList();
    CUDA_Cleanup_HomeVertexList();
    CUDA_Cleanup_VertexConnectionList();
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_Cleanup_VertexList ()
{
    if ( m_cudaVertexList ) {
        free( m_cudaVertexList );
        m_cudaVertexList = NULL;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_Cleanup_PrevVertexList ()
{
    if ( m_cudaPrevVertexList ) {
        free( m_cudaPrevVertexList );
        m_cudaPrevVertexList = NULL;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_Cleanup_HomeVertexList ()
{
    if ( m_cudaHomeVertexList ) {
        free( m_cudaHomeVertexList );
        m_cudaHomeVertexList = NULL;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_Cleanup_VertexConnectionList ()
{
    if ( m_cudaVertexConnectionList ) {
        free( m_cudaVertexConnectionList );
        m_cudaVertexConnectionList = NULL;
        m_cudaMaxConnectionSize = 0;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyVertexToMem ()
{
    if ( !m_cudaVertexList )    return;
    for ( unsigned int i = 0, p = 0; i < static_cast<unsigned int>( m_pHEVertexList->size() ); ++i ) {
        m_cudaVertexList[p++] = (*m_pHEVertexList)[i]->GetHEVertexPtr()->GetPosition()[0];
        m_cudaVertexList[p++] = (*m_pHEVertexList)[i]->GetHEVertexPtr()->GetPosition()[1];
        m_cudaVertexList[p++] = (*m_pHEVertexList)[i]->GetHEVertexPtr()->GetPosition()[2];
        m_cudaVertexList[p++] = 1;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyPrevVertexToMem ()
{
    if ( !m_cudaPrevVertexList )    return;
    for ( unsigned int i = 0, p = 0; i < static_cast<unsigned int>( m_pHEVertexList->size() ); ++i ) {
        m_cudaPrevVertexList[p++] = (*m_pHEVertexList)[i]->GetHEVertexPtr()->GetPosition()[0];
        m_cudaPrevVertexList[p++] = (*m_pHEVertexList)[i]->GetHEVertexPtr()->GetPosition()[1];
        m_cudaPrevVertexList[p++] = (*m_pHEVertexList)[i]->GetHEVertexPtr()->GetPosition()[2];
        m_cudaPrevVertexList[p++] = 1;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyMemToVertex ()
{
    if ( !m_cudaVertexList )    return;
    for ( unsigned int i = 0, p = 0; i < static_cast<unsigned int>( m_pHEVertexList->size() ); ++i ) {
        (*m_pHEVertexList)[i]->GetHEVertexPtr()->SetPosition( 
            m_cudaVertexList[p  ],
            m_cudaVertexList[p+1],
            m_cudaVertexList[p+2]
        );
        p += 4;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyMemToPrevVertex ()
{
    if ( !m_cudaPrevVertexList )    return;
    for ( unsigned int i = 0, p = 0; i < static_cast<unsigned int>( m_pHEVertexList->size() ); ++i ) {
        (*m_pHEVertexList)[i]->GetHEVertexPtr()->SetPosition( 
            m_cudaPrevVertexList[p  ],
            m_cudaPrevVertexList[p+1],
            m_cudaPrevVertexList[p+2]
        );
        p += 4;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyHomeVertexToMem ()
{
    if ( !m_cudaHomeVertexList )    return;
    for ( unsigned int i = 0, p = 0; i < static_cast<unsigned int>( m_pHEVertexList->size() ); ++i ) {
        //Vector3<T> worldPos = m_pHEVertexList)[i]->GetHomePosition();
        m_cudaHomeVertexList[p++] = (*m_pHEVertexList)[i]->GetHomePosition()[0];
        m_cudaHomeVertexList[p++] = (*m_pHEVertexList)[i]->GetHomePosition()[1];
        m_cudaHomeVertexList[p++] = (*m_pHEVertexList)[i]->GetHomePosition()[2];
        m_cudaHomeVertexList[p++] = 1;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyMemToHomeVertex ()
{
    if ( !m_cudaHomeVertexList )    return;
    for ( unsigned int i = 0, p = 0; i < static_cast<unsigned int>( m_pHEVertexList->size() ); ++i ) {
        (*m_pHEVertexList)[i]->SetHomePosition( 
            Vector3<T> (
                m_cudaHomeVertexList[p  ],
                m_cudaHomeVertexList[p+1],
                m_cudaHomeVertexList[p+2]
            )
        );
        p += 4;
    }
}

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyVertexConnectionToMem ()
{
    if ( !m_cudaVertexConnectionList )  return;

#ifdef  TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS
    std::cout << "NOT IMPLEMENTED YET!" << " File: " << __FILE__ << " Line: " << __LINE__ << std::endl;
#else //TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS
    for ( unsigned int i = 0, p = 0; i < static_cast<unsigned int>( m_pHEVertexList->size() ); ++i, p+=m_cudaMaxConnectionSize ) {
        unsigned int n = 0;
        for ( ; n < static_cast<int>( (*m_pHEVertexList)[i]->GetListConnectedVertices().size() ); ++n ) {
            m_cudaVertexConnectionList[p+n] = (*m_pHEVertexList)[i]->GetListConnectedVertices()[n];
        }
        for ( ; n < m_cudaMaxConnectionSize; ++n ) {
            m_cudaVertexConnectionList[p+n] = -1;
        }
    }
#endif//TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS

}

/*
template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_CopyMemToVertexConnection ()
{
    if ( !m_cudaVertexConnectionList )  return;

#ifdef  TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS
    std::cout << "NOT IMPLEMENTED YET!" << " File: " << __FILE__ << " Line: " << __LINE__ << std::endl;
    //for ( int i = 0, p = 0; i < static_cast<int>( m_pHEVertexList->size() ); ++i, p+=m_cudaMaxConnectionSize ) {
    //  for ( int n = 0; n < static_cast<int>( (*m_pHEVertexList)[i]->GetListConnectedVertices().size() ); ++n ) {
    //      float fValue = m_cudaVertexConnectionList[p+n];
    //      int iVal = static_cast<int>(fVal);
    //      if ( fVal+0.5f >= iVal+1 ) {
    //          (*m_pHEVertexList)[i]->GetListConnectedVertices()[n] = iVal+1;
    //      }
    //      else {
    //          (*m_pHEVertexList)[i]->GetListConnectedVertices()[n] = iVal;
    //      }

    //  }
    //}
#else //TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS
    for ( int i = 0, p = 0; i < static_cast<int>( m_pHEVertexList->size() ); ++i, p+=m_cudaMaxConnectionSize ) {
        for ( int n = 0; n < static_cast<int>( (*m_pHEVertexList)[i]->GetListConnectedVertices().size() ); ++n ) {
            (*m_pHEVertexList)[i]->GetListConnectedVertices()[n] = m_cudaVertexConnectionList[p+n];
        }
    }
#endif//TAPs_CUDA_MSS_INDIVIDUAL_SPRING_PROPS

}
//*/

template <typename T>
void HETriMeshOneModelMultiParts<T>::CUDA_SwapBuffers ()
{
    float * tmpPtr = m_cudaVertexList;
    m_cudaVertexList = m_cudaPrevVertexList;
    m_cudaPrevVertexList = tmpPtr;
}

//-----------------------------------------------------------------------------
#endif//TAPs_USE_CUDA
//=============================================================================


#ifdef  TAPs_USE_WXWIDGETS
//=============================================================================
    template <typename T>
    void HETriMeshOneModelMultiParts<T>::ShowPropertyDialog ( wxWindow * parent )
    {
        if ( pDialogs == NULL ) {
            wxMessageDialog( NULL, "HETriMeshOneModelMultiParts' Property Dialog was not created!", "Info", wxOK );
            return;
        }
        if ( pDialogs->IsInitialized() ) {
            // If the dialog is shown, then close it.
            if ( pDialogs->IsShown() ) {
                pDialogs->Close();
            }
            // If the dialog is not shown, then show it.
            else {
                pDialogs->PropertyDialog<T>( parent, &GetTransform(), &GetListOfParts() );
            }
        }
        else {
            wxMessageDialog( NULL, "HETriMeshOneModelMultiParts' Property Dialog is not available!", "Info", wxOK );
        }
    }
//=============================================================================
#endif//TAPs_USE_WXWIDGETS

//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----