VolumeBuffer.cpp

Go to the documentation of this file.

#ifdef _WIN32
#include<windows.h>
#endif

#include <GL/glew.h>
#include <GL/glut.h>
#include <GL/glext.h>
//#include <Cg/cgGL.h>
#include <stdio.h>
#include <math.h>


#include "VolumeBuffer.h"

PFNGLTEXIMAGE3DPROC glTexImage3D;

VolumeBuffer::VolumeBuffer(GLenum format, int width, int height, int depth, int banks)
    : m_width(width),
      m_height(height),
      m_depth(depth),
      m_banks(banks),
      m_blendMode(BLEND_NONE)
{
    // create fbo
        //m_fbo = new FramebufferObject();

    //glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_max_banks);
    //if (m_banks > m_max_banks) m_banks = m_max_banks;

    // create textures
    
        //m_tex = new GLuint [m_banks];
    //for(int i=0; i<m_banks; i++) {
    //    m_tex[i] = create3dTexture(format, m_width, m_height, m_depth);
    //}

    // attach slice 0 of first texture to fbo for starters
    //m_fbo->Bind();
    //m_fbo->AttachTexture(GL_TEXTURE_3D, m_tex[0], GL_COLOR_ATTACHMENT0_EXT, 0, 0);
    //m_fbo->IsValid();
    //m_fbo->Disable();

        //volume_data_raw = (unsigned char *) malloc(size*sizeof(unsigned char));
        
        //m_volume_data_rgba = (unsigned char *) malloc(size*sizeof(unsigned char)*4);
        
        m_volume_size = m_width*m_height*m_depth;
        m_volume_data_raw = new unsigned char [m_volume_size];
        //m_volume_data_rgba = new unsigned char [m_volume_size*4];
        //m_volume_data_rgba = (unsigned char *) malloc(size*sizeof(unsigned char)*4);

        if(banks >= 1)
        {
                m_scale1_raw = new unsigned char [m_volume_size];
                //m_scale1_rgba = new unsigned char [m_volume_size*4];
        }
        
        if(banks >= 2)
        {
                m_scale2_raw = new unsigned char [m_volume_size];
                //m_scale2_rgba = new unsigned char [m_volume_size*4];
        }

        if(banks >= 3)
        {
                m_scale3_raw = new unsigned char [m_volume_size];
                //m_scale3_rgba = new unsigned char [m_volume_size*4];
        }

        m_tex = new GLuint [m_banks];
        glEnable(GL_TEXTURE_2D);
        m_tex_z = new unsigned int [m_depth];
        m_tex_x = new unsigned int [m_width];
        m_tex_y = new unsigned int [m_height];

        m_tex_z_s1 = new unsigned int [m_depth];
        m_tex_z_s2 = new unsigned int [m_depth];
        m_tex_z_s3 = new unsigned int [m_depth];
        //m_tex[0] = create2dTexture(format, m_width, m_height, m_depth);
        //glEnable(GL_TEXTURE_3D);
        //m_tex[0] = create3dTexture(format, m_width, m_height, m_depth);

        // could be part VolumeRender
        // vertex ordering:
        //  
        //       3 *---------* 2  BACK            +y axis
        //        /|        /|                  ^
        //       / |       / |                  |   -z axis
        //      /  |      /  |                  | /
        //   7 *---------* 6 |                  |/
        //     |   |     |   |       -x <-------+-------> +x axis
        //     | 0 *-----+---* 1               /|
        //     |  /      |  /                 / |
        //     | /       | /                 /  | -y
        //     |/        |/                  +z
        //   4 *---------* 5  FRONT

        vertex[0].x=-0.5; vertex[0].y=-0.5; vertex[0].z=-0.5;
        vertex[1].x= 0.5; vertex[1].y=-0.5; vertex[1].z=-0.5;
        vertex[2].x= 0.5; vertex[2].y= 0.5; vertex[2].z=-0.5;
        vertex[3].x=-0.5; vertex[3].y= 0.5; vertex[3].z=-0.5;
        vertex[4].x=-0.5; vertex[4].y=-0.5; vertex[4].z= 0.5;
        vertex[5].x= 0.5; vertex[5].y=-0.5; vertex[5].z= 0.5;
        vertex[6].x= 0.5; vertex[6].y= 0.5; vertex[6].z= 0.5;
        vertex[7].x=-0.5; vertex[7].y= 0.5; vertex[7].z= 0.5;
        
        //0 front
        //1 right
        //2 back
        //3 left
        //4 top
        //5 down
        normal[0].x=0;  normal[0].y=0;  normal[0].z=-1;
        normal[1].x=1;  normal[1].y=0;  normal[1].z=0;
        normal[2].x=0;  normal[2].y=0;  normal[2].z=1;
        normal[3].x=-1; normal[3].y=0;  normal[3].z=0;
        normal[4].x=0;  normal[4].y=1;  normal[4].z=0;
        normal[5].x=0;  normal[5].y=-1; normal[5].z=0;

        m_textures_ready = 0;
}

