TAPsModelDeformableGLSL_Visualization_3DTexture.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsModelDeformableGLSL_Visualization_3DTexture.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (05/12/2007)
UPDATE          (07/21/2007)

******************************************************************************/
#include "TAPsModelDeformableGLSL_Visualization_3DTexture.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
//=============================================================================
//-----------------------------------------------------------------------------
// default constructor
/*
template <typename T>
ModelDeformableGLSL_Visualization_3DTexture<T>::
ModelDeformableGLSL_Visualization_3DTexture () 
: m_SimDomain( NULL )
{
    //---------------------------------------------------------------
    // Since Microsoft gl.h is version 1.1,
    // So this fn calls glewInit() for latest OpenGL version 
    // and initialize GLSL.
    GFnInitGLSL();
    Default();
    //---------------------------------------------------------------
#ifdef  TAPs_DEBUG_MODE
    std::cout << "ModelDeformableGLSL_Visualization_3DTexture<" 
                << typeid(T).name() << "> Constructor\n";
#endif
}
//*/
//-----------------------------------------------------------------------------
// constructor
template <typename T>
ModelDeformableGLSL_Visualization_3DTexture<T>::
ModelDeformableGLSL_Visualization_3DTexture ( 
    ModelDeformableGLSL<T> * simDomain
)
{
    m_SimDomain = simDomain;
    //---------------------------------------------------------------
    // Since Microsoft gl.h is version 1.1,
    // So this fn calls glewInit() for latest OpenGL version 
    // and initialize GLSL.
    GFnInitGLSL();
    Default();
    //---------------------------------------------------------------
#ifdef  TAPs_DEBUG_MODE
    std::cout << "ModelDeformableGLSL_Visualization_3DTexture<" 
                << typeid(T).name() << "> Constructor\n";
#endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Destructor
template <typename T>
ModelDeformableGLSL_Visualization_3DTexture<T>::
~ModelDeformableGLSL_Visualization_3DTexture ()
{
    Clear();
    //---------------------------------------------------------------
#ifdef  TAPs_DEBUG_MODE
    std::cout << "ModelDeformableGLSL_Visualization_3DTexture<" 
                << typeid(T).name() << "> Destructor\n";
#endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Default
template <typename T>
void ModelDeformableGLSL_Visualization_3DTexture<T>::Default ()
{
    //---------------------------------------------------------------
    // For 3D Object-Aligned Slice Draw Direction
    m_glslFBO_v3DObjAlignedSliceDrawDirection           =   0;
    m_glui2DTextureFor3DObjAlignedSliceDrawDirection    =   0;
    //-------------------------------------------
    // For GLSL
    m_glslProgramObjectFor3DTextureDrawDirection    =   NULL;
    m_glslProgramObjectFor3DTextureDrawing          =   NULL;
    //-------------------------------------------
    // For Textures
    m_3DTextureVisualization    =   NULL;
    m_1DTextureTransferFnLUT    =   NULL;
    //-------------------------------------------
}
//-----------------------------------------------------------------------------
// Clear
template <typename T>
void ModelDeformableGLSL_Visualization_3DTexture<T>::Clear ()
{
    //---------------------------------------------------------------
    // Delete Stuff for 3D Object-Aligned Slice Draw Direction
    if ( m_glslFBO_v3DObjAlignedSliceDrawDirection > 0 ) {
        glDeleteFramebuffersEXT( 1, &m_glslFBO_v3DObjAlignedSliceDrawDirection );
    }
    if ( m_glui2DTextureFor3DObjAlignedSliceDrawDirection > 0 ) {
        glDeleteTextures( 1, &m_glui2DTextureFor3DObjAlignedSliceDrawDirection );
    }
    //---------------------------------------------------------------
    // Clear GLSL
    if ( m_glslProgramObjectFor3DTextureDrawDirection ) {
        m_glslShaderManager.Delete( m_glslProgramObjectFor3DTextureDrawDirection );
    }
    if ( m_glslProgramObjectFor3DTextureDrawing ) {
        m_glslShaderManager.Delete( m_glslProgramObjectFor3DTextureDrawing );
    }
    //---------------------------------------------------------------
    // Clear Textures
    if ( m_3DTextureVisualization ) delete m_3DTextureVisualization;
    if ( m_1DTextureTransferFnLUT ) delete m_1DTextureTransferFnLUT;
    //---------------------------------------------------------------
    Default();
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// For Drawing (3D) Object-Aligned Slices
//-----------------------------------------------------------------------------
template <typename T>
bool ModelDeformableGLSL_Visualization_3DTexture<T>::
SetupFBOAndTextureForAlignedSliceDrawDirection ()
{
    const int width  = 1;
    const int height = 1;
    //---------------------------------------------------------------
    // Setup 2D Texture for 3D Object-Aligned Slice Draw Direction
    glGenTextures( 1, &m_glui2DTextureFor3DObjAlignedSliceDrawDirection );
    if ( m_glui2DTextureFor3DObjAlignedSliceDrawDirection == 0 ) {
        assert( false );
        Clear();
        return false;
    }
    GLfloat data_2D[width*height*4];
    //
    glBindTexture( GL_TEXTURE_2D, m_glui2DTextureFor3DObjAlignedSliceDrawDirection );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
    glTexImage2D( 
        GL_TEXTURE_2D,          // target
        0,                      // level
        GL_RGBA32F_ARB,         // internal format
        width,                  // width
        height,                 // height
        0,                      // border
        GL_RGBA,                // pixel format
        GL_FLOAT,               // data type
        data_2D                 // texels
    );
    glBindTexture( GL_TEXTURE_2D, 0 );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //-----------------------
    // For 3D Object-Aligned Slice Draw Direction
    //-----------------------
    glGenFramebuffersEXT( 1, &m_glslFBO_v3DObjAlignedSliceDrawDirection );
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_glslFBO_v3DObjAlignedSliceDrawDirection );
    glFramebufferTexture2DEXT(
        GL_FRAMEBUFFER_EXT,                     // target
        GL_COLOR_ATTACHMENT0_EXT,               // attached frame
        GL_TEXTURE_2D,                          // texture target
        m_glui2DTextureFor3DObjAlignedSliceDrawDirection,   // texture id
        0                                       // level
    );
    TAPs::OpenGL::Fn::CHECK_FRAMEBUFFER_STATUS();
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //---------------------------------
    return true;
}
//-----------------------------------------------------------------------------
// END: SetupFBOAndTextureForAlignedSliceDrawDirection
//=============================================================================

//=============================================================================
// Setup Shaders for Drawing (3D) Object-Aligned Slices
//-----------------------------------------------------------------------------
template <typename T>
bool ModelDeformableGLSL_Visualization_3DTexture<T>::
SetupShadersFor3DTextureDrawDirectionAndDrawing ()
{
    // Draw Direction
    m_glslProgramObjectFor3DTextureDrawDirection = 
        m_glslShaderManager.LoadOnlyAFragmentShaderFromFile(
            "Resource/Shader/DefModelGetObjAlignedDrawDirection.frag"
    );
    if ( !m_glslProgramObjectFor3DTextureDrawDirection ) {
        Clear();
        return false;
    }
    // 3D Texture Drawing
    m_glslProgramObjectFor3DTextureDrawing = 
        m_glslShaderManager.LoadFromFile(
            "Resource/Shader/DefModelDraw3DTextureObjAligned.vert",
            "Resource/Shader/DefModelDraw3DTextureObjAligned.frag"
    );
    if ( !m_glslProgramObjectFor3DTextureDrawing ) {
        Clear();
        return false;
    }
    return true;
}
//-----------------------------------------------------------------------------
// END: SetupShadersFor3DTextureDrawDirectionAndDrawing
//=============================================================================

//=============================================================================
// Setup a 1D Texture for Transfer Function Lookup Table
//-----------------------------------------------------------------------------
template <typename T>
bool ModelDeformableGLSL_Visualization_3DTexture<T>::
Setup1DTextureForTransferFnLUT ()
{
    //---------------------------------------------------------------
    // Create dataRGBA
    //GLubyte dataRGBA[256][4];
    GLfloat dataRGBA[256][4];
    //---------------------------------
    for ( int i = 0; i < 256; ++i ) {

        dataRGBA[i][0] = 0.75 + (GLfloat)rand() / (GLfloat)RAND_MAX * 0.05;
        dataRGBA[i][1] = 0.73 + (GLfloat)rand() / (GLfloat)RAND_MAX * 0.05;
        dataRGBA[i][2] = 0.61 + (GLfloat)rand() / (GLfloat)RAND_MAX * 0.05;
        dataRGBA[i][3] = i / 255.0;

        //dataRGBA[i][0] = 0.0;
        //dataRGBA[i][1] = 1.0;
        //dataRGBA[i][2] = 0.5;
        //dataRGBA[i][3] = 1.0;
    }
    //---------------------------------------------------------------
    // Setup 1D Texture
    //---------------------------------
    glEnable( GL_TEXTURE_1D );
    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND );
    m_1DTextureTransferFnLUT = new Texture( 
        GL_TEXTURE_1D,          // target
        0,                      // level
        GL_RGBA,                // internal format
        256,                    // width
        0,                      // border
        GL_RGBA,                // pixel format
        //GL_UNSIGNED_BYTE,     // data type
        GL_FLOAT,               // data type
        dataRGBA,               // texels
        1,                      // number of textures
        GL_LINEAR,              // Mag Filter
        GL_LINEAR,              // Min Filter
        GL_CLAMP                // Wrap S
    );
    if ( !m_1DTextureTransferFnLUT ) {
        assert( false );
        Clear();
        return false;
    }
    //---------------------------------
    m_1DTextureTransferFnLUT->BindTexture(0);
    glDisable( GL_TEXTURE_1D );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //---------------------------------------------------------------
    return true;
}
//-----------------------------------------------------------------------------
// END: Setup1DTextureForTransferFnLUT
//=============================================================================

//=============================================================================
// Setup a 3D Texture for Visualization
//-----------------------------------------------------------------------------
template <typename T>
bool ModelDeformableGLSL_Visualization_3DTexture<T>::
Setup3DTextureForVisualization ( 
    int resolutionX, int resolutionY, int resolutionZ, 
    enum GridGenerator<T>::VertexFlag *** pFlagDataForXYZVoxels
)
{
    //---------------------------------------------------------------
    // Set Texture Parameters
    GLenum      target          = GL_TEXTURE_3D;
    GLint       level           = 0;
    GLint       internalFormat  = GL_RGBA;
    //GLint     internalFormat  = GL_RGBA32F_ARB;
    GLsizei     width           = resolutionX;
    GLsizei     height          = resolutionY;
    GLsizei     depth           = resolutionZ;
    GLint       border          = 0;
    GLenum      pixelFormat     = GL_RGBA;
    //GLenum    dataType        = GL_UNSIGNED_BYTE;
    GLenum      dataType        = GL_FLOAT;
    //---------------------------------------------------------------
    // Setup Data for 3D Texture
    int iElementRGBALength = resolutionX * resolutionY * resolutionZ * 4;
    //===============================================================
    // Data from pGridGenerator is arrenged in x, y, and z order.
    // Switch it to z, y, and x order for ordering planes in z-direction.
    //---------------------------------------------------------------
    // Unsigned Byte (Char) Data Type
    if ( dataType == GL_UNSIGNED_BYTE ) {
        GLubyte * dataRGBA = new GLubyte[ iElementRGBALength ];
        int m = 0;
        for ( int k = 0; k < resolutionZ; ++k ) {

            //unsigned char alpha1 = 254 / resolutionZ;
            //unsigned char alpha2 = 510 / resolutionZ;

            //unsigned char alpha1 = 254 / resolutionZ * 3;
            //unsigned char alpha2 = 510 / resolutionZ * 3;

            unsigned char alpha1 = 254;
            unsigned char alpha2 = 254;
            bool useAssociatedColors = false;

            for ( int j = 0; j < resolutionY; ++j ) {
                for ( int i = 0; i < resolutionX; ++i ) {
                    if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::INSIDE_MODEL ) {
                        dataRGBA[m  ] = 255;
                        dataRGBA[m+1] = 255;
                        dataRGBA[m+2] = 0;
                        dataRGBA[m+3] = alpha1;
                    }
                    else if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::RIGHT_INSIDE_BOUNDARY ) {
                        dataRGBA[m  ] = 0;
                        dataRGBA[m+1] = 120;
                        dataRGBA[m+2] = 0;
                        dataRGBA[m  ] += i;
                        dataRGBA[m+1] += j;
                        dataRGBA[m+2] += k;
                        dataRGBA[m+3] = alpha2;
                        //dataRGBA[m+3] = (double)rand() / (double)RAND_MAX * 254 + 1;
                    }
                    else if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::ON_BOUNDARY ) {
                        dataRGBA[m  ] = 0;
                        dataRGBA[m+1] = 0;
                        //dataRGBA[m+2] = 1;
                        //dataRGBA[m+3] = alpha2;
                        dataRGBA[m+2] = 0;
                        dataRGBA[m+3] = 0;
                    }
                    else if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::RIGHT_OUTSIDE_BOUNDARY ) {
                        dataRGBA[m  ] = 0;
                        dataRGBA[m+1] = 0;
                        dataRGBA[m+2] = 0;
                        //dataRGBA[m+3] = 1;
                        dataRGBA[m+3] = 0;
                    }
                    else {
                        dataRGBA[m  ] = 0;
                        dataRGBA[m+1] = 0;
                        dataRGBA[m+2] = 0;
                        dataRGBA[m+3] = 0;
                    }
                    //-------------------------------
                    if ( useAssociatedColors ) {
                        dataRGBA[m  ] *= dataRGBA[m+3];
                        dataRGBA[m+1] *= dataRGBA[m+3];
                        dataRGBA[m+2] *= dataRGBA[m+3];
                    }
                    //-------------------------------
                    m += 4;
                }
            }
        }
        //-------------------------------------------------
        // Setup 3D Texture
        //---------------------------------
        glEnable( GL_TEXTURE_3D );
        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND );
        m_3DTextureVisualization = new Texture( 
            target, level, internalFormat, 
            width, height, depth, 
            border, pixelFormat,                
            dataType, 
            dataRGBA,                       // texels
            1,                              // number of textures
            GL_LINEAR, GL_LINEAR,           // mag and min filter
            GL_CLAMP, GL_CLAMP, GL_CLAMP    // wrap s, t, and r
        );
        m_3DTextureVisualization->UnbindTexture();
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        delete [] dataRGBA;
    }
    //
    //---------------------------------------------------------------
    // Float Data Type
    else if ( dataType == GL_FLOAT ) {
        GLfloat * dataRGBA = new GLfloat[ iElementRGBALength ];
        int m = 0;
        for ( int k = 0; k < resolutionZ; ++k ) {

            //float alpha1 = 1.0 / resolutionZ;
            //float alpha2 = 2.0 / resolutionZ;

            //float alpha1 = 1.0 / resolutionZ * 3;
            //float alpha2 = 2.0 / resolutionZ * 3;

            // Can't set to any value greater than 254.0/255.0.
            // Otherwise, the transfer function lookup will not get a correct value.
            // This error is about texture coordinate out of range.
            float alpha1 = 0.995;
            float alpha2 = 0.995;
            bool useAssociatedColors = false;

            for ( int j = 0; j < resolutionY; ++j ) {
                for ( int i = 0; i < resolutionX; ++i ) {
                    if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::INSIDE_MODEL ) {
                        dataRGBA[m  ] = 1;
                        dataRGBA[m+1] = 1;
                        dataRGBA[m+2] = 0;
                        dataRGBA[m+3] = alpha1;
                    }
                    else if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::RIGHT_INSIDE_BOUNDARY ) {
                        //dataRGBA[m  ] = 0.5;
                        //dataRGBA[m+1] = 0.5;
                        //dataRGBA[m+2] = 0.5;
                        dataRGBA[m  ] = 0.0;
                        dataRGBA[m+1] = 0.5;
                        dataRGBA[m+2] = 0.0;
                        
                        //dataRGBA[m  ] += (float)i/resolutionX;
                        //dataRGBA[m+1] += (float)j/resolutionY;
                        //dataRGBA[m+2] += (float)k/resolutionZ;
                        dataRGBA[m+3] = alpha2;

//                      dataRGBA[m  ] += (double)rand() / (double)RAND_MAX;
//                      dataRGBA[m+1] += (double)rand() / (double)RAND_MAX;
//                      dataRGBA[m+2] += (double)rand() / (double)RAND_MAX;
                        //dataRGBA[m+3] = (double)rand() / (double)RAND_MAX + 0.5;
                        if ( dataRGBA[m  ] > 1.0f ) dataRGBA[m  ] = 1.0f;
                        if ( dataRGBA[m+1] > 1.0f ) dataRGBA[m+1] = 1.0f;
                        if ( dataRGBA[m+2] > 1.0f ) dataRGBA[m+2] = 1.0f;
                        if ( dataRGBA[m+3] > 1.0f ) dataRGBA[m+3] = 1.0f;
                        //dataRGBA[m+3] = i;
                    }
                    else if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::ON_BOUNDARY ) {
                        dataRGBA[m  ] = 0;
                        dataRGBA[m+1] = 0;
                        //dataRGBA[m+2] = 1;
                        //dataRGBA[m+3] = alpha2;
                        dataRGBA[m+2] = 0;
                        dataRGBA[m+3] = 0;
                    }
                    else if ( pFlagDataForXYZVoxels[i][j][k] >= GridGenerator<T>::RIGHT_OUTSIDE_BOUNDARY ) {
                        dataRGBA[m  ] = 0;
                        dataRGBA[m+1] = 0;
                        dataRGBA[m+2] = 0;
                        //dataRGBA[m+3] = 0.001;
                        dataRGBA[m+3] = 0.0;
                        //dataRGBA[m+3] = 1.0;  // DEBUG
                    }
                    else {
                        dataRGBA[m  ] = 0;
                        dataRGBA[m+1] = 0;
                        dataRGBA[m+2] = 0;
                        dataRGBA[m+3] = 0;
                    }
                    //-------------------------------
                    if ( useAssociatedColors ) {
                        dataRGBA[m  ] *= dataRGBA[m+3];
                        dataRGBA[m+1] *= dataRGBA[m+3];
                        dataRGBA[m+2] *= dataRGBA[m+3];
                    }
                    //-------------------------------
                    m += 4;
                }
            }
        }
        //-------------------------------------------------
        // Setup 3D Texture
        //---------------------------------
        glEnable( GL_TEXTURE_3D );
        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND );
        m_3DTextureVisualization = new Texture( 
            target, level, internalFormat, 
            width, height, depth, 
            border, pixelFormat,                
            dataType, 
            dataRGBA,                       // texels
            1,                              // number of textures
            GL_LINEAR, GL_LINEAR,           // mag and min filter
            GL_CLAMP, GL_CLAMP, GL_CLAMP    // wrap s, t, and r
        );
        m_3DTextureVisualization->UnbindTexture();
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        delete [] dataRGBA;
    }
    //
    //---------------------------------------------------------------
    // Unsupported Data Type!
    else {
        std::cerr << "The data type of m_3DTextureVisualizationParameters is not supported!" << std::endl;
        assert( false );
        Clear();
        return false;
    }
    //---------------------------------------------------------------
    return true;
}
//-----------------------------------------------------------------------------
// END: Setup3DTextureForVisualization
//=============================================================================

