TAPsModelDeformableGLSL_ConnectivityOne.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsModelDeformableGLSL_ConnectivityOne.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (10/17/2006)
UPDATE          (09/29/2007)
******************************************************************************/
#include "TAPsModelDeformableGLSL.hpp"
//#include "TAPsModelDeformableGLSL_ConnectivityOne.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
//=============================================================================
//-----------------------------------------------------------------------------
// START FNs FOR TAPs_MODEL_DEFORMABLE_USE_TEXTURE_CONNECTIVITY_ONE
#ifdef TAPs_MODEL_DEFORMABLE_USE_TEXTURE_CONNECTIVITY_ONE
//-----------------------------------------------------------------------------

//=============================================================================
// For Initializations & Setups
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL<T>::SetupConnectivityPattern ( 
    enum ConnectivityPattern CP 
)
{
    // PROVIDE CONNECTIONS ARRANGED IN THESE INDICES ORDER
    //-------------------------------------------------
    // Identification Numbers (for front, center, and back planes)
    // from connectionPattern
    // --------------------------------
    // |   FRONT    CENTER     BACK   |
    // | 07 06 05  15 14 13  23 22 21 |
    // | 04 25 03  12 26 11  20 24 19 |
    // | 02 01 00  10 09 08  18 17 16 |
    // --------------------------------
    // ----------------------------------------------------------------------
    // Connectivities
    // (The group is arranged in one texel of 4 components.)
    // ----------------------------------------------------------------------
    // |        FRONT         |       CENTER         |        BACK          |
    // | 07(NW) 06(N)  05(NE) | 15(NW) 14(N)  13(NE) | 23(NW) 22(N)  21(NE) |
    // | 04(W)  25(F)  03(E)  | 12(W)  26(C)  11(E)  | 20(W)  24(B)  19(E)  |
    // | 02(SW) 01(S)  00(SE) | 10(SW) 09(S)  08(SE) | 18(SW) 17(S)  16(SE) |
    // ----------------------------------------------------------------------
    //-------------------------------------------------
    switch ( CP ) {
        case FULL_ONE_RING:
        default:
            //---------------------------------------------
            // FOR POSITIONS
            // Front Plane
            m_piConnectionPattern[ 7] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_NORTH_WEST];
            m_piConnectionPattern[ 6] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_NORTH];
            m_piConnectionPattern[ 5] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_NORTH_EAST];
            m_piConnectionPattern[ 4] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_WEST];
            m_piConnectionPattern[ 3] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_EAST];
            m_piConnectionPattern[ 2] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_SOUTH_WEST];
            m_piConnectionPattern[ 1] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_SOUTH];
            m_piConnectionPattern[ 0] = CONNECTION_INDEX_POSITION[SpringProp::FRONT_SOUTH_EAST];
            // Center Plane
            m_piConnectionPattern[15] = CONNECTION_INDEX_POSITION[SpringProp::NORTH_WEST];
            m_piConnectionPattern[14] = CONNECTION_INDEX_POSITION[SpringProp::NORTH];
            m_piConnectionPattern[13] = CONNECTION_INDEX_POSITION[SpringProp::NORTH_EAST];
            m_piConnectionPattern[12] = CONNECTION_INDEX_POSITION[SpringProp::WEST];
            m_piConnectionPattern[11] = CONNECTION_INDEX_POSITION[SpringProp::EAST];
            m_piConnectionPattern[10] = CONNECTION_INDEX_POSITION[SpringProp::SOUTH_WEST];
            m_piConnectionPattern[ 9] = CONNECTION_INDEX_POSITION[SpringProp::SOUTH];
            m_piConnectionPattern[ 8] = CONNECTION_INDEX_POSITION[SpringProp::SOUTH_EAST];
            // Back Plane
            m_piConnectionPattern[23] = CONNECTION_INDEX_POSITION[SpringProp::BACK_NORTH_WEST];
            m_piConnectionPattern[22] = CONNECTION_INDEX_POSITION[SpringProp::BACK_NORTH];
            m_piConnectionPattern[21] = CONNECTION_INDEX_POSITION[SpringProp::BACK_NORTH_EAST];
            m_piConnectionPattern[20] = CONNECTION_INDEX_POSITION[SpringProp::BACK_WEST];
            m_piConnectionPattern[19] = CONNECTION_INDEX_POSITION[SpringProp::BACK_EAST];
            m_piConnectionPattern[18] = CONNECTION_INDEX_POSITION[SpringProp::BACK_SOUTH_WEST];
            m_piConnectionPattern[17] = CONNECTION_INDEX_POSITION[SpringProp::BACK_SOUTH];
            m_piConnectionPattern[16] = CONNECTION_INDEX_POSITION[SpringProp::BACK_SOUTH_EAST];
            //---------------------------------------------
            // Center, Front, & Back
            m_piConnectionPattern[26] = CONNECTION_INDEX_POSITION[SpringProp::NOT_CONNECTED];
            m_piConnectionPattern[25] = CONNECTION_INDEX_POSITION[SpringProp::FRONT];
            m_piConnectionPattern[24] = CONNECTION_INDEX_POSITION[SpringProp::BACK];
            //---------------------------------------------
            /*
            #ifdef TAPs_DEBUG_MODE
            std::cout << "Connection Pattern\n";
            std::cout << "------------------\n";
            for ( int i = 0; i < 27; ++i ) {
                std::cout << "m_piConnectionPattern[" << i << "]: " << m_piConnectionPattern[i] << "\n";
            }
            std::cout << "------------------\n";
            #endif//TAPs_DEBUG_MODE
            //*/
            //---------------------------------------------
        break;
    }
}
//-----------------------------------------------------------------------------
//=============================================================================