VolumeBuffer::~VolumeBuffer()
{
//    delete m_fbo;
    for(int i=0; i<m_banks; i++) {
        glDeleteTextures(1, &m_tex[i]);
    }
        for(int i=0; i<m_depth; i++) {
        glDeleteTextures(1, &m_tex_z[i]);
                
                glDeleteTextures(1, &m_tex_z_s1[i]);
                glDeleteTextures(1, &m_tex_z_s2[i]);
                glDeleteTextures(1, &m_tex_z_s3[i]);
    }

        for(int i=0; i<m_width; i++) {
        glDeleteTextures(1, &m_tex_y[i]);
    }
        
        for(int i=0; i<m_height; i++) {
        glDeleteTextures(1, &m_tex_x[i]);
    }
    
        delete [] m_tex_z;
        delete [] m_tex_x;
        delete [] m_tex_y;

        delete [] m_tex_z_s1;
        delete [] m_tex_z_s2;
        delete [] m_tex_z_s3;

    delete [] m_tex;
        delete [] m_volume_data_raw;
        //delete [] m_volume_data_rgba;

        if(m_banks >= 1)
        {
                delete [] m_scale1_raw;
                //delete [] m_scale1_rgba;
        }
        if(m_banks >= 2)
        {
                delete [] m_scale2_raw;
                //delete [] m_scale2_rgba;
        }
        if(m_banks >= 3)
        {
                delete [] m_scale3_raw;
                //delete [] m_scale3_rgba;
        }
}

GLuint
VolumeBuffer::create3dTexture(GLenum internalformat, int w, int h, int d)
{
    GLuint tex;
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_3D, tex);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    GLint mode = GL_CLAMP_TO_BORDER;
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, mode);
        
        // VERY IMPORTANT:
        // this line loads the address of the glTexImage3D function into the function pointer of the same name.
        // glTexImage3D is not implemented in the standard GL libraries and must be loaded dynamically at run time,
        // the environment the program is being run in MAY OR MAY NOT support it, if not we'll get back a NULL pointer.
        // this is necessary to use any OpenGL function declared in the glext.h header file
        // the Pointer to FunctioN ... PROC types are declared in the same header file with a type appropriate to the function name
#ifdef _WIN32
        PFNGLTEXIMAGE3DPROC  glTexImage3D=0;
        glTexImage3D = (PFNGLTEXIMAGE3DPROC) wglGetProcAddress("glTexImage3D");
#endif
        if (glTexImage3D == NULL) {
                printf("Error in line %d: Couldn't load glTexImage3D function. Aborting.\n", __LINE__);
                return -1;
        }
    //glTexImage3D(GL_TEXTURE_3D, 0, GL_INTENSITY, w, h, d, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, w, h, d, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
        //glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY, w, h, 0, GL_LUMINANCE, internalformat, 0);
    return tex;
}

GLuint
VolumeBuffer::create2dTexture(GLenum internalformat, int w, int h, int d)
{
        GLuint tex;
    glGenTextures(1, &tex);
#ifdef GL_VERSION_1_1
    glBindTexture(GL_TEXTURE_2D, tex);
#endif
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

        //GLint mode = GL_REPEAT;
        GLint mode = GL_CLAMP;
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mode);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mode);

#ifdef GL_VERSION_1_1
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, internalformat, 0);
        //glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY, w, h, 0, GL_LUMINANCE, internalformat, 0);
#else
   glTexImage2D(GL_TEXTURE_2D, 0, 4, w, h, 0, GL_LUMINANCE, internalformat, 0);
#endif
   return tex;
}

GLuint
VolumeBuffer::create2DTextures(GLenum internalformat)
{
        if(m_textures_ready == 0)
        {
                //create2DTexturesX(internalformat);
                //create2DTexturesY(internalformat);
                create2DTexturesZ(internalformat);
                create2DTexturesZscale1(internalformat);
                create2DTexturesZscale2(internalformat);
                create2DTexturesZscale3(internalformat);
                m_textures_ready = 1;
        }
        return 0;
}