//=============================================================================
// CalAndRecordFreqsOfHistogramRange_0_255_ToArray
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL_Visualization_3DTexture<T>::
CalAndRecordFreqsOfHistogramRange_0_255_ToArray ( 
    GLubyte freqs[256] )
{
    if ( !m_3DTextureVisualization ) {
        assert( false );
        return;
    }
    //===============================================================
    // Read data from GPU
    //---------------------------------------------------------------
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    //-----------------------------------------------------
    GLsizei sizeForVisual = 
            m_3DTextureVisualization->GetWidth() *
            m_3DTextureVisualization->GetHeight() *
            m_3DTextureVisualization->GetDepth() *
            m_3DTextureVisualization->GetInternalFormatNumberOfComponents();
    GLfloat * dataForVisual = new GLfloat[ sizeForVisual ];
    {
        //=================================================
        // Read data for positions from a texture to memory
        glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        m_3DTextureVisualization->BindTexture(0);
        glGetTexImage( 
            m_3DTextureVisualization->GetTarget(),
            m_3DTextureVisualization->GetLevel(),
            m_3DTextureVisualization->GetPixelFormat(),
            m_3DTextureVisualization->GetDataType(),
            dataForVisual
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //=================================================
    }
    //---------------------------------------------------------------
    glPopAttrib();
    //---------------------------------------------------------------
    //===============================================================
    //---------------------------------------------------------------
    // Calculate and Record the 256 frequencies for histogram to the input array
    for ( int f = 0; f < 256; ++f ) {
        freqs[f] = 0;
    }
    GLubyte idx;
    for ( int i = 3; i < sizeForVisual; i+=4 ) {
        double D = dataForVisual[i] * 255.0;
        int I    = (int) D;
        if ( D-I >= 0.5 )   idx = I+1;
        else                idx = I;
        if ( idx > 255 )    idx = 255;
        else if ( idx < 0 ) idx = 0;
        ++freqs[idx];
    }

    #ifdef  TAPs_DEBUG_MODE
    for ( int f = 0; f < 256; ++f ) {
        std::cout << "freqs[" << f << "]: " << (int)freqs[f] << "\n";
    }
    #endif//TAPs_DEBUG_MODE

    //---------------------------------------------------------------
    delete [] dataForVisual;
}
//-----------------------------------------------------------------------------
// END: CalAndRecordFreqsOfHistogramRange_0_255_ToArray
//=============================================================================

//=============================================================================
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
/*
template <typename T>
void ModelDeformableGLSL<T>::DrawByGL_3DTexture ( DrawType drawType )
{
    static int iMaxNumberOfSlices = 512;
    //---------------------------------------------------------------
#ifdef TAPs_DEBUG_MODE
    if ( !m_SimDomain ) return;
    //---------------------------------------------------------------
    if ( !m_SimDomain->RetObject3DTexturePosition() )   return;
    //---------------------------------------------------------------
    if ( !m_glslProgramObjectFor3DTextureDrawDirection )    return;
    //---------------------------------------------------------------
    if ( !m_glslProgramObjectFor3DTextureDrawing )  return;
    //---------------------------------------------------------------
    if ( !m_3DTextureVisualization )    return;
#endif
    //---------------------------------------------------------------
    // Find direction to the eye view
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glEnable( GL_TEXTURE_2D );
    m_glslProgramObject->BeginGLSL();
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_glslFBO_v3DObjAlignedSliceDrawDirection );
    TAPs::OpenGL::Fn::CHECK_FRAMEBUFFER_STATUS();
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //
    //GLfloat modelViewMatrix[16];
    //
    {
        //-------------------------------------------------
        glMatrixMode( GL_PROJECTION );
        glPushMatrix();
        glLoadIdentity();
        gluOrtho2D( 0, 1, 0, 1 );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //
        // Load Model View Matrix
        glMatrixMode( GL_MODELVIEW );
        glPushMatrix();
        //glGetFloatv( GL_MODELVIEW_MATRIX, modelViewMatrix );
        //glLoadmatrixf( modelViewMatrix );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //
        // Only one pixel is needed to get the inverse transpose of modelview matrix
        glViewport( 0, 0, 1, 1 );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        {
            glEnable( GL_TEXTURE_2D );
            glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_glslFBO_v3DObjAlignedSliceDrawDirection );
            glFramebufferTexture2DEXT(
                GL_FRAMEBUFFER_EXT,                     // target
                GL_COLOR_ATTACHMENT0_EXT,               // attached frame
                GL_TEXTURE_2D,                          // texture target
                m_glui2DTextureFor3DObjAlignedSliceDrawDirection,   // texture id
                0                                       // level
            );
            glDrawBuffer( GL_COLOR_ATTACHMENT0_EXT );
            TAPs::OpenGL::Fn::CHECK_FRAMEBUFFER_STATUS();
            TAPs::OpenGL::Fn::CHECK_GL_ERROR();
            glClearColor( 0, 0, 0, 0 );
            glDisable( GL_DEPTH_TEST );
            glClear( GL_COLOR_BUFFER_BIT );
            glPolygonMode( GL_FRONT, GL_FILL );
            glBegin( GL_POINTS );
                glVertex3f( 0, 0, 0 );
            glEnd();
        }
        glPopMatrix();
        glMatrixMode( GL_PROJECTION );
        glPopMatrix();
        glMatrixMode( GL_MODELVIEW );
    }
    glDisable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, 0 );
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
    m_glslProgramObject->EndGLSL();
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    glPopAttrib();
    //
    //===========================================
    // Read drawing direction from the texture
    const int width = 1, height = 1;
    GLfloat drawDir[width*height*4];
    glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
    glBindTexture( GL_TEXTURE_2D, m_glui2DTextureFor3DObjAlignedSliceDrawDirection );
    glGetTexImage( 
        GL_TEXTURE_2D,
        0,
        GL_RGBA,
        GL_FLOAT,
        drawDir
    );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //-------------------------------------------
    // Find the draw direction
    //   The draw direction is the data with maximum absolute value.
    GLfloat absDrawDir[3] = { fabs( drawDir[0] ), fabs( drawDir[1] ), fabs( drawDir[2] ) };
    int iDrawDir = 0;       // X: -1,1; Y: -2,2; Z: -3,3
    if ( absDrawDir[0] > absDrawDir[1] ) {
        if ( absDrawDir[0] > absDrawDir[2] ) {
            if ( drawDir[0] > 0.0f )    iDrawDir =  1;
            else                        iDrawDir = -1;
        }
        else {
            if ( drawDir[2] > 0.0f )    iDrawDir =  3;
            else                        iDrawDir = -3;
        }
    }
    else {
        if ( absDrawDir[1] > absDrawDir[2] ) {
            if ( drawDir[1] > 0.0f )    iDrawDir =  2;
            else                        iDrawDir = -2;
        }
        else {
            if ( drawDir[2] > 0.0f )    iDrawDir =  3;
            else                        iDrawDir = -3;
        }
    }
    //=================================================

    //GLfloat pModelViewMatrix[16];
    //GLfloat pModelViewMatrixInv[16];
    //glGetFloatv( GL_MODELVIEW_MATRIX, pModelViewMatrix );
    //InverseMatrix( pModelViewMatrix, pModelViewMatrixInv );
    //GLfloat pViewVector[4] = { 0.0f, 0.0f, -1.0f, 0.0f };
    //MatVecMultiply( pModelViewMatrixInv, pViewVector );
    //int nMax = FindAbsMaximum( pViewVector );
    //switch ( nMax ) {
    //case X:
    //  if ( pViewVector[X] > 0.0f ) {
    //      DrawSliceStack_PositiveX();
    //  }
    //  else {
    //      DrawSliceStack_NagativeX();
    //  }
    //  break;
    //case Y:
    //  if ( pViewVector[Y] > 0.0f ) {
    //      DrawSliceStack_PositiveY();
    //  }
    //  else {
    //      DrawSliceStack_NagativeY();
    //  }
    //  break;
    //case Z:
    //  if ( pViewVector[Z] > 0.0f ) {
    //      DrawSliceStack_PositiveZ();
    //  }
    //  else {
    //      DrawSliceStack_NagativeZ();
    //  }
    //  break;
    //}

    //---------------------------------------------------------------
    // Draw The 3D Texture
//  if ( m_glui3DTextureForVisualization ) {
    if ( m_3DTextureVisualization ) {
        glPushAttrib( GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT );
        glEnable( GL_LIGHTING );
        glEnable( GL_COLOR_MATERIAL );
        glColor3f( 0.15, 0.45, 0.53 );
        glEnable( GL_BLEND );
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        glActiveTexture( GL_TEXTURE0 );
        m_3DTextureVisualization->EnableTextureTarget();
        m_3DTextureVisualization->BindTexture(0);
        m_3DTextureVisualization->UseParameters();
        Vector3<T> vAABBMinPt = GetBoundingAABBLowPoint();
        Vector3<T> vAABBMaxPt = GetBoundingAABBHighPoint();
        //-----------------------------------------------------------
        int iSubdivision = 8;
        int iAxis;
        glBegin( GL_QUADS );
        //-----------------------------------------------------------
        // DrawSliceStack_NegativeZ();  // back-to-front is from -z to +z
        if ( iDrawDir == -3 ) {
            iAxis = 2;
            T zValue = vAABBMinPt[iAxis];
            T numberOfSlices = m_vGridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 0;
            T tStep  = 1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( 0, 0, tValue );
                glNormal3f( 0, 0, 1 );
                glVertex3f( vAABBMinPt[0], vAABBMinPt[1], zValue );
                //
                glTexCoord3f( 1, 0, tValue );
                glNormal3f( 0, 0, 1 );
                glVertex3f( vAABBMaxPt[0], vAABBMinPt[1], zValue );
                //
                glTexCoord3f( 1, 1, tValue );
                glNormal3f( 0, 0, 1 );
                glVertex3f( vAABBMaxPt[0], vAABBMaxPt[1], zValue );
                //
                glTexCoord3f( 0, 1, tValue );
                glNormal3f( 0, 0, 1 );
                glVertex3f( vAABBMinPt[0], vAABBMaxPt[1], zValue );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_NegativeX();  // back-to-front is from -x to +x
        else if ( iDrawDir == -1 ) {
            iAxis = 0;
            T zValue = vAABBMinPt[iAxis];
            T numberOfSlices = m_vGridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 0;
            T tStep  = 1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( tValue, 0, 1 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMaxPt[2] );
                //
                glTexCoord3f( tValue, 0, 0 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMinPt[2] );
                //
                glTexCoord3f( tValue, 1, 0 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMinPt[2] );
                //
                glTexCoord3f( tValue, 1, 1 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMaxPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_NegativeY();  // back-to-front is from -y to +y
        else if ( iDrawDir == -2 ) {
            iAxis = 1;
            T zValue = vAABBMinPt[iAxis];
            T numberOfSlices = m_vGridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 0;
            T tStep  = 1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( 0, tValue, 1 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMaxPt[2] );
                //
                glTexCoord3f( 1, tValue, 1 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMaxPt[2] );
                //
                glTexCoord3f( 1, tValue, 0 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMinPt[2] );
                //
                glTexCoord3f( 0, tValue, 0 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMinPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_PositiveZ();  // back-to-front is from +z to -z
        else if ( iDrawDir == 3 ) {
            iAxis = 2;
            T zValue = vAABBMaxPt[iAxis];
            T numberOfSlices = m_vGridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 1.0;
            T tStep  = -1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( 0, 0, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMinPt[0], vAABBMinPt[1], zValue );
                //
                glTexCoord3f( 0, 1, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMinPt[0], vAABBMaxPt[1], zValue );
                //
                glTexCoord3f( 1, 1, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMaxPt[0], vAABBMaxPt[1], zValue );
                //
                glTexCoord3f( 1, 0, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMaxPt[0], vAABBMinPt[1], zValue );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_PositiveX();  // back-to-front is from +x to -x
        else if ( iDrawDir == 1 ) {
            iAxis = 0;
            T zValue = vAABBMaxPt[iAxis];
            T numberOfSlices = m_vGridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 1.0;
            T tStep  = -1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( tValue, 0, 0 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMinPt[2] );
                //
                glTexCoord3f( tValue, 0, 1 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMaxPt[2] );
                //
                glTexCoord3f( tValue, 1, 1 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMaxPt[2] );
                //
                glTexCoord3f( tValue, 1, 0 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMinPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_PositiveY();  // back-to-front is from +y to -y
        else if ( iDrawDir == 2 ) {
            iAxis = 1;
            T zValue = vAABBMaxPt[iAxis];
            T numberOfSlices = m_vGridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 1.0;
            T tStep  = -1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( 0, tValue, 1 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMaxPt[2] );
                //
                glTexCoord3f( 0, tValue, 0 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMinPt[2] );
                //
                glTexCoord3f( 1, tValue, 0 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMinPt[2] );
                //
                glTexCoord3f( 1, tValue, 1 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMaxPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        glEnd();
        glBindTexture( GL_TEXTURE_3D, 0 );
        glPopAttrib();
    }
}
//*/
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// DrawByGL (Using 3D Texture)
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL_Visualization_3DTexture<T>::
DrawByGL ( int iSubdivision )
{
    static int iMaxNumberOfSlices = 512;
    //---------------------------------------------------------------
#ifdef TAPs_DEBUG_MODE
    if ( !m_SimDomain ) return;
    //---------------------------------------------------------------
    if ( !m_SimDomain->RetObject3DTexturePosition() )   return;
    //---------------------------------------------------------------
    if ( !m_glslProgramObjectFor3DTextureDrawDirection )    return;
    //---------------------------------------------------------------
    if ( !m_glslProgramObjectFor3DTextureDrawing )  return;
    //---------------------------------------------------------------
    if ( !m_3DTextureVisualization )    return;
#endif
    //---------------------------------------------------------------
    //===============================================================
    // Read data from GPU
    //---------------------------------------------------------------
    Texture * texture3DPosition     = m_SimDomain->RetObject3DTexturePosition();
    Texture * texture3DConnectivity = m_SimDomain->RetObject3DTextureConnectivity();
    //---------------------------------------------------------------
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    //-----------------------------------------------------
    GLsizei sizeForPosition = 
            texture3DPosition->GetWidth() *
            texture3DPosition->GetHeight() *
            texture3DPosition->GetDepth() *
            texture3DPosition->GetInternalFormatNumberOfComponents();
    GLfloat * dataForPosition = new GLfloat[ sizeForPosition ];
    //
    //GLsizei sizeForConnectivity = 
    //      texture3DConnectivity->GetWidth() *
    //      texture3DConnectivity->GetHeight() *
    //      texture3DConnectivity->GetDepth() *
    //      texture3DConnectivity->GetInternalFormatNumberOfComponents();
    //GLfloat * dataForConnectivity = new GLfloat[ sizeForConnectivity ];
    //
    {
        int i = 0;
        //=================================================
        // Read data for positions from a texture to memory
        glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        texture3DPosition->BindTexture(0);
        glGetTexImage( 
            texture3DPosition->GetTarget(),
            texture3DPosition->GetLevel(),
            texture3DPosition->GetPixelFormat(),
            texture3DPosition->GetDataType(),
            dataForPosition
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //=================================================
        //=================================================
        // Read data for connectivities from a texture to memory
        //glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        //texture3DConnectivity->BindTexture(0);
        //glGetTexImage( 
        //  texture3DConnectivity->GetTarget(),
        //  texture3DConnectivity->GetLevel(),
        //  texture3DConnectivity->GetPixelFormat(),
        //  texture3DConnectivity->GetDataType(),
        //  dataForConnectivity
        //);
        //TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //=================================================
    }
    //---------------------------------------------------------------
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //-----------------------------------------------------
    glPopAttrib();
    //---------------------------------------------------------------
    //===============================================================

    //---------------------------------------------------------------
    // Find direction to the eye view
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glEnable( GL_TEXTURE_2D );
    m_glslProgramObjectFor3DTextureDrawDirection->BeginGLSL();
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_glslFBO_v3DObjAlignedSliceDrawDirection );
    TAPs::OpenGL::Fn::CHECK_FRAMEBUFFER_STATUS();
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    {
        //-------------------------------------------------
        glMatrixMode( GL_PROJECTION );
        glPushMatrix();
        glLoadIdentity();
        glOrtho( -1000000, 1000000, -1000000, 1000000, -1000000, 1000000 );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //
        // Load Model View Matrix
        glMatrixMode( GL_MODELVIEW );
        glPushMatrix();
        //glGetFloatv( GL_MODELVIEW_MATRIX, modelViewMatrix );
        //glLoadmatrixf( modelViewMatrix );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //
        // Only one pixel is needed to get the inverse transpose of modelview matrix
        glViewport( 0, 0, 1, 1 );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        {
            //glEnable( GL_TEXTURE_2D );
            glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_glslFBO_v3DObjAlignedSliceDrawDirection );
            glFramebufferTexture2DEXT(
                GL_FRAMEBUFFER_EXT,                     // target
                GL_COLOR_ATTACHMENT0_EXT,               // attached frame
                GL_TEXTURE_2D,                          // texture target
                m_glui2DTextureFor3DObjAlignedSliceDrawDirection,   // texture id
                0                                       // level
            );
            glDrawBuffer( GL_COLOR_ATTACHMENT0_EXT );
            TAPs::OpenGL::Fn::CHECK_FRAMEBUFFER_STATUS();
            TAPs::OpenGL::Fn::CHECK_GL_ERROR();
            glClearColor( 0, 0, 0, 0 );
            glDisable( GL_DEPTH_TEST );
            glClear( GL_COLOR_BUFFER_BIT );
            glPolygonMode( GL_FRONT, GL_FILL );
            glBegin( GL_POINTS );
                glVertex3f( 0, 0, 0 );
            glEnd();
        }
        glPopMatrix();
        glMatrixMode( GL_PROJECTION );
        glPopMatrix();
        glMatrixMode( GL_MODELVIEW );
    }
    glDisable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, 0 );
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
    m_glslProgramObjectFor3DTextureDrawDirection->EndGLSL();
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    glPopAttrib();
    //
    //===========================================
    // Read drawing direction from the texture
    const int width = 1, height = 1;
    GLfloat drawDir[width*height*4];
    glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
    glBindTexture( GL_TEXTURE_2D, m_glui2DTextureFor3DObjAlignedSliceDrawDirection );
    glGetTexImage( 
        GL_TEXTURE_2D,
        0,
        GL_RGBA,
        GL_FLOAT,
        drawDir
    );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //-------------------------------------------
    // Find the draw direction
    //   The draw direction is the data with maximum absolute value.
    GLfloat absDrawDir[3] = { fabs( drawDir[0] ), fabs( drawDir[1] ), fabs( drawDir[2] ) };
    int iDrawDir = 0;       // X: -1,1; Y: -2,2; Z: -3,3
    if ( absDrawDir[0] > absDrawDir[1] ) {
        if ( absDrawDir[0] > absDrawDir[2] ) {
            if ( drawDir[0] > 0.0f )    iDrawDir =  1;
            else                        iDrawDir = -1;
        }
        else {
            if ( drawDir[2] > 0.0f )    iDrawDir =  3;
            else                        iDrawDir = -3;
        }
    }
    else {
        if ( absDrawDir[1] > absDrawDir[2] ) {
            if ( drawDir[1] > 0.0f )    iDrawDir =  2;
            else                        iDrawDir = -2;
        }
        else {
            if ( drawDir[2] > 0.0f )    iDrawDir =  3;
            else                        iDrawDir = -3;
        }
    }
    //=================================================
    //-------------------------------------------------
    // Draw The 3D Texture -- DrawByGL_Using3DTexture
    if ( m_3DTextureVisualization ) {
        glPushAttrib( GL_ALL_ATTRIB_BITS );
        //glPushAttrib( GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT );
        //glDisable( GL_LIGHTING );
        glEnable( GL_LIGHTING );
        //glEnable( GL_COLOR_MATERIAL );
        //glColor3f( 0.75, 0.75, 0.75 );
        //---------------------------------------
        // Set Color Material
        GLfloat vAmbient[4]   = { 0.2, 0.2, 0.2, 1.0 };
        GLfloat vDiffuse[4]   = { 0.8, 0.8, 0.8, 1.0 };
        GLfloat vSpecular[4]  = { 0.2, 0.2, 0.2, 1.0 };
        GLfloat vEmission[4]  = { 0.0, 0.0, 0.0, 1.0 };
        GLfloat vShininess[1] = { 128 };
        glMaterialfv( GL_FRONT, GL_AMBIENT,   vAmbient );
        glMaterialfv( GL_FRONT, GL_DIFFUSE,   vDiffuse );
        glMaterialfv( GL_FRONT, GL_SPECULAR,  vSpecular );
        glMaterialfv( GL_FRONT, GL_EMISSION,  vEmission );
        glMaterialfv( GL_FRONT, GL_SHININESS, vShininess );
        //
        glEnable( GL_BLEND );
        //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        glActiveTexture( GL_TEXTURE0 );
        glEnable( GL_TEXTURE_3D );
        //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
        //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
        //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND );
        //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT );
        //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
        m_3DTextureVisualization->BindTexture(0);
        m_3DTextureVisualization->UseParameters();
        Vector3<T> vAABBMinPt = m_SimDomain->GetBoundingAABBLowPoint();
        Vector3<T> vAABBMaxPt = m_SimDomain->GetBoundingAABBHighPoint();
        //-----------------------------------------------------------
        Vector3<int> gridResolution = m_SimDomain->GetGridResolution();
        Vector3<T>   gridDimension  = m_SimDomain->GetGridDimension();
        //-----------------------------------------------------------
        int iAxis;
        glBegin( GL_QUADS );
        //-----------------------------------------------------------
        // DrawSliceStack_NegativeZ();  // back-to-front is from -z to +z
        if ( iDrawDir == -3 ) {
            iAxis = 2;
            //
            T texCoordStep[3] = { 
                1.0 / (gridResolution[0]-1), 
                1.0 / (gridResolution[1]-1), 
                1.0 / (gridResolution[2]-1) 
            };
            T texCoordStart[3] = { 0, 0, 0 };
            T normalizeScale[3] = {
                vAABBMaxPt[0] - vAABBMinPt[0], 
                vAABBMaxPt[1] - vAABBMinPt[1], 
                vAABBMaxPt[2] - vAABBMinPt[2] 
            };
            T posStep[3] = { 
                normalizeScale[0] / (gridResolution[0]-1), 
                normalizeScale[1] / (gridResolution[1]-1), 
                normalizeScale[2] / (gridResolution[2]-1) 
            };
            T posStart[3] = { 
                vAABBMinPt[0], 
                vAABBMinPt[1], 
                vAABBMinPt[2] 
            };
            T zValue = vAABBMinPt[iAxis];
            int numberOfSlices = gridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
    
            // DEBUG for making one-to-one mapping on z-direction
            numberOfSlices = gridResolution[iAxis];

            //T zStep  = (vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / numberOfSlices;
            //T tValue = 0;
            //T tStep  = 1.0 / numberOfSlices;

            //
            T texCoordBegin[3];
            T texCoordEnd[3];
            T posBegin[3];
            T posEnd[3];
            //
            // Offsets for inverse mapping
            //   3---2
            //   |   |  and [][3] for x,y,z
            //   0---1
            int index[4];   // for dataPosition
            T offsetInvMapping[4][3];
            T texCoordAfterInvMapping[4][3];
            //
            texCoordBegin[2] = texCoordStart[2];
            texCoordEnd[2] = texCoordStart[2] + texCoordStep[2];
            posBegin[2] = posStart[2];
            posEnd[2] = posStart[2] + posStep[2];
            //
            //static int countForCalNormals = 0;
            double randNormal[4][3];
            for ( int i = 0; i < numberOfSlices; ++i ) {
                //
                //index = (m_vGridResolution[1] * m_vGridResolution[0] * 4) * i;
                //
                texCoordBegin[1] = texCoordStart[1];
                texCoordEnd[1] = texCoordStart[1] + texCoordStep[1];
                posBegin[1] = posStart[1];
                posEnd[1] = posStart[1] + posStep[1];
                //
                for ( int y = 0; y < gridResolution[1]-1; ++y ) {
                    //
                    texCoordBegin[0] = texCoordStart[0];
                    texCoordEnd[0] = texCoordStart[0] + texCoordStep[0];
                    posBegin[0] = posStart[0];
                    posEnd[0] = posStart[0] + posStep[0];
                    //
                    for ( int x = 0; x < gridResolution[0]-1; ++x ) {
                        //
                        {
                            //
                            int nextX = 4;
                            int idxX  = nextX * x;
                            int nextY = gridResolution[0] * nextX;
                            int idxY  = nextY * y;
                            int nextZ = gridResolution[1] * nextY;
                            int idxZ  = nextZ * i;
                            index[0] = idxZ + idxY + idxX;
                            index[1] = index[0] + nextX;
                            index[2] = index[1] + nextY;
                            index[3] = index[0] + nextY;

                            for ( int s = 0; s < 4; ++s ) {
                                randNormal[s][0] = 0;
                                randNormal[s][1] = 0;
                                randNormal[s][2] = 1;
                            }
                            // Calculate Gradients as Normals
                            // DEBUG
                            //double randNormal[4][3];
                            //if ( ++countForCalNormals < m_vGridResolution[0]*m_vGridResolution[1]*m_vGridResolution[2]*100 ) {
                                if ( ( 1 < i && i < numberOfSlices-1 ) &&
                                    ( 1 < y && y < gridResolution[1]-2 ) &&
                                    ( 1 < x && x < gridResolution[0]-2 ) )
                                {
                                    for ( int s = 0; s < 4; ++s ) {
                                        randNormal[s][0] = ( dataForPosition[index[s]+nextX] - dataForPosition[index[s]-nextX] ) / gridDimension[0];
                                        randNormal[s][1] = ( dataForPosition[index[s]+nextY] - dataForPosition[index[s]-nextY] ) / gridDimension[1];
                                        randNormal[s][2] = ( dataForPosition[index[s]+nextZ] - dataForPosition[index[s]-nextZ] ) / gridDimension[2];
                                        double length = sqrt( 
                                            randNormal[s][0] * randNormal[s][0] +
                                            randNormal[s][1] * randNormal[s][1] +
                                            randNormal[s][2] * randNormal[s][2] 
                                        );
                                        length *= -1;
                                        if ( length > 0.00001 ) {
                                            randNormal[s][0] /= length;
                                            randNormal[s][1] /= length;
                                            randNormal[s][2] /= length;
                                        }
                                    }
                                }
                            //}
                            //else if ( countForCalNormals > m_vGridResolution[0]*m_vGridResolution[1]*m_vGridResolution[2]*200 ) {
                            //  countForCalNormals = 0;
                            //}

                            //
                            // begin, begin, begin
                            offsetInvMapping[0][0] = posBegin[0] - dataForPosition[index[0]  ];
                            offsetInvMapping[0][1] = posBegin[1] - dataForPosition[index[0]+1];
                            offsetInvMapping[0][2] = posBegin[2] - dataForPosition[index[0]+2];
                            // end, begin, begin
                            offsetInvMapping[1][0] = posEnd[0]   - dataForPosition[index[1]  ];
                            offsetInvMapping[1][1] = posBegin[1] - dataForPosition[index[1]+1];
                            offsetInvMapping[1][2] = posBegin[2] - dataForPosition[index[1]+2];
                            // end, end, begin
                            offsetInvMapping[2][0] = posEnd[0]   - dataForPosition[index[2]  ];
                            offsetInvMapping[2][1] = posEnd[1]   - dataForPosition[index[2]+1];
                            offsetInvMapping[2][2] = posBegin[2] - dataForPosition[index[2]+2];
                            // begin, end, begin
                            offsetInvMapping[3][0] = posBegin[0] - dataForPosition[index[3]  ];
                            offsetInvMapping[3][1] = posEnd[1]   - dataForPosition[index[3]+1];
                            offsetInvMapping[3][2] = posBegin[2] - dataForPosition[index[3]+2];
                            //
                            for ( int dim = 0; dim < 4; ++dim ) {
                                offsetInvMapping[dim][0] /= normalizeScale[0];
                                offsetInvMapping[dim][1] /= normalizeScale[1];
                                offsetInvMapping[dim][2] /= normalizeScale[2];
                            }
                            //
                            // begin, begin, begin
                            texCoordAfterInvMapping[0][0] = texCoordBegin[0] + offsetInvMapping[0][0];
                            texCoordAfterInvMapping[0][1] = texCoordBegin[1] + offsetInvMapping[0][1];
                            texCoordAfterInvMapping[0][2] = texCoordBegin[2] + offsetInvMapping[0][2];
                            // end, begin, begin
                            texCoordAfterInvMapping[1][0] = texCoordEnd[0]   + offsetInvMapping[1][0];
                            texCoordAfterInvMapping[1][1] = texCoordBegin[1] + offsetInvMapping[1][1];
                            texCoordAfterInvMapping[1][2] = texCoordBegin[2] + offsetInvMapping[1][2];
                            // end, end, begin
                            texCoordAfterInvMapping[2][0] = texCoordEnd[0]   + offsetInvMapping[2][0];
                            texCoordAfterInvMapping[2][1] = texCoordEnd[1]   + offsetInvMapping[2][1];
                            texCoordAfterInvMapping[2][2] = texCoordBegin[2] + offsetInvMapping[2][2];
                            // begin, end, begin
                            texCoordAfterInvMapping[3][0] = texCoordBegin[0] + offsetInvMapping[3][0];
                            texCoordAfterInvMapping[3][1] = texCoordEnd[1]   + offsetInvMapping[3][1];
                            texCoordAfterInvMapping[3][2] = texCoordBegin[2] + offsetInvMapping[3][2];
                            //
                        }
                        //
                        //glTexCoord3f( texCoordBegin[0], texCoordBegin[1], texCoordBegin[2] );
                        glTexCoord3f( texCoordAfterInvMapping[0][0], texCoordAfterInvMapping[0][1], texCoordAfterInvMapping[0][2] );
                        //glNormal3f( 0, 0, 1 );
                        glNormal3f( randNormal[0][0], randNormal[0][1], randNormal[0][2] );
                        glVertex3f( posBegin[0], posBegin[1], posBegin[2] );
                        //
                        //glTexCoord3f( texCoordEnd[0], texCoordBegin[1], texCoordBegin[2] );
                        glTexCoord3f( texCoordAfterInvMapping[1][0], texCoordAfterInvMapping[1][1], texCoordAfterInvMapping[1][2] );
                        //glNormal3f( 0, 0, 1 );
                        glNormal3f( randNormal[1][0], randNormal[1][1], randNormal[1][2] );
                        glVertex3f( posEnd[0], posBegin[1], posBegin[2] );
                        //
                        //glTexCoord3f( texCoordEnd[0], texCoordEnd[1], texCoordBegin[2] );
                        glTexCoord3f( texCoordAfterInvMapping[2][0], texCoordAfterInvMapping[2][1], texCoordAfterInvMapping[2][2] );
                        //glNormal3f( 0, 0, 1 );
                        glNormal3f( randNormal[2][0], randNormal[2][1], randNormal[2][2] );
                        glVertex3f( posEnd[0], posEnd[1], posBegin[2] );
                        //
                        //glTexCoord3f( texCoordBegin[0], texCoordEnd[1], texCoordBegin[2] );
                        glTexCoord3f( texCoordAfterInvMapping[3][0], texCoordAfterInvMapping[3][1], texCoordAfterInvMapping[3][2] );
                        //glNormal3f( 0, 0, 1 );
                        glNormal3f( randNormal[3][0], randNormal[3][1], randNormal[3][2] );
                        glVertex3f( posBegin[0], posEnd[1], posBegin[2] );
                        //
                        texCoordBegin[0] = texCoordEnd[0];
                        texCoordEnd[0] += texCoordStep[0];
                        posBegin[0] = posEnd[0];
                        posEnd[0] += posStep[0];
                    }
                    texCoordBegin[1] = texCoordEnd[1];
                    texCoordEnd[1] += texCoordStep[1];
                    posBegin[1] = posEnd[1];
                    posEnd[1] += posStep[1];
                }
                texCoordBegin[2] = texCoordEnd[2];
                texCoordEnd[2] += texCoordStep[2];
                posBegin[2] = posEnd[2];
                posEnd[2] += posStep[2];
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_NegativeX();  // back-to-front is from -x to +x
        else if ( iDrawDir == -1 ) {
            iAxis = 0;
            T zValue = vAABBMinPt[iAxis];
            int numberOfSlices = gridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 0;
            T tStep  = 1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( tValue, 0, 1 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMaxPt[2] );
                //
                glTexCoord3f( tValue, 0, 0 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMinPt[2] );
                //
                glTexCoord3f( tValue, 1, 0 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMinPt[2] );
                //
                glTexCoord3f( tValue, 1, 1 );
                glNormal3f( 1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMaxPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_NegativeY();  // back-to-front is from -y to +y
        else if ( iDrawDir == -2 ) {
            iAxis = 1;
            T zValue = vAABBMinPt[iAxis];
            int numberOfSlices = gridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 0;
            T tStep  = 1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( 0, tValue, 1 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMaxPt[2] );
                //
                glTexCoord3f( 1, tValue, 1 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMaxPt[2] );
                //
                glTexCoord3f( 1, tValue, 0 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMinPt[2] );
                //
                glTexCoord3f( 0, tValue, 0 );
                glNormal3f( 0, 1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMinPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_PositiveZ();  // back-to-front is from +z to -z
        else if ( iDrawDir == 3 ) {
            iAxis = 2;
            T zValue = vAABBMaxPt[iAxis];
            int numberOfSlices = gridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 1.0;
            T tStep  = -1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( 0, 0, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMinPt[0], vAABBMinPt[1], zValue );
                //
                glTexCoord3f( 0, 1, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMinPt[0], vAABBMaxPt[1], zValue );
                //
                glTexCoord3f( 1, 1, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMaxPt[0], vAABBMaxPt[1], zValue );
                //
                glTexCoord3f( 1, 0, tValue );
                glNormal3f( 0, 0, -1 );
                glVertex3f( vAABBMaxPt[0], vAABBMinPt[1], zValue );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_PositiveX();  // back-to-front is from +x to -x
        else if ( iDrawDir == 1 ) {
            iAxis = 0;
            T zValue = vAABBMaxPt[iAxis];
            int numberOfSlices = gridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 1.0;
            T tStep  = -1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( tValue, 0, 0 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMinPt[2] );
                //
                glTexCoord3f( tValue, 0, 1 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMinPt[1], vAABBMaxPt[2] );
                //
                glTexCoord3f( tValue, 1, 1 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMaxPt[2] );
                //
                glTexCoord3f( tValue, 1, 0 );
                glNormal3f( -1, 0, 0 );
                glVertex3f( zValue, vAABBMaxPt[1], vAABBMinPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        // DrawSliceStack_PositiveY();  // back-to-front is from +y to -y
        else if ( iDrawDir == 2 ) {
            iAxis = 1;
            T zValue = vAABBMaxPt[iAxis];
            int numberOfSlices = gridResolution[iAxis] * iSubdivision;
            if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;
            T zStep  = (vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / (numberOfSlices-1);
            T tValue = 1.0;
            T tStep  = -1.0 / (numberOfSlices-1);
            for ( int i = 0; i < numberOfSlices; ++i )
            {
                glTexCoord3f( 0, tValue, 1 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMaxPt[2] );
                //
                glTexCoord3f( 0, tValue, 0 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMinPt[0], zValue, vAABBMinPt[2] );
                //
                glTexCoord3f( 1, tValue, 0 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMinPt[2] );
                //
                glTexCoord3f( 1, tValue, 1 );
                glNormal3f( 0, -1, 0 );
                glVertex3f( vAABBMaxPt[0], zValue, vAABBMaxPt[2] );
                //
                zValue += zStep;
                tValue += tStep;
            }
        }
        //-----------------------------------------------------------
        glEnd();
        glBindTexture( GL_TEXTURE_3D, 0 );
        glPopAttrib();
    }
    //---------------------------------------------------------------
    //===============================================================
    // Delete temp data read from GPU
    delete [] dataForPosition;
    //delete [] dataForConnectivity;
}
//-----------------------------------------------------------------------------
// END: DrawByGL (Using 3D Texture)
//=============================================================================

//*****************************************************************************
// BEGIN: DrawByGLSL (Using 3D Texture)
//-----------------------------------------------------------------------------
template <typename T>
void ModelDeformableGLSL_Visualization_3DTexture<T>::
DrawByGLSL ( int iSubdivision )
{
    static int iMaxNumberOfSlices = 1024;
    //---------------------------------------------------------------
#ifdef TAPs_DEBUG_MODE
    if ( !m_SimDomain ) return;
    //---------------------------------------------------------------
    if ( !m_SimDomain->RetObject3DTexturePosition() )   return;
    //---------------------------------------------------------------
    if ( !m_glslProgramObjectFor3DTextureDrawDirection )    return;
    //---------------------------------------------------------------
    if ( !m_glslProgramObjectFor3DTextureDrawing )  return;
    //---------------------------------------------------------------
    if ( !m_3DTextureVisualization )    return;
#endif
    //---------------------------------------------------------------
    //if ( !Get3DTextureVisualization() )   return;
    //---------------------------------------------------------------
    //===============================================================
    // Read data from GPU
    //---------------------------------------------------------------
    Texture * texture3DPosition = m_SimDomain->RetObject3DTexturePosition();
    //---------------------------------------------------------------
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    //-----------------------------------------------------
    GLsizei sizeForPosition = 
            texture3DPosition->GetWidth() *
            texture3DPosition->GetHeight() *
            texture3DPosition->GetDepth() *
            texture3DPosition->GetInternalFormatNumberOfComponents();
    GLfloat * dataForPosition = new GLfloat[ sizeForPosition ];
    //
    //GLsizei sizeForConnectivity = 
    //      m_3DTextureConnectivityParameters.width * 
    //      m_3DTextureConnectivityParameters.height * 
    //      m_3DTextureConnectivityParameters.depth * 
    //      m_3DTextureConnectivityParameters.internalFormatNumOfComponents;
    //GLfloat * dataForConnectivity = new GLfloat[ sizeForConnectivity ];
    //
    {
        int i = 0;
        //=================================================
        // Read data for positions from a texture to memory
        glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        texture3DPosition->BindTexture(0);
        glGetTexImage( 
            texture3DPosition->GetTarget(),
            texture3DPosition->GetLevel(),
            texture3DPosition->GetPixelFormat(),
            texture3DPosition->GetDataType(),
            dataForPosition
        );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //=================================================
        //=================================================
        // Read data for connectivities from a texture to memory
        //glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
        //glBindTexture( m_3DTextureConnectivityParameters.target, m_gluipNameTextureConnectivity[i] );
        //glGetTexImage( 
        //  m_3DTextureConnectivityParameters.target,
        //  0,
        //  m_3DTextureConnectivityParameters.pixelFormat,
        //  m_3DTextureConnectivityParameters.dataType,
        //  dataForConnectivity
        //);
        //TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //=================================================
    }
    //---------------------------------------------------------------
    glPopAttrib();
    //---------------------------------------------------------------
    //===============================================================

    //===============================================================
    // Find direction to the eye view
    //---------------------------------------------------------------
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glEnable( GL_TEXTURE_2D );
    m_glslProgramObjectFor3DTextureDrawDirection->BeginGLSL();
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_glslFBO_v3DObjAlignedSliceDrawDirection );
    TAPs::OpenGL::Fn::CHECK_FRAMEBUFFER_STATUS();
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    {
        //-------------------------------------------------
        glMatrixMode( GL_PROJECTION );
        glPushMatrix();
        glLoadIdentity();
        glOrtho( -1000000, 1000000, -1000000, 1000000, -1000000, 1000000 );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //
        // Load Model View Matrix
        glMatrixMode( GL_MODELVIEW );
        glPushMatrix();
        //glGetFloatv( GL_MODELVIEW_MATRIX, modelViewMatrix );
        //glLoadmatrixf( modelViewMatrix );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        //
        // Only one pixel is needed to get the inverse transpose of modelview matrix
        glViewport( 0, 0, 1, 1 );
        TAPs::OpenGL::Fn::CHECK_GL_ERROR();
        {
            //glEnable( GL_TEXTURE_2D );
            glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_glslFBO_v3DObjAlignedSliceDrawDirection );
            glFramebufferTexture2DEXT(
                GL_FRAMEBUFFER_EXT,                     // target
                GL_COLOR_ATTACHMENT0_EXT,               // attached frame
                GL_TEXTURE_2D,                          // texture target
                m_glui2DTextureFor3DObjAlignedSliceDrawDirection,   // texture id
                0                                       // level
            );
            glDrawBuffer( GL_COLOR_ATTACHMENT0_EXT );
            TAPs::OpenGL::Fn::CHECK_FRAMEBUFFER_STATUS();
            TAPs::OpenGL::Fn::CHECK_GL_ERROR();
            glClearColor( 0, 0, 0, 0 );
            glDisable( GL_DEPTH_TEST );
            glClear( GL_COLOR_BUFFER_BIT );
            glPolygonMode( GL_FRONT, GL_FILL );
            glBegin( GL_POINTS );
                glVertex3f( 0, 0, 0 );
            glEnd();
        }
        glPopMatrix();
        glMatrixMode( GL_PROJECTION );
        glPopMatrix();
        glMatrixMode( GL_MODELVIEW );
    }
    glDisable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, 0 );
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
    m_glslProgramObjectFor3DTextureDrawDirection->EndGLSL();
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    glPopAttrib();
    //
    //===========================================
    // Read drawing direction from the texture
    const int width = 1, height = 1;
    GLfloat drawDir[width*height*4];
    glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
    glBindTexture( GL_TEXTURE_2D, m_glui2DTextureFor3DObjAlignedSliceDrawDirection );
    glGetTexImage( 
        GL_TEXTURE_2D,
        0,
        GL_RGBA,
        GL_FLOAT,
        drawDir
    );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //-------------------------------------------
    // Find the draw direction
    //   The draw direction is the data with maximum absolute value.
    GLfloat absDrawDir[3] = { fabs( drawDir[0] ), fabs( drawDir[1] ), fabs( drawDir[2] ) };
    int iDrawDir = 0;       // X: -1,1; Y: -2,2; Z: -3,3
    if ( absDrawDir[0] > absDrawDir[1] ) {
        if ( absDrawDir[0] > absDrawDir[2] ) {
            if ( drawDir[0] > 0.0f )    iDrawDir =  1;
            else                        iDrawDir = -1;
        }
        else {
            if ( drawDir[2] > 0.0f )    iDrawDir =  3;
            else                        iDrawDir = -3;
        }
    }
    else {
        if ( absDrawDir[1] > absDrawDir[2] ) {
            if ( drawDir[1] > 0.0f )    iDrawDir =  2;
            else                        iDrawDir = -2;
        }
        else {
            if ( drawDir[2] > 0.0f )    iDrawDir =  3;
            else                        iDrawDir = -3;
        }
    }
    //---------------------------------------------------------------
    //===============================================================

    //===============================================================
    //---------------------------------------------------------------
    //=====================================================
    // Draw The 3D Texture
    //-----------------------------------------------------
    //---------------------------------
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    //-----------------------
    // Set Color Material
    //GLfloat vAmbient[4]   = { 0.2, 0.2, 0.2, 1.0 };
    //GLfloat vDiffuse[4]   = { 0.8, 0.8, 0.8, 1.0 };
    //GLfloat vSpecular[4]  = { 0.2, 0.2, 0.2, 1.0 };
    //GLfloat vEmission[4]  = { 0.0, 0.0, 0.0, 1.0 };
    //GLfloat vShininess[1] = { 128 };
    //glMaterialfv( GL_FRONT, GL_AMBIENT,   vAmbient );
    //glMaterialfv( GL_FRONT, GL_DIFFUSE,   vDiffuse );
    //glMaterialfv( GL_FRONT, GL_SPECULAR,  vSpecular );
    //glMaterialfv( GL_FRONT, GL_EMISSION,  vEmission );
    //glMaterialfv( GL_FRONT, GL_SHININESS, vShininess );
    //-----------------------
    glEnable( GL_LIGHTING );
    glEnable( GL_BLEND );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    //---------------------------------
    Vector3<T> vAABBMinPt = m_SimDomain->GetBoundingAABBLowPoint();
    Vector3<T> vAABBMaxPt = m_SimDomain->GetBoundingAABBHighPoint();
    //---------------------------------
    Vector3<int> gridResolution = m_SimDomain->GetGridResolution();
    Vector3<T>   gridDimension  = m_SimDomain->GetGridDimension();
    //=====================================================
    m_glslProgramObjectFor3DTextureDrawing->BeginGLSL();
    //-----------------------------------------------------
    m_glslProgramObjectFor3DTextureDrawing->SetUniform1f( "threshold", 0.5f );
    //---------------------------------
    //m_glslProgramObject->SetUniform3f( "LightPosition", 0.0f, 2.0f, 4.0f );
    m_glslProgramObjectFor3DTextureDrawing->SetUniform3f( 
        "VoxelSize", gridDimension[0], gridDimension[1], gridDimension[2] );
    //---------------------------------
    // Set 3D texture to Texture Unit 0
    m_3DTextureVisualization->EnableTextureTarget();
    glActiveTexture( GL_TEXTURE0 );
    m_3DTextureVisualization->BindTexture(0);
    m_glslProgramObjectFor3DTextureDrawing->SetUniform1i( "ModelVolumeTexture", 0 );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //---------------------------------

    //---------------------------------
    // Set 1D texture to Texture Unit 1
    m_1DTextureTransferFnLUT->EnableTextureTarget();
    glActiveTexture( GL_TEXTURE1 );
    m_1DTextureTransferFnLUT->BindTexture(0);
    m_glslProgramObjectFor3DTextureDrawing->SetUniform1i( "ModelTransferFnLUT", 1 );
    TAPs::OpenGL::Fn::CHECK_GL_ERROR();
    //---------------------------------

    // DEBUG
    #ifdef  TAPs_DEBUG_MODE
    //=================================================
    //GLubyte data[256][4];
    {
        static boolean firstRun = true;
        if ( firstRun ) {
            GLfloat data[256][4];
            //---------------------------------
            glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
            m_1DTextureTransferFnLUT->BindTexture(0);
//          glBindTexture( m_1DTextureTransferFnLUTParameters.target, m_glui1DTextureTransferFnLUT );
            glGetTexImage( 
//              m_1DTextureTransferFnLUTParameters.target,
//              0,
//              m_1DTextureTransferFnLUTParameters.pixelFormat,
//              m_1DTextureTransferFnLUTParameters.dataType,
                m_1DTextureTransferFnLUT->GetTarget(),
                m_1DTextureTransferFnLUT->GetLevel(),
                m_1DTextureTransferFnLUT->GetPixelFormat(),
                m_1DTextureTransferFnLUT->GetDataType(),
                data
            );
            for ( int i = 0; i < 256; ++i ) {
//              if      ( m_1DTextureTransferFnLUTParameters.dataType == GL_UNSIGNED_BYTE ) {
                if      ( m_1DTextureTransferFnLUT->GetDataType() == GL_UNSIGNED_BYTE ) {
                    std::cout << "data: " << (int)data[i][0] << " " 
                                        << (int)data[i][1] << " "  
                                        << (int)data[i][2] << " " 
                                        << (int)data[i][3] << "\n";
                }
//              else if ( m_1DTextureTransferFnLUTParameters.dataType == GL_FLOAT ) {
                else if ( m_1DTextureTransferFnLUT->GetDataType() == GL_FLOAT ) {
                    std::cout << "data: " << data[i][0] << " " 
                                        << data[i][1] << " "  
                                        << data[i][2] << " " 
                                        << data[i][3] << "\n";
                }
            }
            TAPs::OpenGL::Fn::CHECK_GL_ERROR();
            //-----------------------------------
            firstRun = false;
        }
    }
    //=================================================
    #endif//TAPs_DEBUG_MODE



    //---------------------------------
    glBegin( GL_QUADS );
    //---------------------------------
    int iAxis = 0;
    //-----------------------------------------------------
    //=====================================================

    //===============================================================
    // DrawSliceStack_NegativeZ();  // back-to-front is from -z to +z
    //---------------------------------------------------------------
    if ( true ) {
    //if ( iDrawDir == -3 ) {
        iAxis = 2;
        //---------------------------------
        T texCoordStep[3] = { 
            1.0 / (gridResolution[0]-1), 
            1.0 / (gridResolution[1]-1), 
            1.0 / (gridResolution[2]-1) 
        };
        T texCoordStart[3] = { 0, 0, 0 };
        T normalizeScale[3] = {
            vAABBMaxPt[0] - vAABBMinPt[0], 
            vAABBMaxPt[1] - vAABBMinPt[1], 
            vAABBMaxPt[2] - vAABBMinPt[2] 
        };
        T posStep[3] = { 
            normalizeScale[0] / (gridResolution[0]-1), 
            normalizeScale[1] / (gridResolution[1]-1), 
            normalizeScale[2] / (gridResolution[2]-1) 
        };
        T posStart[3] = { 
            vAABBMinPt[0], 
            vAABBMinPt[1], 
            vAABBMinPt[2] 
        };
        T zValue = vAABBMinPt[iAxis];
        int numberOfSlices = gridResolution[iAxis] * iSubdivision;
        if ( numberOfSlices > iMaxNumberOfSlices ) numberOfSlices = iMaxNumberOfSlices;

        // DEBUG for making one-to-one mapping on z-direction
        numberOfSlices = gridResolution[iAxis];

        //T zStep  = (vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / numberOfSlices;
        //T tValue = 0;
        //T tStep  = 1.0 / numberOfSlices;

        //
        T texCoordBegin[3];
        T texCoordEnd[3];
        T posBegin[3];
        T posEnd[3];
        //
        // Offsets for inverse mapping
        //   3---2
        //   |   |  and [][3] for x,y,z
        //   0---1
        int index[4];   // for dataPosition
        T offsetInvMapping[4][3];
        T texCoordAfterInvMapping[4][3];
        //
        texCoordBegin[2] = texCoordStart[2];
        texCoordEnd[2] = texCoordStart[2] + texCoordStep[2];
        posBegin[2] = posStart[2];
        posEnd[2] = posStart[2] + posStep[2];
        //
        for ( int i = 0; i < numberOfSlices; ++i ) {
        //for ( int i = 0+1; i < numberOfSlices-1; ++i ) {
            //
            //index = (m_vGridResolution[1] * m_vGridResolution[0] * 4) * i;
            //
            texCoordBegin[1] = texCoordStart[1];
            texCoordEnd[1] = texCoordStart[1] + texCoordStep[1];
            posBegin[1] = posStart[1];
            posEnd[1] = posStart[1] + posStep[1];
            //
            for ( int y = 0; y < gridResolution[1]-1; ++y ) {
                //
                texCoordBegin[0] = texCoordStart[0];
                texCoordEnd[0] = texCoordStart[0] + texCoordStep[0];
                posBegin[0] = posStart[0];
                posEnd[0] = posStart[0] + posStep[0];
                //
                for ( int x = 0; x < gridResolution[0]-1; ++x ) {
                    //
                    {
                        //
                        int nextX = 4;
                        int idxX  = nextX * x;
                        int nextY = gridResolution[0] * nextX;
                        int idxY  = nextY * y;
                        int nextZ = gridResolution[1] * nextY;
                        int idxZ  = nextZ * i;
                        index[0] = idxZ + idxY + idxX;
                        index[1] = index[0] + nextX;
                        index[2] = index[1] + nextY;
                        index[3] = index[0] + nextY;

                        //
                        // begin, begin, begin
                        offsetInvMapping[0][0] = posBegin[0] - dataForPosition[index[0]  ];
                        offsetInvMapping[0][1] = posBegin[1] - dataForPosition[index[0]+1];
                        offsetInvMapping[0][2] = posBegin[2] - dataForPosition[index[0]+2];
                        // end, begin, begin
                        offsetInvMapping[1][0] = posEnd[0]   - dataForPosition[index[1]  ];
                        offsetInvMapping[1][1] = posBegin[1] - dataForPosition[index[1]+1];
                        offsetInvMapping[1][2] = posBegin[2] - dataForPosition[index[1]+2];
                        // end, end, begin
                        offsetInvMapping[2][0] = posEnd[0]   - dataForPosition[index[2]  ];
                        offsetInvMapping[2][1] = posEnd[1]   - dataForPosition[index[2]+1];
                        offsetInvMapping[2][2] = posBegin[2] - dataForPosition[index[2]+2];
                        // begin, end, begin
                        offsetInvMapping[3][0] = posBegin[0] - dataForPosition[index[3]  ];
                        offsetInvMapping[3][1] = posEnd[1]   - dataForPosition[index[3]+1];
                        offsetInvMapping[3][2] = posBegin[2] - dataForPosition[index[3]+2];
                        //
                        for ( int dim = 0; dim < 4; ++dim ) {
                            offsetInvMapping[dim][0] /= normalizeScale[0];
                            offsetInvMapping[dim][1] /= normalizeScale[1];
                            offsetInvMapping[dim][2] /= normalizeScale[2];

                            //offsetInvMapping[dim][0] = 0;
                            //offsetInvMapping[dim][1] = 0;
                            //offsetInvMapping[dim][2] = 0;
                        }
                        //
                        // begin, begin, begin
                        texCoordAfterInvMapping[0][0] = texCoordBegin[0] + offsetInvMapping[0][0];
                        texCoordAfterInvMapping[0][1] = texCoordBegin[1] + offsetInvMapping[0][1];
                        texCoordAfterInvMapping[0][2] = texCoordBegin[2] + offsetInvMapping[0][2];
                        // end, begin, begin
                        texCoordAfterInvMapping[1][0] = texCoordEnd[0]   + offsetInvMapping[1][0];
                        texCoordAfterInvMapping[1][1] = texCoordBegin[1] + offsetInvMapping[1][1];
                        texCoordAfterInvMapping[1][2] = texCoordBegin[2] + offsetInvMapping[1][2];
                        // end, end, begin
                        texCoordAfterInvMapping[2][0] = texCoordEnd[0]   + offsetInvMapping[2][0];
                        texCoordAfterInvMapping[2][1] = texCoordEnd[1]   + offsetInvMapping[2][1];
                        texCoordAfterInvMapping[2][2] = texCoordBegin[2] + offsetInvMapping[2][2];
                        // begin, end, begin
                        texCoordAfterInvMapping[3][0] = texCoordBegin[0] + offsetInvMapping[3][0];
                        texCoordAfterInvMapping[3][1] = texCoordEnd[1]   + offsetInvMapping[3][1];
                        texCoordAfterInvMapping[3][2] = texCoordBegin[2] + offsetInvMapping[3][2];
                        //
                    }
                    //
                    //glTexCoord3f( texCoordBegin[0], texCoordBegin[1], texCoordBegin[2] );
                    glTexCoord3f( texCoordAfterInvMapping[0][0], texCoordAfterInvMapping[0][1], texCoordAfterInvMapping[0][2] );
                    glVertex3f( posBegin[0], posBegin[1], posBegin[2] );
                    //
                    //glTexCoord3f( texCoordEnd[0], texCoordBegin[1], texCoordBegin[2] );
                    glTexCoord3f( texCoordAfterInvMapping[1][0], texCoordAfterInvMapping[1][1], texCoordAfterInvMapping[1][2] );
                    glVertex3f( posEnd[0], posBegin[1], posBegin[2] );
                    //
                    //glTexCoord3f( texCoordEnd[0], texCoordEnd[1], texCoordBegin[2] );
                    glTexCoord3f( texCoordAfterInvMapping[2][0], texCoordAfterInvMapping[2][1], texCoordAfterInvMapping[2][2] );
                    glVertex3f( posEnd[0], posEnd[1], posBegin[2] );
                    //
                    //glTexCoord3f( texCoordBegin[0], texCoordEnd[1], texCoordBegin[2] );
                    glTexCoord3f( texCoordAfterInvMapping[3][0], texCoordAfterInvMapping[3][1], texCoordAfterInvMapping[3][2] );
                    glVertex3f( posBegin[0], posEnd[1], posBegin[2] );
                    //
                    texCoordBegin[0] = texCoordEnd[0];
                    texCoordEnd[0] += texCoordStep[0];
                    posBegin[0] = posEnd[0];
                    posEnd[0] += posStep[0];
                }
                texCoordBegin[1] = texCoordEnd[1];
                texCoordEnd[1] += texCoordStep[1];
                posBegin[1] = posEnd[1];
                posEnd[1] += posStep[1];
            }
            texCoordBegin[2] = texCoordEnd[2];
            texCoordEnd[2] += texCoordStep[2];
            posBegin[2] = posEnd[2];
            posEnd[2] += posStep[2];
        }
    }
    //---------------------------------------------------------------
    //===============================================================

    //if ( iDrawDir == -3 ) {
    //  iAxis = 2;
    //  //---------------------------------
    //  int numberOfSlices = m_vGridResolution[iAxis] * iSubdivision;
    //  if ( numberOfSlices > iMaxNumberOfSlices )  numberOfSlices = iMaxNumberOfSlices;
    //  T zValue = vAABBMinPt[iAxis];
    //  T zStep  = ( vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / ( numberOfSlices-1 );
    //  T tValue = 0;
    //  T tStep  = 1.0 / ( numberOfSlices-1 );
    //  //-----------------------
    //  for ( int s = 0; s < numberOfSlices; ++s ) {
    //      //
    //      glTexCoord3f( 0.4, 0.4, tValue );
    //      glNormal3f( 0, 0, 1 );
    //      glVertex3f( vAABBMinPt[0], vAABBMinPt[1], zValue );
    //      //
    //      glTexCoord3f( 0.6, 0.4, tValue );
    //      glNormal3f( 0, 0, 1 );
    //      glVertex3f( vAABBMaxPt[0], vAABBMinPt[1], zValue );
    //      //
    //      glTexCoord3f( 0.6, 0.6, tValue );
    //      glNormal3f( 0, 0, 1 );
    //      glVertex3f( vAABBMaxPt[0], vAABBMaxPt[1], zValue );
    //      //
    //      glTexCoord3f( 0.4, 0.6, tValue );
    //      glNormal3f( 0, 0, 1 );
    //      glVertex3f( vAABBMinPt[0], vAABBMaxPt[1], zValue );
    //      //
    //      zValue += zStep;
    //      tValue += tStep;
    //  }
    //}

    //===============================================================
    // DrawSliceStack_NegativeX();  // back-to-front is from -x to +x
    //---------------------------------------------------------------
    else if ( iDrawDir == -1 ) {
        iAxis = 0;
        //---------------------------------
        int numberOfSlices = gridResolution[iAxis] * iSubdivision;
        if ( numberOfSlices > iMaxNumberOfSlices )  numberOfSlices = iMaxNumberOfSlices;
        T zValue = vAABBMinPt[iAxis];
        T zStep  = ( vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / ( numberOfSlices-1 );
        T tValue = 0;
        T tStep  = 1.0 / ( numberOfSlices-1 );
        //-----------------------
        for ( int s = 0; s < numberOfSlices; ++s ) {
            //
            glTexCoord3f( tValue, 0, 1 );
            glNormal3f( 1, 0, 0 );
            glVertex3f( zValue, vAABBMinPt[1], vAABBMaxPt[2] );
            //
            glTexCoord3f( tValue, 0, 0 );
            glNormal3f( 1, 0, 0 );
            glVertex3f( zValue, vAABBMinPt[1], vAABBMinPt[2] );
            //
            glTexCoord3f( tValue, 1, 0 );
            glNormal3f( 1, 0, 0 );
            glVertex3f( zValue, vAABBMaxPt[1], vAABBMinPt[2] );
            //
            glTexCoord3f( tValue, 1, 1 );
            glNormal3f( 1, 0, 0 );
            glVertex3f( zValue, vAABBMaxPt[1], vAABBMaxPt[2] );
            //
            zValue += zStep;
            tValue += tStep;
        }
    }
    //---------------------------------------------------------------
    //===============================================================

    //===============================================================
    // DrawSliceStack_NegativeY();  // back-to-front is from -y to +y
    //---------------------------------------------------------------
    else if ( iDrawDir == -2 ) {
        iAxis = 1;
        //---------------------------------
        int numberOfSlices = gridResolution[iAxis] * iSubdivision;
        if ( numberOfSlices > iMaxNumberOfSlices )  numberOfSlices = iMaxNumberOfSlices;
        T zValue = vAABBMinPt[iAxis];
        T zStep  = ( vAABBMaxPt[iAxis] - vAABBMinPt[iAxis] ) / ( numberOfSlices-1 );
        T tValue = 0;
        T tStep  = 1.0 / ( numberOfSlices-1 );
        //-----------------------
        for ( int s = 0; s < numberOfSlices; ++s ) {
            //
            glTexCoord3f( 0, tValue, 1 );
            glNormal3f( 0, 1, 0 );
            glVertex3f( vAABBMinPt[0], zValue, vAABBMaxPt[2] );
            //
            glTexCoord3f( 1, tValue, 1 );
            glNormal3f( 0, 1, 0 );
            glVertex3f( vAABBMaxPt[0], zValue, vAABBMaxPt[2] );
            //
            glTexCoord3f( 1, tValue, 0 );
            glNormal3f( 0, 1, 0 );
            glVertex3f( vAABBMaxPt[0], zValue, vAABBMinPt[2] );
            //
            glTexCoord3f( 0, tValue, 0 );
            glNormal3f( 0, 1, 0 );
            glVertex3f( vAABBMinPt[0], zValue, vAABBMinPt[2] );
            //
            zValue += zStep;
            tValue += tStep;
        }
    }
    //---------------------------------------------------------------
    //===============================================================

    //===============================================================
    // DrawSliceStack_PositiveZ();  // back-to-front is from +z to -z
    //---------------------------------------------------------------
    else if ( iDrawDir == 3 ) {
        iAxis = 2;
        //---------------------------------
        int numberOfSlices = gridResolution[iAxis] * iSubdivision;
        if ( numberOfSlices > iMaxNumberOfSlices )  numberOfSlices = iMaxNumberOfSlices;
        T zValue = vAABBMaxPt[iAxis];
        T zStep  = ( vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / ( numberOfSlices-1 );
        T tValue = 1.0;
        T tStep  = -1.0 / ( numberOfSlices-1 );
        //-----------------------
        for ( int s = 0; s < numberOfSlices; ++s ) {
            //
            glTexCoord3f( 0, 0, tValue );
            glNormal3f( 0, 0, -1 );
            glVertex3f( vAABBMinPt[0], vAABBMinPt[1], zValue );
            //
            glTexCoord3f( 0, 1, tValue );
            glNormal3f( 0, 0, -1 );
            glVertex3f( vAABBMinPt[0], vAABBMaxPt[1], zValue );
            //
            glTexCoord3f( 1, 1, tValue );
            glNormal3f( 0, 0, -1 );
            glVertex3f( vAABBMaxPt[0], vAABBMaxPt[1], zValue );
            //
            glTexCoord3f( 1, 0, tValue );
            glNormal3f( 0, 0, -1 );
            glVertex3f( vAABBMaxPt[0], vAABBMinPt[1], zValue );
            //
            zValue += zStep;
            tValue += tStep;
        }
    }
    //---------------------------------------------------------------
    //===============================================================

    //===============================================================
    // DrawSliceStack_PositiveX();  // back-to-front is from +x to -x
    //---------------------------------------------------------------
    else if ( iDrawDir == 1 ) {
        iAxis = 0;
        //---------------------------------
        int numberOfSlices = gridResolution[iAxis] * iSubdivision;
        if ( numberOfSlices > iMaxNumberOfSlices )  numberOfSlices = iMaxNumberOfSlices;
        T zValue = vAABBMaxPt[iAxis];
        T zStep  = ( vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / ( numberOfSlices-1 );
        T tValue = 1.0;
        T tStep  = -1.0 / ( numberOfSlices-1 );
        //-----------------------
        for ( int s = 0; s < numberOfSlices; ++s ) {
            //
            glTexCoord3f( tValue, 0, 0 );
            glNormal3f( -1, 0, 0 );
            glVertex3f( zValue, vAABBMinPt[1], vAABBMinPt[2] );
            //
            glTexCoord3f( tValue, 0, 1 );
            glNormal3f( -1, 0, 0 );
            glVertex3f( zValue, vAABBMinPt[1], vAABBMaxPt[2] );
            //
            glTexCoord3f( tValue, 1, 1 );
            glNormal3f( -1, 0, 0 );
            glVertex3f( zValue, vAABBMaxPt[1], vAABBMaxPt[2] );
            //
            glTexCoord3f( tValue, 1, 0 );
            glNormal3f( -1, 0, 0 );
            glVertex3f( zValue, vAABBMaxPt[1], vAABBMinPt[2] );
            //
            zValue += zStep;
            tValue += tStep;
        }
    }
    //---------------------------------------------------------------
    //===============================================================

    //===============================================================
    // DrawSliceStack_PositiveY();  // back-to-front is from +y to -y
    //---------------------------------------------------------------
    else if ( iDrawDir == 2 ) {
        iAxis = 1;
        //---------------------------------
        int numberOfSlices = gridResolution[iAxis] * iSubdivision;
        if ( numberOfSlices > iMaxNumberOfSlices )  numberOfSlices = iMaxNumberOfSlices;
        T zValue = vAABBMaxPt[iAxis];
        T zStep  = ( vAABBMinPt[iAxis] - vAABBMaxPt[iAxis] ) / ( numberOfSlices-1 );
        T tValue = 1.0;
        T tStep  = -1.0 / ( numberOfSlices-1 );
        //-----------------------
        for ( int s = 0; s < numberOfSlices; ++s ) {
            //
            glTexCoord3f( 0, tValue, 1 );
            glNormal3f( 0, -1, 0 );
            glVertex3f( vAABBMinPt[0], zValue, vAABBMaxPt[2] );
            //
            glTexCoord3f( 0, tValue, 0 );
            glNormal3f( 0, -1, 0 );
            glVertex3f( vAABBMinPt[0], zValue, vAABBMinPt[2] );
            //
            glTexCoord3f( 1, tValue, 0 );
            glNormal3f( 0, -1, 0 );
            glVertex3f( vAABBMaxPt[0], zValue, vAABBMinPt[2] );
            //
            glTexCoord3f( 1, tValue, 1 );
            glNormal3f( 0, -1, 0 );
            glVertex3f( vAABBMaxPt[0], zValue, vAABBMaxPt[2] );
            //
            zValue += zStep;
            tValue += tStep;
        }
    }
    //---------------------------------------------------------------
    //===============================================================

    //=====================================================
    //-----------------------------------------------------
    glEnd();    // of glBegin( GL_QUADS );
    //---------------------------------
    //-----------------------------------------------------
    m_glslProgramObjectFor3DTextureDrawing->EndGLSL();
    //=====================================================
    //-----------------------------------------------------
    glPopAttrib();
//  glDisable( m_3DTextureVisualizationParameters.target );
//  glBindTexture( m_3DTextureVisualizationParameters.target, 0 );
    m_3DTextureVisualization->DisableTextureTarget();
    m_3DTextureVisualization->UnbindTexture();
//  glDisable( m_1DTextureTransferFnLUTParameters.target );
//  glBindTexture( m_1DTextureTransferFnLUTParameters.target, 0 );
    m_1DTextureTransferFnLUT->DisableTextureTarget();
    m_1DTextureTransferFnLUT->UnbindTexture();
    //-----------------------------------------------------
    //=====================================================
    //---------------------------------------------------------------
    //===============================================================
    // Delete temp data read from GPU
    delete [] dataForPosition;
    //delete [] dataForConnectivity;
}
//-----------------------------------------------------------------------------
// END: DrawByGLSL (Using 3D Texture)
//*****************************************************************************

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