//*****************************************************************************
// BEGIN: Setup3DTexturesForConnectivities
//-----------------------------------------------------------------------------
template <typename T>
bool ModelDeformableGLSL<T>::Setup3DTextureForConnectivities ( 
    int resolutionX, int resolutionY, int resolutionZ, 
    T ****                                  ptElementPosition, 
    enum GridGenerator<T>::VertexFlag ***   pcElementFlag, 
    enum ConnectivityPattern cp
)
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "START: Setup3DTextureForConnectivities" << std::endl;
    #endif//TAPs_DEBUG_MODE

    //---------------------------------------------------------------
    // Values of Textures for Connectivities
    // 4 components for one FCB+1, and 3(width) x 3(height) for one plane
    GLenum      target          =   m_3DTexturePosition->GetTarget();
    GLint       level           =   m_3DTexturePosition->GetLevel();
    GLint       internalFormat  =   GL_RGBA;
    GLsizei     width           =   m_3DTexturePosition->GetWidth();
    GLsizei     height          =   m_3DTexturePosition->GetHeight();
    GLsizei     depth           =   m_3DTexturePosition->GetDepth();
    GLint       border          =   m_3DTexturePosition->GetBorder();
    GLenum      pixelFormat     =   GL_RGBA;
    GLenum      dataType        =   GL_UNSIGNED_BYTE;
    //
    unsigned char   internalFormatNumOfComponents   =   4;
    unsigned char   pixelFormatNumOfComponents      =   4;
    //
    unsigned short  numOfTextures   =   2;
    //-------------------------------------------------
    // Identification Numbers (for front, center, and back planes)
    // from connectionPattern
    // --------------------------------
    // |   FRONT    CENTER     BACK   |
    // | 07 06 05  15 14 13  23 22 21 |
    // | 04 25 03  12 26 11  20 24 19 |
    // | 02 01 00  10 09 08  18 17 16 |
    // --------------------------------
    //-------------------------------------------------
    // RGBA Components Represent
    //  -------------------------------------------
    // 8-bit ubyte  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
    //  -------------------------------------------
    // R --> Front  | NW| N | NE| W | E | SW| S | SE|
    // G --> Center | NW| N | NE| W | E | SW| S | SE|
    // B --> Back   | NW| N | NE| W | E | SW| S | SE|
    // A --> Misc   |   |   |   |   |   | C | F | B |
    //-------------------------------------------------
    SetupConnectivityPattern( FULL_ONE_RING );
    // After the above statement m_piConnectionPattern and 
    //   m_piConnectionPatternToTextureConnectivity
    //   are set according to the passed ConnectivityPattern argument.
    //---------------------------------------------------------------
    // Setup Data for Connectivities
    //*******************************************
    // The coordinate (s,t) values must be mapped to range [0,1]
    SetupTextureCoordinateValues( 
        offsetCoordSPosition, offsetCoordTPosition, offsetCoordRPosition, 
        m_3DTexturePosition->GetWidth(),
        m_3DTexturePosition->GetHeight(),
        m_3DTexturePosition->GetDepth()
    );
    SetupTextureCoordinateValues( 
        offsetCoordSConnection, offsetCoordTConnection, offsetCoordRConnection, 
        width, 
        height, 
        depth 
    );
    //*******************************************
    //===============================================================
    // Setup Texture for Connectivities
    //---------------------------------------------------------------
    unsigned int offset = width * height * pixelFormatNumOfComponents;
    //-----------------------------------------------------
    // Allocate memory for connectivity data
    int iMemorySizeForTotalElements = offset * resolutionZ;
    GLubyte * connectivityData = new GLubyte[ iMemorySizeForTotalElements ];
    //if ( connectivityData == NULL ) {
    //  std::cout << "ASSERT FAILED: connectivityData is NULL -- Setup3DTextureForConnectivities -- One" << std::endl;
    //}
    assert( connectivityData );
    for ( int i = 0; i < iMemorySizeForTotalElements; ++i ) {
        connectivityData[i] = 0;
    }

    //-----------------------------------------------------
    // DEBUG
#ifdef  TAPs_DEBUG_MODE
    std::cout << "size of connectivityData: " << iMemorySizeForTotalElements << "\n";
    std::cout << "m_piConnectionPattern[27]: " << "\n";
    std::cout << " FRONT        CENTER           BACK \n";

    //std::cout << m_piConnectionPattern[ 0] << " " << m_piConnectionPattern[ 1] << " " << m_piConnectionPattern[ 2] << "\t\t";
    //std::cout << m_piConnectionPattern[ 8] << " " << m_piConnectionPattern[ 9] << " " << m_piConnectionPattern[10] << "\t\t";
    //std::cout << m_piConnectionPattern[16] << " " << m_piConnectionPattern[17] << " " << m_piConnectionPattern[18] << "\n";
    //std::cout << m_piConnectionPattern[ 3] << " " << m_piConnectionPattern[25] << " " << m_piConnectionPattern[ 4] << "\t\t";
    //std::cout << m_piConnectionPattern[11] << " " << m_piConnectionPattern[24] << " " << m_piConnectionPattern[12] << "\t\t";
    //std::cout << m_piConnectionPattern[19] << " " << m_piConnectionPattern[26] << " " << m_piConnectionPattern[20] << "\n";
    //std::cout << m_piConnectionPattern[ 5] << " " << m_piConnectionPattern[ 6] << " " << m_piConnectionPattern[ 7] << "\t\t";
    //std::cout << m_piConnectionPattern[13] << " " << m_piConnectionPattern[14] << " " << m_piConnectionPattern[15] << "\t\t";
    //std::cout << m_piConnectionPattern[21] << " " << m_piConnectionPattern[22] << " " << m_piConnectionPattern[23] << "\n";

    std::cout << m_piConnectionPattern[ 7] << " " << m_piConnectionPattern[ 6] << " " << m_piConnectionPattern[ 5] << "\t\t";
    std::cout << m_piConnectionPattern[15] << " " << m_piConnectionPattern[14] << " " << m_piConnectionPattern[13] << "\t\t";
    std::cout << m_piConnectionPattern[23] << " " << m_piConnectionPattern[22] << " " << m_piConnectionPattern[21] << "\n";
    //
    std::cout << m_piConnectionPattern[ 4] << " " << m_piConnectionPattern[25] << " " << m_piConnectionPattern[ 3] << "\t\t";
    std::cout << m_piConnectionPattern[12] << " " << m_piConnectionPattern[26] << " " << m_piConnectionPattern[11] << "\t\t";
    std::cout << m_piConnectionPattern[20] << " " << m_piConnectionPattern[24] << " " << m_piConnectionPattern[19] << "\n";
    //
    std::cout << m_piConnectionPattern[ 2] << " " << m_piConnectionPattern[ 1] << " " << m_piConnectionPattern[ 0] << "\t\t";
    std::cout << m_piConnectionPattern[10] << " " << m_piConnectionPattern[ 9] << " " << m_piConnectionPattern[ 8] << "\t\t";
    std::cout << m_piConnectionPattern[18] << " " << m_piConnectionPattern[17] << " " << m_piConnectionPattern[16] << "\n";
#endif//TAPs_DEBUG_MODE
    //-----------------------------------------------------

    //-----------------------------------------------------
    SetupAllConnections( 
        resolutionX, resolutionY, resolutionZ, 
        m_glpTexelForVertexPos, 
        m_piConnectionPattern, 
        //250.0,                    // Threshold value  (without outside data)
        //150.0,                    // Threshold value  (with inside data)
        m_tSimThreshold,
        connectivityData 
    );
    //-----------------------------------------------------
    // One 3D texture for Connectivities
    m_3DTextureConnectivity = new Texture( 
        target, level, internalFormat, 
        width, height, depth, 
        border, pixelFormat, dataType, 
        //connectivityData,             // texels
        NULL            ,               // texels
        numOfTextures, 
        GL_NEAREST, GL_NEAREST,         // mag & min filter
        GL_CLAMP, GL_CLAMP, GL_CLAMP    // wrap s, t, & r
    );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //---------------------------------
    // Current (for reading) [0] & Change (for writing) [1]
    for ( int i = 0; i < numOfTextures; ++i ) {
        GLuint texName = m_3DTextureConnectivity->GetTexture( i );
        glBindTexture( GL_TEXTURE_3D, texName );
        glTexImage3D( 
            m_3DTextureConnectivity->GetTarget(),
            m_3DTextureConnectivity->GetLevel(),
            m_3DTextureConnectivity->GetInternalFormat(),
            m_3DTextureConnectivity->GetWidth(),
            m_3DTextureConnectivity->GetHeight(),
            m_3DTextureConnectivity->GetDepth(),
            m_3DTextureConnectivity->GetBorder(),
            m_3DTextureConnectivity->GetPixelFormat(),
            m_3DTextureConnectivity->GetDataType(),
            connectivityData 
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    }
    //---------------------------------------------------------------
    //===============================================================
    //---------------------------------------------------------------
    delete [] connectivityData;
    //---------------------------------------------------------------

    //---------------------------------------------------------------
    // DEBUG: Print out the Element Home Positions after setup
#ifdef  TAPs_DEBUG_MODE
    assert ( m_3DTextureHomePosition );
    for ( int i = 0; i < m_3DTextureHomePosition->GetNumberOfTextures(); ++i ) {
    //for ( int i = 0; i < 1; ++i ) {
        std::cout << "\nm_3DTextureHomePosition -- Texture#" << i << ":\n";
        DebugTextureData( 
            m_3DTextureHomePosition->GetWidth(), 
            m_3DTextureHomePosition->GetHeight(), 
            m_3DTextureHomePosition->GetDepth(), 
            m_3DTextureHomePosition->GetInternalFormatNumberOfComponents(), 
            m_3DTextureHomePosition->GetTarget(), 
            m_3DTextureHomePosition->GetPixelFormat(), 
            m_3DTextureHomePosition->GetDataType(), 
            m_3DTextureHomePosition->GetTexture(i)
        );
    }
#endif//TAPs_DEBUG_MODE
    //---------------------------------------------------------------
    // DEBUG: Print out the Element Positions after setup
#ifdef  TAPs_DEBUG_MODE
    assert ( m_3DTexturePosition );
    for ( int i = 0; i < m_3DTexturePosition->GetNumberOfTextures(); ++i ) {
    //for ( int i = 0; i < 1; ++i ) {
        std::cout << "\nm_3DTexturePosition -- Texture#" << i << ":\n";
        DebugTextureData( 
            m_3DTexturePosition->GetWidth(), 
            m_3DTexturePosition->GetHeight(), 
            m_3DTexturePosition->GetDepth(), 
            m_3DTexturePosition->GetInternalFormatNumberOfComponents(), 
            m_3DTexturePosition->GetTarget(), 
            m_3DTexturePosition->GetPixelFormat(), 
            m_3DTexturePosition->GetDataType(), 
            m_3DTexturePosition->GetTexture(i)
        );
    }
#endif//TAPs_DEBUG_MODE
    //---------------------------------------------------------------
    // DEBUG: Print out the Connectivity Data after setup
#ifdef  TAPs_DEBUG_MODE
    //assert( m_3DTextureConnectivity );
    //for ( int i = 0; i < m_3DTextureConnectivity->GetNumberOfTextures(); ++i ) {
    //  std::cout << "\nm_3DTextureConnectivity -- Texture#" << i << ":\n";
    //  DebugTextureDataInConnectivityFormat( 
    //      m_3DTextureConnectivity->GetWidth(),
    //      m_3DTextureConnectivity->GetHeight(),
    //      m_3DTextureConnectivity->GetDepth(),
    //      m_3DTextureConnectivity->GetInternalFormatNumberOfComponents(),
    //      m_3DTextureConnectivity->GetTarget(),
    //      m_3DTextureConnectivity->GetPixelFormat(),
    //      m_3DTextureConnectivity->GetDataType(),
    //      m_3DTextureConnectivity->GetTexture(i)
    //  );
    //}
#endif//TAPs_DEBUG_MODE
    //---------------------------------------------------------------

    //---------------------------------------------------------------
    return true;
}
//-----------------------------------------------------------------------------
// END: Setup3DTextureForConnectivities
//*****************************************************************************


//*****************************************************************************
// BEGIN: SetupAllConnections
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL<T>::SetupAllConnections ( 
    int resolutionX, int resolutionY, int resolutionZ,  // I/Ps:
    GLfloat const * pVertexPosAndFlag,  // I/Ps: pointer to vertex pos + flag
    int const connectionPattern[27],    // I/Ps: connection pattern
    int threshold,                      // I/Ps: threshold value
    GLubyte * connectivityData          // O/Ps: connectivity data
)
{
    //-------------------------------------------------
    // Create connection index to textures
    //   Index
    //-------------------------------------------------
    // Identification Numbers (for front, center, and back planes)
    // from connectionPattern
    // --------------------------------
    // |   FRONT    CENTER     BACK   |
    // | 07 06 05  15 14 13  23 22 21 |
    // | 04 25 03  12 26 11  20 24 19 |
    // | 02 01 00  10 09 08  18 17 16 |
    // --------------------------------
    //-------------------------------------------------
    // RGBA Components Represent
    //  -------------------------------------------
    // 8-bit ubyte  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
    //  -------------------------------------------
    // R --> Front  | NW| N | NE| W | E | SW| S | SE|
    // G --> Center | NW| N | NE| W | E | SW| S | SE|
    // B --> Back   | NW| N | NE| W | E | SW| S | SE|
    // A --> Misc   |   |   |   |   |   | C | F | B |
    //-------------------------------------------------
    //---------------------------------------------------------------
    // All elements not on the boundary
    for ( int Z = 1; Z < resolutionZ-1; ++Z ) {
        for ( int Y = 1; Y < resolutionY-1; ++Y ) {
            for ( int X = 1; X < resolutionX-1; ++X ) {
                SetupConnectionsOfOneElementNotOnBoundary( 
                    resolutionX, resolutionY, 
                    pVertexPosAndFlag, 
                    connectionPattern, 
                    X, Y, Z, 
                    threshold, 
                    connectivityData 
                );
            }
        }
    }
    //*
    //---------------------------------------------------------------
    // The first (and back) slice and the last (and front) slice
    for ( int Z = 0; Z < resolutionZ; Z += resolutionZ-1 ) {
        for ( int Y = 0; Y < resolutionY; ++Y ) {
            for ( int X = 0; X < resolutionX; ++X ) {
                SetupConnectionsOfOneElementOnBoundary( 
                    resolutionX, resolutionY, resolutionZ, 
                    pVertexPosAndFlag, 
                    connectionPattern, 
                    X, Y, Z, 
                    threshold, 
                    connectivityData 
                );
            }
        }
    }
    //---------------------------------------------------------------
    // The bottom slice and the top slice
    for ( int Z = 0; Z < resolutionZ; ++Z ) {
        for ( int Y = 0; Y < resolutionY; Y += resolutionY-1 ) {
            for ( int X = 0; X < resolutionX; ++X ) {
                SetupConnectionsOfOneElementOnBoundary( 
                    resolutionX, resolutionY, resolutionZ, 
                    pVertexPosAndFlag, 
                    connectionPattern, 
                    X, Y, Z, 
                    threshold, 
                    connectivityData 
                );
            }
        }
    }
    //---------------------------------------------------------------
    // The left slice and the right slice
    for ( int Z = 1; Z < resolutionZ-1; ++Z ) {
        for ( int Y = 1; Y < resolutionY-1; ++Y ) {
            for ( int X = 0; X < resolutionX; X += resolutionX-1 ) {
                SetupConnectionsOfOneElementOnBoundary( 
                    resolutionX, resolutionY, resolutionZ, 
                    pVertexPosAndFlag, 
                    connectionPattern, 
                    X, Y, Z, 
                    threshold, 
                    connectivityData 
                );
            }
        }
    }
    //*/
}
//-----------------------------------------------------------------------------
// END: SetupAllConnections
//*****************************************************************************


//*****************************************************************************
// BEGIN: SetupConnectionsOfOneElementNotOnBoundary
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL<T>::SetupConnectionsOfOneElementNotOnBoundary ( 
    int resolutionX, int resolutionY,   // I/Ps: texture width & height
    GLfloat const * pVertexPosAndFlag,  // I/Ps: pointer to vertex pos + flag
    int const connectionPattern[27],    // I/Ps: connection pattern to neighbor voxel
    int x, int y, int z,                // I/Ps: element location
    int threshold,                      // I/Ps: threshold value
    GLubyte * connectivityData          // O/Ps: connectivity data
)
{
    //-------------------------------------------------
    // Indices to the original voxel data
    int iOffsetSlice = resolutionX * resolutionY;                   // 4 for positions + flag
    int indexThis    = (z*iOffsetSlice + y*resolutionX + x)*4 + 3;  // + 3 for accessing the flag
    int indexConnectedTo;
    // Indices to the connectivity texture
    int idxConnectionTexture;
    //-------------------------------------------------
    // Check if this voxel does not represent void
    if ( pVertexPosAndFlag[indexThis] < threshold ) return;
    //-------------------------------------------------
    //-------------------------------------------------
    // Identification Numbers (for front, center, and back planes)
    // from connectionPattern
    // --------------------------------
    // |   FRONT    CENTER     BACK   |
    // | 07 06 05  15 14 13  23 22 21 |
    // | 04 25 03  12 26 11  20 24 19 |
    // | 02 01 00  10 09 08  18 17 16 |
    // --------------------------------
    //-------------------------------------------------
    // RGBA Components Represent
    //  -------------------------------------------
    // 8-bit ubyte  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
    //  -------------------------------------------
    // R --> Front  | NW| N | NE| W | E | SW| S | SE|
    // G --> Center | NW| N | NE| W | E | SW| S | SE|
    // B --> Back   | NW| N | NE| W | E | SW| S | SE|
    // A --> Misc   |   |   |   |   |   | C | F | B |
    //-------------------------------------------------
    GLubyte R = 0, G = 0, B = 0, A = 0;
    //-------------------------------------------------
    int i = 0;
    //---------------------------------
    // R
    // FNW
    i = 7;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 128;
    }
    // FN
    i = 6;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 64;
    }
    // FNE
    i = 5;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 32;
    }
    // FW
    i = 4;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 16;
    }
    // FE
    i = 3;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 8;
    }
    // FSW
    i = 2;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 4;
    }
    // FS
    i = 1;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 2;
    }
    // FSE
    i = 0;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        R += 1;
    }
    //---------------------------------
    // G
    // NW
    i = 15;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 128;
    }
    // N
    i = 14;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 64;
    }
    // NE
    i = 13;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 32;
    }
    // W
    i = 12;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 16;
    }
    // E
    i = 11;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 8;
    }
    // SW
    i = 10;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 4;
    }
    // S
    i = 9;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 2;
    }
    // SE
    i = 8;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        G += 1;
    }
    //---------------------------------
    // B
    // BNW
    i = 23;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 128;
    }
    // BN
    i = 22;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 64;
    }
    // BNE
    i = 21;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 32;
    }
    // BW
    i = 20;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 16;
    }
    // BE
    i = 19;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 8;
    }
    // BSW
    i = 18;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 4;
    }
    // BS
    i = 17;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 2;
    }
    // BSE
    i = 16;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        B += 1;
    }
    //---------------------------------
    // A
    // CENTER (HOME)
    i = 26;
    indexConnectedTo = indexThis + connectionPattern[i];
    //if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {

    // Only outside elements connect to home spring
    if ( pVertexPosAndFlag[indexThis] < IC_Thresholds::ON_BOUNDARY ) 
    {
        A += 4;
    }
    //}

    // FRONT
    i = 25;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        A += 2;
    }
    // BACK
    i = 24;
    indexConnectedTo = indexThis + connectionPattern[i];
    if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
        A += 1;
    }
    //-----------------------------------------------------
    // Record the connectivity
    idxConnectionTexture = indexThis - 3;
    connectivityData[idxConnectionTexture++] = R;
    connectivityData[idxConnectionTexture++] = G;
    connectivityData[idxConnectionTexture++] = B;
    connectivityData[idxConnectionTexture  ] = A;

    /*
    // DEBUG
    std::cout << "Connectivity Data of (" << x << ", " << y << ", " << z << ")";
    std::cout << "\tR " << (int) R;
    std::cout << "\tG " << (int) G;
    std::cout << "\tB " << (int) B;
    std::cout << "\tA " << (int) A;
    std::cout << "\n";
    //*/
}
//-----------------------------------------------------------------------------
// END: SetupConnectionsOfOneElementNotOnBoundary
//*****************************************************************************


//*****************************************************************************
// BEGIN: SetupConnectionsOfOneElementOnBoundary
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL<T>::SetupConnectionsOfOneElementOnBoundary ( 
    int resolutionX, int resolutionY, int resolutionZ,  // I/Ps: texture width & height
    GLfloat const * pVertexPosAndFlag,  // I/Ps: pointer to vertex pos + flag
    int const connectionPattern[27],    // I/Ps: connection pattern to neighbor voxel
    int x, int y, int z,                // I/Ps: element location
    int threshold,                      // I/Ps: threshold value
    GLubyte * connectivityData          // O/Ps: connectivity data
)
{
    //-------------------------------------------------
    // Indices to the original voxel data
    int iOffsetSlice = resolutionX * resolutionY;                   // 4 for positions + flag
    int indexThis    = (z*iOffsetSlice + y*resolutionX + x)*4 + 3;  // + 3 for accessing the flag
    int indexConnectedTo;
    // Indices to the connectivity texture
    int idxConnectionTexture;
    //-------------------------------------------------
    // Check if this voxel does not represent void
    if ( pVertexPosAndFlag[indexThis] < threshold ) return;
    //-------------------------------------------------
    //-------------------------------------------------
    // Identification Numbers (for front, center, and back planes)
    // from connectionPattern
    // --------------------------------
    // |   FRONT    CENTER     BACK   |
    // | 07 06 05  15 14 13  23 22 21 |
    // | 04 25 03  12 26 11  20 24 19 |
    // | 02 01 00  10 09 08  18 17 16 |
    // --------------------------------
    //-------------------------------------------------
    // RGBA Components Represent
    //  -------------------------------------------
    // 8-bit ubyte  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
    //  -------------------------------------------
    // R --> Front  | NW| N | NE| W | E | SW| S | SE|
    // G --> Center | NW| N | NE| W | E | SW| S | SE|
    // B --> Back   | NW| N | NE| W | E | SW| S | SE|
    // A --> Misc   |   |   |   |   |   | C | F | B |
    //-------------------------------------------------
    GLubyte R = 0, G = 0, B = 0, A = 0;
    //-------------------------------------------------
    //-------------------------------------------------
    int iBoundEast  = resolutionX - 1;
    int iBoundWest  = 0;
    int iBoundNorth = resolutionY - 1;
    int iBoundSouth = 0;
    int iBoundFront = resolutionZ - 1;
    int iBoundBack  = 0;
    //-------------------------------------------------
    int i = 0;
    //---------------------------------
    // R
    // FNW
    if ( z < iBoundFront && y < iBoundNorth && x > iBoundWest ) {
        i = 7;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 128;
        }
    }
    // FN
    if ( z < iBoundFront && y < iBoundNorth ) {
        i = 6;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 64;
        }
    }
    // FNE
    if ( z < iBoundFront && y < iBoundNorth && x < iBoundEast ) {
        i = 5;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 32;
        }
    }
    // FW
    if ( z < iBoundFront && x > iBoundWest ) {
        i = 4;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 16;
        }
    }
    // FE
    if ( z < iBoundFront && x < iBoundEast ) {
        i = 3;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 8;
        }
    }
    // FSW
    if ( z < iBoundFront && y > iBoundSouth && x > iBoundWest ) {
        i = 2;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 4;
        }
    }
    // FS
    if ( z < iBoundFront && y > iBoundSouth ) {
        i = 1;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 2;
        }
    }
    // FSE
    if ( z < iBoundFront && y > iBoundSouth && x < iBoundEast ) {
        i = 0;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            R += 1;
        }
    }
    //---------------------------------
    // G
    // NW
    if ( y < iBoundNorth && x > iBoundWest ) {
        i = 15;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 128;
        }
    }
    // N
    if ( y < iBoundNorth ) {
        i = 14;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 64;
        }
    }
    // NE
    if ( y < iBoundNorth && x < iBoundEast ) {
        i = 13;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 32;
        }
    }
    // W
    if ( x > iBoundWest ) {
        i = 12;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 16;
        }
    }
    // E
    if ( x < iBoundEast ) {
        i = 11;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 8;
        }
    }
    // SW
    if ( y > iBoundSouth && x > iBoundWest ) {
        i = 10;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 4;
        }
    }
    // S
    if ( y > iBoundSouth ) {
        i = 9;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 2;
        }
    }
    // SE
    if ( y > iBoundSouth && x < iBoundEast ) {
        i = 8;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            G += 1;
        }
    }
    //---------------------------------
    // B
    // BNW
    if ( z > iBoundBack && y < iBoundNorth && x > iBoundWest ) {
        i = 23;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 128;
        }
    }
    // BN
    if ( z > iBoundBack && y < iBoundNorth ) {
        i = 22;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 64;
        }
    }
    // BNE
    if ( z > iBoundBack && y < iBoundNorth && x < iBoundEast ) {
        i = 21;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 32;
        }
    }
    // BW
    if ( z > iBoundBack && x > iBoundWest ) {
        i = 20;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 16;
        }
    }
    // BE
    if ( z > iBoundBack && x < iBoundEast ) {
        i = 19;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 8;
        }
    }
    // BSW
    if ( z > iBoundBack && y > iBoundSouth && x > iBoundWest ) {
        i = 18;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 4;
        }
    }
    // BS
    if ( z > iBoundBack && y > iBoundSouth ) {
        i = 17;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 2;
        }
    }
    // BSE
    if ( z > iBoundBack && y > iBoundSouth && x < iBoundEast ) {
        i = 16;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            B += 1;
        }
    }
    //---------------------------------
    // A
    // CENTER
        //i = 26;
        //indexConnectedTo = indexThis + connectionPattern[i];
        //if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            A += 4;
        //}
    // FRONT
    if ( z < iBoundFront ) {
        i = 25;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            A += 2;
        }
    }
    // BACK
    if ( z > iBoundBack ) {
        i = 24;
        indexConnectedTo = indexThis + connectionPattern[i];
        if ( connectionPattern[i] != 0 && pVertexPosAndFlag[indexConnectedTo] >= threshold ) {
            A += 1;
        }
    }
    //-----------------------------------------------------
    // Record the connectivity
    idxConnectionTexture = indexThis - 3;
    connectivityData[idxConnectionTexture++] = R;
    connectivityData[idxConnectionTexture++] = G;
    connectivityData[idxConnectionTexture++] = B;
    connectivityData[idxConnectionTexture  ] = A;
}
//-----------------------------------------------------------------------------
// END: SetupConnectionsOfOneElementOnBoundary
//*****************************************************************************


//*****************************************************************************
// BEGIN: DrawByGL_AllElementsWithConnectivities_GPU
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL<T>::DrawByGL_AllElementsWithConnectivities_GPU ()
{
//*
    //---------------------------------------------------------------
    if ( !m_3DTexturePosition ) return;
    //---------------------------------------------------------------
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    //-----------------------------------------------------
    GLsizei sizeForPosition = 
            m_3DTexturePosition->GetWidth() *
            m_3DTexturePosition->GetHeight() *
            m_3DTexturePosition->GetDepth() *
            m_3DTexturePosition->GetInternalFormatNumberOfComponents();
    GLfloat * dataForPosition = new GLfloat[ sizeForPosition ];
    //
    GLsizei sizeForConnectivity = 
            m_3DTextureConnectivity->GetWidth() *
            m_3DTextureConnectivity->GetHeight() *
            m_3DTextureConnectivity->GetDepth() *
            m_3DTextureConnectivity->GetInternalFormatNumberOfComponents();
    GLubyte * dataForConnectivity = new GLubyte[ sizeForConnectivity ];
    //
    {
        int i = 0;
        //=================================================
        // Read data for positions from a texture to memory
        glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        m_3DTexturePosition->BindTexture(0);
        glGetTexImage( 
            m_3DTexturePosition->GetTarget(),
            m_3DTexturePosition->GetLevel(),
            m_3DTexturePosition->GetPixelFormat(),
            m_3DTexturePosition->GetDataType(),
            dataForPosition
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //=================================================
        //=================================================
        // Read data for connectivities from a texture to memory
        glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        m_3DTextureConnectivity->BindTexture(0);
        glGetTexImage( 
            m_3DTextureConnectivity->GetTarget(),
            m_3DTextureConnectivity->GetLevel(),
            m_3DTextureConnectivity->GetPixelFormat(),
            m_3DTextureConnectivity->GetDataType(),
            dataForConnectivity
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //=================================================
    }
    //---------------------------------------------------------------
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //-----------------------------------------------------
    glPopAttrib();
    //---------------------------------------------------------------

    //===============================================================
    // Drawing
    //---------------------------------------------------------------
    // Draw as Spheres
    int count = 0;
    m_OGLUsefulObj.SetColor( 0.1, 0.3, 0.25, 0.25 );
    Vector3<T> vScale( 
        // Ellipsoid touching each other
        //m_vGridDimension[0] / 2.0f, 
        //m_vGridDimension[1] / 2.0f, 
        //m_vGridDimension[2] / 2.0f 

        m_vGridDimension[0] / 4.0f, 
        m_vGridDimension[1] / 4.0f, 
        m_vGridDimension[2] / 4.0f 

        //m_vGridDimension[0] / 8.0f, 
        //m_vGridDimension[1] / 8.0f, 
        //m_vGridDimension[2] / 8.0f 
    );
    //-----------------------------------------------------
    for ( int Z = 0; Z < m_vGridResolution[2]; ++Z ) {
        for ( int Y = 0; Y < m_vGridResolution[1]; ++Y ) {
            for ( int X = 0; X < m_vGridResolution[0]; ++X ) {

                //if ( dataForPosition[count+3] > IC_Thresholds::OUTSIDE_MODEL ) {
                //  glPushMatrix();
                //  glTranslatef( 
                //      dataForPosition[count  ], 
                //      dataForPosition[count+1], 
                //      dataForPosition[count+2] 
                //  );
                //  m_OGLUsefulObj.DrawSphere( vScale );
                //  glPopMatrix();
                //}

                //if ( X == 1 && Y == 1 && Z == 1 ) {
                //  m_OGLUsefulObj.SetColor( 1.0, 0.0, 0.5, 0.25 ); // some what red
                //  glPushMatrix();
                //  glTranslatef( 
                //      dataForPosition[count  ], 
                //      dataForPosition[count+1], 
                //      dataForPosition[count+2] 
                //  );
                //  m_OGLUsefulObj.DrawSphere( vScale );
                //  glPopMatrix();
                //}

                //-------------------------------
                if ( IC_Thresholds::INSIDE_MODEL <= dataForPosition[count+3] ) {
                    m_OGLUsefulObj.SetColor( 0.10, 0.30, 0.50, 0.25 );  // some what blue

                    //*
                    // TWO COLORS FOR TWO CONFIGURATION MC CUBES
                    {
                        int flag = static_cast<int>( dataForPosition[count+3] );
                        flag %= 100;
                        if      ( flag > 0 && flag < 5+1 ) {
                            m_OGLUsefulObj.SetColor( 0.90, 0.90, 0.50, 0.25 );
                        }
                        else if ( flag > 5+1 ) {
                            m_OGLUsefulObj.SetColor( 0.10, 0.90, 0.90, 0.25 );
                        }
                    }
                    //*/

                    glPushMatrix();
                    glTranslatef( 
                        dataForPosition[count  ], 
                        dataForPosition[count+1], 
                        dataForPosition[count+2] 
                    );
                    m_OGLUsefulObj.DrawSphere( vScale );
                    glPopMatrix();
                }
                //-------------------------------
                else if ( IC_Thresholds::RIGHT_INSIDE_BOUNDARY <= dataForPosition[count+3] ) {
                    m_OGLUsefulObj.SetColor( 0.10, 0.30, 0.25, 0.25 );  // some what green

                    //*
                    // TWO COLORS FOR TWO CONFIGURATION MC CUBES
                    {
                        int flag = static_cast<int>( dataForPosition[count+3] );
                        flag %= 100;
                        if      ( flag > 0 && flag < 5+1 ) {
                            m_OGLUsefulObj.SetColor( 0.90, 0.90, 0.25, 0.25 );
                        }
                        else if ( flag > 5+1 ) {
                            m_OGLUsefulObj.SetColor( 0.10, 0.90, 0.90, 0.25 );
                        }
                    }
                    //*/

                    glPushMatrix();
                    glTranslatef( 
                        dataForPosition[count  ], 
                        dataForPosition[count+1], 
                        dataForPosition[count+2] 
                    );
                    m_OGLUsefulObj.DrawSphere( vScale );
                    glPopMatrix();
                }
                //-------------------------------
                else if ( IC_Thresholds::ON_BOUNDARY <= dataForPosition[count+3] ) {
                    m_OGLUsefulObj.SetColor( 0.50, 0.30, 0.10, 0.25 );  // some what yellow
                    glPushMatrix();
                    glTranslatef( 
                        dataForPosition[count  ], 
                        dataForPosition[count+1], 
                        dataForPosition[count+2] 
                    );
                    m_OGLUsefulObj.DrawSphere( vScale * 1.5 );
                    glPopMatrix();
                }
                //-------------------------------
                else if ( IC_Thresholds::RIGHT_OUTSIDE_BOUNDARY <= dataForPosition[count+3] ) {
                    m_OGLUsefulObj.SetColor( 0.50, 0.25, 0.25, 0.25 );  // red
                    glPushMatrix();
                    glTranslatef( 
                        dataForPosition[count  ], 
                        dataForPosition[count+1], 
                        dataForPosition[count+2] 
                    );
                    m_OGLUsefulObj.DrawSphere( vScale );
                    glPopMatrix();
                }
                //-------------------------------
                //else {
                //        m_OGLUsefulObj.SetColor( 0.5, 0.25, 0.25, 0.25 ); // red
                //        glPushMatrix();
                //        glTranslatef( 
                //                dataForPosition[count  ], 
                //                dataForPosition[count+1], 
                //                dataForPosition[count+2] 
                //        );
                //        m_OGLUsefulObj.DrawSphere( vScale / 5 );
                //        glPopMatrix();
                //}
                //-------------------------------
                count += 4;
            }
        }
    }
    //*
    //-------------------------------------------
    // Draw Connections
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glLineWidth( 1 );
    //glLineWidth( 3 );
    glColor3f( 0.9, 1.0, 0.0 );
    glDisable( GL_LIGHTING );
    int idxElementPos = 0;
    int idxElementPos2 = 0;
    int idxElementConnection = 0;
    //int idxConnection = 0;
    int iOffsetSlice = m_vGridResolution[1] * m_vGridResolution[0] * 4;
    int iOffsetRow = m_vGridResolution[0] * 4;
    int iOffsetCol = 4;
    //------------------------------------------------------------------
    glBegin( GL_LINES );

    // DEBUG
    #ifdef TAPs_DEBUG_MODE
    static bool isFirstRun = true;
    #endif // #ifdef TAPs_DEBUG_MODE

    for ( int Z = 0; Z < m_vGridResolution[2]; ++Z ) {
        for ( int Y = 0; Y < m_vGridResolution[1]; ++Y ) {
            for ( int X = 0; X < m_vGridResolution[0]; ++X ) {
                //if ( m_glfpElementPos[idxElementPos + 3] < 450 ) {    // Skip all except an inside element
                //if ( dataForPosition[idxElementPos + 3] < 250 ) { // Skip a void element
                //if (   dataForPosition[idxElementPos + 3] < 250 
                //  && dataForPosition[idxElementPos + 3] > 450 ) {
                //if ( dataForPosition[idxElementPos + 3] < 150 ) { // Skip a void element
                if ( false ) {
                }
                else {
                    //-------------------------------------------------
                    // Identification Numbers (for front, center, and back planes)
                    // from connectionPattern
                    // --------------------------------
                    // |   FRONT    CENTER     BACK   |
                    // | 07 06 05  15 14 13  23 22 21 |
                    // | 04 25 03  12 26 11  20 24 19 |
                    // | 02 01 00  10 09 08  18 17 16 |
                    // --------------------------------
                    //-------------------------------------------------
                    // RGBA Components Represent
                    //  -------------------------------------------
                    // 8-bit ubyte  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
                    //  -------------------------------------------
                    // R --> Front  | NW| N | NE| W | E | SW| S | SE|
                    // G --> Center | NW| N | NE| W | E | SW| S | SE|
                    // B --> Back   | NW| N | NE| W | E | SW| S | SE|
                    // A --> Misc   |   |   |   |   |   | C | F | B |
                    //-------------------------------------------------
                    GLubyte mask = 128;     // 1000 0000
                    GLubyte connectionBits = 0;
                    bool isSet = false;
                    int i = 0;
                    //-------------------------------------------------
                    // FRONT GROUP, without Front connection, == Red component
                    //mask = 128;
                    //idxConnection = idxElementPos;    // Both have the same size


                    // DEBUG
                    #ifdef TAPs_DEBUG_MODE
                    //-----------------------------------------------
                    // Printout Connectivities
                    if ( isFirstRun ) {
                        char id[4] = { 'R', 'G', 'B', 'A' };
                        std::cout << "connectionBits (" << X << "," << Y << "," << Z << ")--> ";
                        if ( 
                            dataForConnectivity[ idxElementPos + 0 ] + 
                            dataForConnectivity[ idxElementPos + 1 ] + 
                            dataForConnectivity[ idxElementPos + 2 ] + 
                            dataForConnectivity[ idxElementPos + 3 ] > 0 ) {
                            for ( int j = 0; j < 4; ++j ) {
                                unsigned char mask = 128;
                                unsigned char contBits = dataForConnectivity[ idxElementPos + j ];
                                std::cout << "\t(" << id[j] << "): ";
                                for ( int i = 0; i < 8; ++i ) {
                                    std::cout << ( mask & contBits ? '1' : '0' );
                                    mask >>= 1;
                                }
                                //std::cout << "\n";
                            }
                        }
                        std::cout << "\n";
                    }
                    //-----------------------------------------------
                    #endif // #ifdef TAPs_DEBUG_MODE


                    // DEBUG 
                    GLubyte color[24] = {
                        255, 0, 0,
                        175, 0, 0,
                        100, 0, 0,
                        0 ,255, 0,
                        0, 100, 0,
                        0, 0, 255,
                        0, 0, 175,
                        0, 0, 100,
                    };

                    int idx = 7;
                    for ( int C = 0; C < 3; ++C ) {
                        mask = 128;     // reset the mask
                        connectionBits = dataForConnectivity[ idxElementPos + C ];
                        if      ( C == 1 ) idx = 15;
                        else if ( C == 2 ) idx = 23;
                        for ( int i = 7; i >= 0; --i, --idx ) {
                            isSet = ( mask & connectionBits ? true : false );
                            connectionBits <<= 1;   // left shift connectionBits by 1 bit
                            //
                            if ( isSet ) {
                                glColor3ubv( &color[i*3] );
                                idxElementPos2 = idxElementPos + m_piConnectionPattern[idx];
                                glVertex3f( 
                                    dataForPosition[idxElementPos    ], 
                                    dataForPosition[idxElementPos + 1], 
                                    dataForPosition[idxElementPos + 2] 
                                );
                                glVertex3f( 
                                    dataForPosition[idxElementPos2    ], 
                                    dataForPosition[idxElementPos2 + 1], 
                                    dataForPosition[idxElementPos2 + 2] 
                                );
                            }
                            //std::cout << "idxElementPos2 for id#" << C*8+i << ": " << idxElementPos2 << std::endl;
                        }
                    }
                    //---------------------------
                    // Misc Connections
                    connectionBits = dataForConnectivity[ idxElementPos + 3 ];
                    //---------------------------
                    // Center
                    //std::cout << "idxElementPos: " << idxElementPos << std::endl;
                    //std::cout << "idxElementPos2 for Center: " << idxElementPos2 << std::endl;
                    //---------------------------
                    // Front
                    mask = 2;
                    isSet = ( mask & connectionBits ? true : false );
                    if ( isSet ) {
                        glColor3ub( 255, 255, 0 );
                        idxElementPos2 = idxElementPos + m_piConnectionPattern[25];
                        glVertex3f( 
                            dataForPosition[idxElementPos    ], 
                            dataForPosition[idxElementPos + 1], 
                            dataForPosition[idxElementPos + 2] 
                        );
                        glVertex3f( 
                            dataForPosition[idxElementPos2    ], 
                            dataForPosition[idxElementPos2 + 1], 
                            dataForPosition[idxElementPos2 + 2] 
                        );
                    }
                    else {
                        ++idx;
                    }
                    //std::cout << "m_piConnectionPattern for Front: " << m_piConnectionPattern[idx] << std::endl;
                    //std::cout << "idxElementPos2 for Front: " << idxElementPos2 << std::endl;
                    //---------------------------
                    // Back
                    mask = 1;
                    isSet = ( mask & connectionBits ? true : false );
                    if ( isSet ) {
                        glColor3ub( 255, 0, 255 );
                        idxElementPos2 = idxElementPos + m_piConnectionPattern[24];
                        glVertex3f( 
                            dataForPosition[idxElementPos    ], 
                            dataForPosition[idxElementPos + 1], 
                            dataForPosition[idxElementPos + 2] 
                        );
                        glVertex3f( 
                            dataForPosition[idxElementPos2    ], 
                            dataForPosition[idxElementPos2 + 1], 
                            dataForPosition[idxElementPos2 + 2] 
                        );
                    }
                    //else {
                    //  ++idx;
                    //}
                    //std::cout << "m_piConnectionPattern for Back: " << m_piConnectionPattern[idx] << std::endl;
                    //std::cout << "idxElementPos2 for Back: " << idxElementPos2 << std::endl;
                    //---------------------------
                }
                //-----------------------------------------
                idxElementPos += 4;
                //-----------------------------------------
            }
        }
    }
    glEnd();
    glPopAttrib();

    //*/
    //---------------------------------------------------------------
    //===============================================================
    delete [] dataForPosition;
    delete [] dataForConnectivity;

    // DEBUG
    #ifdef TAPs_DEBUG_MODE
    isFirstRun = false;
    #endif // #ifdef TAPs_DEBUG_MODE
//*/
}
//-----------------------------------------------------------------------------
// END: DrawByGL_AllElementsWithConnectivities_GPU
//*****************************************************************************


//-----------------------------------------------------------------------------
#endif

// END FNs FOR TAPs_MODEL_DEFORMABLE_USE_TEXTURE_CONNECTIVITY_ONE
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----