GLuint
VolumeBuffer::create2DTexturesZ(GLenum internalformat)
{
    //generates texture symbols for direction Z
        glGenTextures(m_depth, (m_tex_z));

        int ix,iy,iz,value;
        
        //allocate memory for one texture in direction Z
        unsigned char* tex_z = new unsigned char [m_width*m_height*4];
        
        for(iz = 0; iz < m_depth; iz++)
        {
                //reset slice values to zeros
                memset(tex_z,0,m_width*m_height*4*sizeof(unsigned char));
                
                //fill slice values from datagrid
                for (iy = 0; iy < m_height; iy++)
                {
                        for (ix = 0; ix < m_width; ix++)
                        {
                                value = m_volume_data_raw[(m_height*m_width)*iz + (m_width)*iy + ix];

                                tex_z[((m_width)*iy + ix)*4 + 0] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 1] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 2] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 3] = (GLubyte) 255;
                        }
                }
                
                //bind slice with texture name
                glBindTexture(GL_TEXTURE_2D,(m_tex_z)[iz]);
                
                //texture setup
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                
                GLint mode = GL_CLAMP;
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mode);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mode);

                //bind slice data
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_z);
        }
        
        delete [] tex_z;
        return 0;
}

GLuint
VolumeBuffer::create2DTexturesZscale1(GLenum internalformat)
{
    //generates texture symbols for direction Z
        glGenTextures(m_depth, (m_tex_z_s1));

        int ix,iy,iz,value;
        
        //allocate memory for one texture in direction Z
        unsigned char* tex_z = new unsigned char [m_width*m_height*4];
        
        for(iz = 0; iz < m_depth; iz++)
        {
                //reset slice values to zeros
                memset(tex_z,0,m_width*m_height*4*sizeof(unsigned char));
                
                //fill slice values from datagrid
                for (iy = 0; iy < m_height; iy++)
                {
                        for (ix = 0; ix < m_width; ix++)
                        {
                                value = m_scale1_raw[(m_height*m_width)*iz + (m_width)*iy + ix];

                                tex_z[((m_width)*iy + ix)*4 + 0] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 1] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 2] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 3] = (GLubyte) 255;
                        }
                }
                
                //bind slice with texture name
                glBindTexture(GL_TEXTURE_2D,(m_tex_z_s1)[iz]);
                
                //texture setup
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                
                GLint mode = GL_CLAMP;
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mode);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mode);

                //bind slice data
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_z);
        }
        
        delete [] tex_z;
        return 0;
}

GLuint
VolumeBuffer::create2DTexturesZscale2(GLenum internalformat)
{
    //generates texture symbols for direction Z
        glGenTextures(m_depth, (m_tex_z_s2));

        int ix,iy,iz,value;
        
        //allocate memory for one texture in direction Z
        unsigned char* tex_z = new unsigned char [m_width*m_height*4];
        
        for(iz = 0; iz < m_depth; iz++)
        {
                //reset slice values to zeros
                memset(tex_z,0,m_width*m_height*4*sizeof(unsigned char));
                
                //fill slice values from datagrid
                for (iy = 0; iy < m_height; iy++)
                {
                        for (ix = 0; ix < m_width; ix++)
                        {
                                value = m_scale2_raw[(m_height*m_width)*iz + (m_width)*iy + ix];

                                tex_z[((m_width)*iy + ix)*4 + 0] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 1] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 2] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 3] = (GLubyte) 255;
                        }
                }
                
                //bind slice with texture name
                glBindTexture(GL_TEXTURE_2D,(m_tex_z_s2)[iz]);
                
                //texture setup
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                
                GLint mode = GL_CLAMP;
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mode);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mode);

                //bind slice data
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_z);
        }
        
        delete [] tex_z;
        return 0;
}

GLuint
VolumeBuffer::create2DTexturesZscale3(GLenum internalformat)
{
    //generates texture symbols for direction Z
        glGenTextures(m_depth, (m_tex_z_s3));

        int ix,iy,iz,value;
        
        //allocate memory for one texture in direction Z
        unsigned char* tex_z = new unsigned char [m_width*m_height*4];
        
        for(iz = 0; iz < m_depth; iz++)
        {
                //reset slice values to zeros
                memset(tex_z,0,m_width*m_height*4*sizeof(unsigned char));
                
                //fill slice values from datagrid
                for (iy = 0; iy < m_height; iy++)
                {
                        for (ix = 0; ix < m_width; ix++)
                        {
                                value = m_scale3_raw[(m_height*m_width)*iz + (m_width)*iy + ix];

                                tex_z[((m_width)*iy + ix)*4 + 0] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 1] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 2] = (GLubyte) value;
                                tex_z[((m_width)*iy + ix)*4 + 3] = (GLubyte) 255;
                        }
                }
                
                //bind slice with texture name
                glBindTexture(GL_TEXTURE_2D,(m_tex_z_s3)[iz]);
                
                //texture setup
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                
                GLint mode = GL_CLAMP;
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mode);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mode);

                //bind slice data
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_z);
        }
        
        delete [] tex_z;
        return 0;
}

GLuint
VolumeBuffer::create2DTexturesX(GLenum internalformat)
{
        //generates texture symbols for direction X
        glGenTextures(m_width, (m_tex_x));

        int ix,iy,iz,value;

        //allocate memory for one texture in direction Z
        unsigned char* tex_x = new unsigned char [m_height*m_depth*4];

        for(ix = 0; ix < m_width; ix++)
        {
                //reset slice values to zeros
                memset(tex_x,0,m_height*m_depth*4*sizeof(unsigned char));
                
                //fill slice values from datagrid
                for(iz = 0; iz < m_depth; iz++)
                {
                        for (iy = 0; iy < m_height; iy++)
                        {
                                value = m_volume_data_raw[(m_height*m_width)*iz + (m_width)*iy + ix];

                                tex_x[((m_height)*iz + iy)*4 + 0] = (GLubyte) value;
                                tex_x[((m_height)*iz + iy)*4 + 1] = (GLubyte) value;
                                tex_x[((m_height)*iz + iy)*4 + 2] = (GLubyte) value;
                                tex_x[((m_height)*iz + iy)*4 + 3] = (GLubyte) 255;
                        }
                }
                
                //bind slice with texture name
                glBindTexture(GL_TEXTURE_2D,(m_tex_x)[ix]);
                
                //texture setup
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                
                GLint mode = GL_CLAMP;
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mode);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mode);

                //bind slice data
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_height, m_depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_x);
        }
        
        delete [] tex_x;
        return 0;
}

GLuint
VolumeBuffer::create2DTexturesY(GLenum internalformat)
{
        //generates texture symbols for direction X
        glGenTextures(m_height, (m_tex_y));

        int ix,iy,iz,value;

        //allocate memory for one texture in direction Z
        unsigned char* tex_y = new unsigned char [m_width*m_depth*4];

        for(iy = 0; iy < m_height; iy++)
        {
                //reset slice values to zeros
                memset(tex_y,0,m_width*m_depth*4*sizeof(unsigned char));
                
                //fill slice values from datagrid
                for(iz = 0; iz < m_depth; iz++)
                {
                        for (ix = 0; ix < m_width; ix++)
                        {
                                value = m_volume_data_raw[(m_height*m_width)*iz + (m_width)*iy + ix];

                                tex_y[((m_width)*iz + ix)*4 + 0] = (GLubyte) value;
                                tex_y[((m_width)*iz + ix)*4 + 1] = (GLubyte) value;
                                tex_y[((m_width)*iz + ix)*4 + 2] = (GLubyte) value;
                                tex_y[((m_width)*iz + ix)*4 + 3] = (GLubyte) 255;
                        }
                }
                
                //bind slice with texture name
                glBindTexture(GL_TEXTURE_2D,(m_tex_y)[iy]);
                
                //texture setup
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                
                GLint mode = GL_CLAMP;
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mode);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mode);

                //bind slice data
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_y);
        }
        
        delete [] tex_y;
        return 0;
}

void
VolumeBuffer::setWrapMode(GLint mode, int bank)
{
    glBindTexture(GL_TEXTURE_3D, m_tex[bank]);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, mode);
}

void
VolumeBuffer::setFiltering(GLint mode, int bank)
{
    glBindTexture(GL_TEXTURE_3D, m_tex[bank]);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, mode);
}

int
VolumeBuffer::setData(unsigned char *data, int bank)
{
    glBindTexture(GL_TEXTURE_3D, m_tex[bank]);
        // VERY IMPORTANT:
        // this line loads the address of the glTexImage3D function into the function pointer of the same name.
        // glTexImage3D is not implemented in the standard GL libraries and must be loaded dynamically at run time,
        // the environment the program is being run in MAY OR MAY NOT support it, if not we'll get back a NULL pointer.
        // this is necessary to use any OpenGL function declared in the glext.h header file
        // the Pointer to FunctioN ... PROC types are declared in the same header file with a type appropriate to the function name
        glTexImage3D = (PFNGLTEXIMAGE3DPROC) wglGetProcAddress("glTexImage3D");
        if (glTexImage3D == NULL) {
                printf("Error in line %d: Couldn't load glTexImage3D function. Aborting.\n", __LINE__);
                return -1;
        }
    //glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, m_width, m_height, m_depth, GL_RGBA, GL_FLOAT, data);
        //glTexImage3D(GL_TEXTURE_3D, 0, GL_INTENSITY, m_width, m_height, m_depth, 0 , GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, m_width, m_height, m_depth, 0 , GL_RGBA, GL_UNSIGNED_BYTE, data);
}

void
//VolumeBuffer::set2DData(GLubyte data[64][64][4], int bank)
VolumeBuffer::set2DData(unsigned char* data, int bank)
{
    glBindTexture(GL_TEXTURE_2D, m_tex[bank]);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
        //glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY, m_width, m_height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
}

// draw a slice of the volume
void
VolumeBuffer::drawSlice(float z)
{
        glEnable(GL_TEXTURE_3D);
        glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
    glBegin(GL_QUADS);
    glTexCoord3f(0.0f, 0.0f, z); glVertex3f(-1.0f, -1.0f, 0.0f);
    glTexCoord3f(1.0f, 0.0f, z); glVertex3f(1.0f, -1.0f, 0.0f);
    glTexCoord3f(1.0f, 1.0f, z); glVertex3f(1.0f, 1.0f, 0.0f);
    glTexCoord3f(0.0f, 1.0f, z); glVertex3f(-1.0f, 1.0f, 0.0f);
    glEnd();
}

void
VolumeBuffer::drawOneSlice()
{
        glBegin(GL_QUADS);
        
        glTexCoord3f(0.0f, 0.0f, 0.0f); glVertex3f (-1.0f, -1.0f, 0.0f);
        glTexCoord3f(0.0f, 1.0f, 0.0f); glVertex3f (1.0f, -1.0f, 0.0f);
        glTexCoord3f(1.0f, 1.0f, 0.0f); glVertex3f (1.0f, 1.0f, 0.0f);
        glTexCoord3f(1.0f, 0.0f, 0.0f); glVertex3f (-1.0f, 1.0f, 0.0f);
        
        glEnd();
}

void
VolumeBuffer::drawZSlice(int iz)
{
        glBindTexture(GL_TEXTURE_2D, m_tex_z[iz]);

        glBegin(GL_QUADS);
        
        glTexCoord3f(0.0f, 0.0f, 0.0f); glVertex3f (-1.0f, -1.0f, 0.0f);
        glTexCoord3f(0.0f, 1.0f, 0.0f); glVertex3f (1.0f, -1.0f, 0.0f);
        glTexCoord3f(1.0f, 1.0f, 0.0f); glVertex3f (1.0f, 1.0f, 0.0f);
        glTexCoord3f(1.0f, 0.0f, 0.0f); glVertex3f (-1.0f, 1.0f, 0.0f);
        
        glEnd();
}

void
VolumeBuffer::drawXSlice(int ix)
{
        glBindTexture(GL_TEXTURE_2D, m_tex_x[ix]);

        glBegin(GL_QUADS);
        
        glTexCoord3f(0.0f, 0.0f, 0.0f); glVertex3f (-1.0f, -1.0f, 0.0f);
        glTexCoord3f(0.0f, 1.0f, 0.0f); glVertex3f (1.0f, -1.0f, 0.0f);
        glTexCoord3f(1.0f, 1.0f, 0.0f); glVertex3f (1.0f, 1.0f, 0.0f);
        glTexCoord3f(1.0f, 0.0f, 0.0f); glVertex3f (-1.0f, 1.0f, 0.0f);
        
        glEnd();
}

void
VolumeBuffer::drawYSlice(int iy)
{
        glBindTexture(GL_TEXTURE_2D, m_tex_y[iy]);

        glBegin(GL_QUADS);
        
        glTexCoord3f(0.0f, 0.0f, 0.0f); glVertex3f (-1.0f, -1.0f, 0.0f);
        glTexCoord3f(0.0f, 1.0f, 0.0f); glVertex3f (1.0f, -1.0f, 0.0f);
        glTexCoord3f(1.0f, 1.0f, 0.0f); glVertex3f (1.0f, 1.0f, 0.0f);
        glTexCoord3f(1.0f, 0.0f, 0.0f); glVertex3f (-1.0f, 1.0f, 0.0f);
        
        glEnd();
}

int
VolumeBuffer::readRawFile(char *filename)
{
        FILE *fp = fopen(filename, "rb");
    
        if (!fp) {
        fprintf(stderr, "Error opening file '%s'\n", filename);
        return 0;
    }

        size_t read = fread(m_volume_data_raw, sizeof(unsigned char), m_volume_size, fp);
        fclose(fp);

        //unsigned char volume_data_rgba[256][256][256][4];
        
        int i, j, k, c;
        
        for (i = 0; i < m_depth; i++) {
                for (j = 0; j < m_height; j++) {
                        for (k = 0; k < m_width; k++) {
                                
                                c = m_volume_data_raw[(m_height*m_width)*i + (m_width)*j + k];
                            
                                /*
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 0] = (GLubyte) c;
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 1] = (GLubyte) c;
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 2] = (GLubyte) c;
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 3] = (GLubyte) 255;
                                */
                        }
                }
        }

    printf("Read '%s', %d bytes\n", filename, read);

}

int
VolumeBuffer::readScale1File(char *filename)
{
        FILE *fp = fopen(filename, "rb");
    
        if (!fp) {
        fprintf(stderr, "Error opening file '%s'\n", filename);
        return 0;
    }

        size_t read = fread(m_scale1_raw, sizeof(unsigned char), m_volume_size, fp);
        fclose(fp);

        //unsigned char volume_data_rgba[256][256][256][4];
        
        int i, j, k, c;
        
        for (i = 0; i < m_depth; i++) {
                for (j = 0; j < m_height; j++) {
                        for (k = 0; k < m_width; k++) {
                                
                                c = m_scale1_raw[(m_height*m_width)*i + (m_width)*j + k];
                            
/*
                                m_scale1_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 0] = (GLubyte) c;
                                m_scale1_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 1] = (GLubyte) c;
                                m_scale1_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 2] = (GLubyte) c;
                                m_scale1_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 3] = (GLubyte) 255;
                                */
                        }
                }
        }

        printf("Scale1: read '%s', %d bytes\n", filename, read);

}

int
VolumeBuffer::readScale2File(char *filename)
{
        FILE *fp = fopen(filename, "rb");
    
        if (!fp) {
        fprintf(stderr, "Error opening file '%s'\n", filename);
        return 0;
    }

        size_t read = fread(m_scale2_raw, sizeof(unsigned char), m_volume_size, fp);
        fclose(fp);

        //unsigned char volume_data_rgba[256][256][256][4];
        
        int i, j, k, c;
        
        for (i = 0; i < m_depth; i++) {
                for (j = 0; j < m_height; j++) {
                        for (k = 0; k < m_width; k++) {
                                
                                c = m_scale2_raw[(m_height*m_width)*i + (m_width)*j + k];
                            
                                /*
                                m_scale2_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 0] = (GLubyte) c;
                                m_scale2_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 1] = (GLubyte) c;
                                m_scale2_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 2] = (GLubyte) c;
                                m_scale2_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 3] = (GLubyte) 255;
                                */
                        }
                }
        }

        printf("Scale2: read '%s', %d bytes\n", filename, read);

}

int
VolumeBuffer::readScale3File(char *filename)
{
        FILE *fp = fopen(filename, "rb");
    
        if (!fp) {
        fprintf(stderr, "Error opening file '%s'\n", filename);
        return 0;
    }

        size_t read = fread(m_scale3_raw, sizeof(unsigned char), m_volume_size, fp);
        fclose(fp);

        //unsigned char volume_data_rgba[256][256][256][4];
        
        int i, j, k, c;
        
        for (i = 0; i < m_depth; i++) {
                for (j = 0; j < m_height; j++) {
                        for (k = 0; k < m_width; k++) {
                                
                                c = m_scale3_raw[(m_height*m_width)*i + (m_width)*j + k];
                            
                                /*
                                m_scale3_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 0] = (GLubyte) c;
                                m_scale3_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 1] = (GLubyte) c;
                                m_scale3_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 2] = (GLubyte) c;
                                m_scale3_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 3] = (GLubyte) 255;
                                */
                        }
                }
        }

        printf("Scale3: read '%s', %d bytes\n", filename, read);

}

---