texData.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////
// 9/6/02       Aaron Lefohn    Scientific Computing and Imaging Institute
// School of Computing          University of Utah
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
////////////////////////////////////////////////////////////////////////

#include <texture/texData.h>
#include <GL/glUtil.h>
#include <iostream>

using namespace std;
using namespace gutz;

using namespace glift;

/// Full Non-Nrrd Constructor
TexData::TexData( GLenum texDimenName, const vec3i& origin, const vec3i& dimen, int borderW,                            
                 GLenum glFormat, GLenum dataFormat, GLenum dataType, void* data,
                 bool isCompressed, int numDataBytes )
                 : m_data(                      data ),
                 m_texDimenName(        texDimenName ),
                 m_glFormat(            glFormat ),
                 m_dataFormat(  dataFormat ),
                 m_dataType(            dataType ),
                 m_texOrigin(           origin ),
                 m_dimen(                       dimen ),
                 m_borderW(             borderW ),
                 m_isCompressed(        isCompressed ),
                 m_numBytes(            numDataBytes )
{
   checkInput();
}

void TexData::checkInput()
{
   /// Check the input GLenum's
   checkDimenName(              m_texDimenName );
   checkFormatGL(       m_glFormat     );
   checkFormatData(     m_dataFormat   );
}

/// Ensure 1D, 2D, or 3D.
void TexData::checkDimenName( GLenum texDimenName )
{
   if( texDimenName != GL_TEXTURE_1D &&
      texDimenName != GL_TEXTURE_2D &&
      texDimenName != GL_TEXTURE_3D ) {
         err() << "checkDimenName(...) Error:\n\t'texDimenName' ( " << texDimenName 
            << " ) is not supported. Use 6 2D texData's for a cube map.\n";
         exit(1);
      }
}

/// Check that the interal format is valid
///     TODO: Make this complete for the current architecture
void TexData::checkFormatGL( GLenum format )
{
   if( format != GL_RGB &&
      format != GL_RGB8 &&
      format != GL_RGB16 &&
      format != GL_RGBA &&
      format != GL_RGBA8 &&
      format != GL_RGBA16 &&
      format != GL_RED &&
      format != GL_GREEN &&
      format != GL_BLUE &&
      format != GL_ALPHA &&
      format != GL_ALPHA8 &&
      format != GL_ALPHA16 &&
      format != GL_LUMINANCE &&
      format != GL_LUMINANCE8 &&
      format != GL_LUMINANCE16 &&
      format != GL_LUMINANCE_ALPHA &&
      format != GL_LUMINANCE8_ALPHA8 &&
      format != GL_LUMINANCE16_ALPHA16 &&

      format != GL_RGBA_FLOAT32_ATI &&
      format != GL_RGB_FLOAT32_ATI &&       
      format != GL_ALPHA_FLOAT32_ATI &&
      format != GL_INTENSITY_FLOAT32_ATI &&      
      format != GL_LUMINANCE_FLOAT32_ATI &&     
      format != GL_LUMINANCE_ALPHA_FLOAT32_ATI && 
      format != GL_RGBA_FLOAT16_ATI &&
      format != GL_RGB_FLOAT16_ATI &&  
      format != GL_ALPHA_FLOAT16_ATI &&   
      format != GL_INTENSITY_FLOAT16_ATI &&
      format != GL_LUMINANCE_FLOAT16_ATI &&
      format != GL_LUMINANCE_ALPHA_FLOAT16_ATI &&

      format != GL_COMPRESSED_ALPHA_ARB                 &&
      format != GL_COMPRESSED_LUMINANCE_ARB             &&      
      format != GL_COMPRESSED_LUMINANCE_ALPHA_ARB &&
      format != GL_COMPRESSED_INTENSITY_ARB             &&
      format != GL_COMPRESSED_RGB_ARB                           &&
      format != GL_COMPRESSED_RGBA_ARB ) 
   {
      err() << "checkInFormat(...) Error:\n\t'format' ( " << format 
         << " ) is not supported.\n";
      exit(1);
   }
}

/// Check that the data format is valid
void TexData::checkFormatData( GLenum format )
{
   if( format != GL_COLOR_INDEX &&
      format != GL_RGB &&
      format != GL_RGBA &&
      format != GL_RED &&
      format != GL_GREEN &&
      format != GL_BLUE &&
      format != GL_ALPHA &&
      format != GL_LUMINANCE &&
      format != GL_LUMINANCE_ALPHA &&

      format != GL_RGBA_FLOAT32_ATI &&
      format != GL_RGB_FLOAT32_ATI &&       
      format != GL_ALPHA_FLOAT32_ATI &&
      format != GL_INTENSITY_FLOAT32_ATI &&      
      format != GL_LUMINANCE_FLOAT32_ATI &&     
      format != GL_LUMINANCE_ALPHA_FLOAT32_ATI && 
      format != GL_RGBA_FLOAT16_ATI &&
      format != GL_RGB_FLOAT16_ATI &&  
      format != GL_ALPHA_FLOAT16_ATI &&   
      format != GL_INTENSITY_FLOAT16_ATI &&
      format != GL_LUMINANCE_FLOAT16_ATI &&
      format != GL_LUMINANCE_ALPHA_FLOAT16_ATI )
   {
      err() << "checkExFormat(...) Error:\n\t'format' ( " << format 
         << " ) is not supported.\n";
      exit(1);
   }

}

/// Write the data to texture memory with 'glTexImage*D(...)'
void TexData::texImageND( GLenum texType, int mipLevel )
{
   if( m_isCompressed ) {
      switch( m_texDimenName )
      {
      case GL_TEXTURE_1D:
         glCompressedTexImage1DARB(     texType, mipLevel, m_dataFormat, m_dimen.x, 
            m_borderW, m_numBytes, m_data );
         break;
      case GL_TEXTURE_2D:
         glCompressedTexImage2DARB(     texType, mipLevel, m_dataFormat, m_dimen.x, m_dimen.y,
            m_borderW, m_numBytes, m_data );
         break;
      case GL_TEXTURE_3D :
         glCompressedTexImage3DARB(     texType, mipLevel, m_dataFormat, m_dimen.x, m_dimen.y, m_dimen.z, 
            m_borderW, m_numBytes, m_data );
         break;
      default:
         err() << "texImageND Error:\n\tUnsupported texDimenName (" 
            << texType << endl;
         exit(1);
      }

   }
   else {
      switch( m_texDimenName )
      {
      case GL_TEXTURE_1D:
         glTexImage1D(  texType, mipLevel, m_glFormat, m_dimen.x, 
            m_borderW, m_dataFormat, m_dataType, m_data );
         break;
      case GL_TEXTURE_2D:
         glTexImage2D(  texType, mipLevel, m_glFormat, m_dimen.x, m_dimen.y,
            m_borderW, m_dataFormat, m_dataType, m_data );
         break;
      case GL_TEXTURE_3D :
         glTexImage3D(  texType, mipLevel, m_glFormat, m_dimen.x, m_dimen.y, m_dimen.z, 
            m_borderW, m_dataFormat, m_dataType, m_data );
         break;
      default:
         err() << "texImageND Error:\n\tUnsupported texDimenName (" 
            << texType << endl;
         exit(1);
      }
   }
}

/// Replace part of all of the texture with 'glTexSubImage*D(...)'
void TexData::texSubImageND( GLenum texType, int mipLevel )
{
   if( m_isCompressed ) {
      switch( m_texDimenName )
      {
      case GL_TEXTURE_1D:
         glCompressedTexSubImage1DARB( texType, mipLevel, m_texOrigin.x, 
            m_dimen.x, 
            m_dataFormat, m_numBytes, m_data );
         break;
      case GL_TEXTURE_2D:
         glCompressedTexSubImage2DARB( texType, mipLevel, m_texOrigin.x, m_texOrigin.y, 
            m_dimen.x, m_dimen.y,
            m_dataFormat, m_numBytes, m_data );
         break;
      case GL_TEXTURE_3D :
         glCompressedTexSubImage3DARB( texType, mipLevel, m_texOrigin.x, m_texOrigin.y, m_texOrigin.z,
            m_dimen.x, m_dimen.y, m_dimen.z, 
            m_dataFormat, m_numBytes, m_data );
         break;
      default:
         err() << "texImageND Error:\n\tUnsupported texDimenName (" 
            << texType << endl;
         exit(1);
      }

   }
   else {
      switch( m_texDimenName )
      {
      case GL_TEXTURE_1D:
         glTexSubImage1D( texType, mipLevel, m_texOrigin.x, 
            m_dimen.x, 
            m_dataFormat, m_dataType, m_data);
         break;
      case GL_TEXTURE_2D:
         glTexSubImage2D( texType, mipLevel, m_texOrigin.x, m_texOrigin.y, 
            m_dimen.x, m_dimen.y,
            m_dataFormat, m_dataType, m_data);
         break;
      case GL_TEXTURE_3D :
         glTexSubImage3D( texType, mipLevel, m_texOrigin.x, m_texOrigin.y, m_texOrigin.z,
            m_dimen.x, m_dimen.y, m_dimen.z, 
            m_dataFormat, m_dataType, m_data);
         break;
      default:
         err() << "texImageND Error:\n\tUnsupported texDimenName (" 
            << texType << endl;
         exit(1);
      }
   }
}

/// Make the OpenGL call to 'glTexImage*D(...)' or 'glTexSubImage*D(...)'
void TexData::setTexData( GLenum texType, int mipLevel )
{
   if( m_texOrigin == 0 ) { 
      texImageND( texType, mipLevel ); 
   }
   else {                                        
      texSubImageND( texType, mipLevel ); 
   }
}


/*// How many bytes are in 'data'
// DEPRECATED: Works only for non-compressed texture images
int TexData::numBytes( const vec3i& size, GLenum dataFormat, GLenum dataType )
{
int typeSize = 0;

switch(dataType) {
case GL_BYTE:
case GL_UNSIGNED_BYTE: typeSize = 1; break;

case GL_SHORT:
case GL_UNSIGNED_SHORT:typeSize = 2; break;

case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:             typeSize = 4; break;
default:
cerr << "TexData::numBytes(..): ERROR:\n\tUnknown dataType.\n\n\a";
exit(1);
}

vec3i sizeMul( (size.x == 0) ? 1 : size.x, 
(size.y == 0) ? 1 : size.y, 
(size.z == 0) ? 1 : size.z );

int numBytes = sizeMul.x * sizeMul.y * sizeMul.z * typeSize * getNumChannels(dataFormat);
cerr << "TexData::numBytes(...): numBytes = " << numBytes << endl;
return numBytes;
}
*/

---

Send questions, comments, and bug reports to: