simTexture.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     3-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// simTexture.cpp

/// Simian Texture utilities.

#include <GL/glew.h>
#include "simTexture.h"
#include <nrro/nrro.h>
#include <GL/glUtil.h>
#include <iostream>

using namespace glift;
using namespace gutz;
using namespace std;

enum SIM_TEX_FORMATS{
   SIMTL_HILO,
   SIMTL_NV3_FLOAT,
   SIMTL_NV3_HFLOAT,
   SIMTL_ATI97_16,
   SIMTL_ATI97_HFLOAT,
   SIMTL_ATI97_FLOAT,
   SIMTL_8BIT
};

inline void derr(char *when, char *where = 0)
{
#if _DEBUG
   cerr << "simTexture::" << when;
   if(where)
      cerr << " - " << where;
   cerr << endl;
#endif
}

///////////////////////////////////////////////////////////////////////////
// Load a single nrrd texture
///////////////////////////////////////////////////////////////////////////
glift::SingleTex *loadNrrdTexture(char *nrrdTexName, int texType)
{
   derr("loading nrrd from file name", nrrdTexName);

   NrroSP n(new Nrro(nrrdTexName));

   if(n.isNull())
   {
      derr("falied to load nrrd texture");
      return 0;
   }

   if(n->dim() != 4)
   {
      if(n->forceMultiChannel())
      {
         derr("incorrect texture dimensions");
      }
   }

   return loadNrroTexture(n,texType);

   return 0;
}

///////////////////////////////////////////////////////////////////////////
// Load a single Nrro texture
///////////////////////////////////////////////////////////////////////////
glift::SingleTexSP loadNrroTexture(const NrroSP n, int texType)
{
   int ntype = n->getType();

   if(ntype == Nrro::CHAR || ntype == Nrro::UCHAR)
   {
      derr("Loading char Nrro texture");
      SingleTexSP ret = 
         loadTexture3D((char*) n->getData(), 
         n->dim(1), n->dim(2), n->dim(3), n->dim(0),
         getSimtType(n,texType));
      if(!ret)
         derr("loadNrroTexture failed");

      return ret;
   }
   return SingleTexSP();
}

///////////////////////////////////////////////////////////////////////////
// find the type that best fits a Nrro
///////////////////////////////////////////////////////////////////////////
int getSimtType(const NrroSP n, int texType)
{
   int ntype = n->getType();

   if(ntype == nrrdTypeUChar || ntype == nrrdTypeChar)
   {
      derr(" nrrd texture = uchar ");
      return SIMT_8BIT;
   }

   return SIMT_UNKNOWN;
}


///////////////////////////////////////////////////////////////////////////
/// Load Texture, explicit, standard texture object state:
///     Linear, clamp to boarder (if applicable) or clamp
///    BEST FITS:
/// \code
///   Comps               Type General           Type nv123x      Type ATI 9700+
///     1                   Lumanance               HILO16           Fixed16 Lum
///     2                   Lumanance Alpha         HILO16           Fixed16 Lum Alpha
///     3                   RGB8                    RGB8             RGB16  (FIXED)
///     4                   RGBA8                   RGBA8            RGBA16 (FIXED)
/// \endcode
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// 3D texture, float data
///////////////////////////////////////////////////////////////////////////
glift::SingleTexSP loadTexture3D(float *data, int sx, int sy, int sz, int comp, int texType)
{       
   //////////////////////////////
   /// create the tex data object

   GLenum inFmt = getInternalFormat(comp,texType);
   GLenum exFmt = getExternalFormat(comp,inFmt);

   TexData *tdata = new TexData(GL_TEXTURE_3D,                    //texture type 
      vec3i(0,0,0),                     //origin
      vec3i(sx, sy, sz),                //size
      0,                                //border
      inFmt,                            //internal format
      exFmt,                            //external format
      GL_FLOAT,                         //type
      data);                            //data pointer

   //////////////////////////////
   /// create texture object
   if(tdata)
   {
      MultiTexOState tstate;
      tstate << TS_S_CLAMP_TO_EDGE << TS_T_CLAMP_TO_EDGE << TS_LINEAR; //<< new MipMapTex(GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR, true);

      SingleTex* tout = new Tex3D(tstate, tdata);

      glErr(cerr,"SimTexture", "loadTexture3D - float");

      return SingleTexSP(tout);
   }
   else
   {
      cerr << " Simian Texture Utillities :: Error, failed to create 3D texture " << endl;
      return SingleTexSP();
   }


   return SingleTexSP(); ///< should be unreachable
}

///////////////////////////////////////////////////////////////////////////
// 3D texture, char data
///////////////////////////////////////////////////////////////////////////
glift::SingleTexSP loadTexture3D(char  *data, int sx, int sy, int sz, int comp, int texType)
{
   derr("Loading 3D byte texture");
   //////////////////////////////
   /// create the tex data object

   GLenum inFmt = getInternalFormat(comp,texType);
   GLenum exFmt = getExternalFormat(comp,inFmt);

   TexData *tdata = new TexData(GL_TEXTURE_3D,                    //texture type 
      vec3i(0,0,0),                     //origin
      vec3i(sx, sy, sz),                //size
      0,                                //border
      inFmt,                            //internal format
      exFmt,                            //external format
      GL_UNSIGNED_BYTE,                 //type
      data);                            //data pointer

   //////////////////////////////
   /// create texture object
   if(tdata)
   {
      MultiTexOState tstate;
      tstate << TS_S_CLAMP_TO_EDGE << TS_T_CLAMP_TO_EDGE << TS_LINEAR; //<< new MipMapTex(GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR, true);

      SingleTex* tout = new Tex3D(tstate, tdata);

      derr("Texture created");

      glErr(cerr,"SimTexture", "loadTexture3D - char");

      return SingleTexSP(tout);
   }
   else
   {
      cerr << " Simian Texture Utillities :: Error, failed to create 3D texture " << endl;
      return SingleTexSP();
   }


   return SingleTexSP(); ///< should be unreachable
}


///////////////////////////////////////////////////////////////////////////
// 1D
///////////////////////////////////////////////////////////////////////////

glift::SingleTex *loadTexture1D(float *data, int sx, int comp, int texType)
{
   //////////////////////////////
   /// create the tex data object

   GLenum inFmt = getInternalFormat(comp,texType);
   GLenum exFmt = getExternalFormat(comp,inFmt);

   TexData *tdata = new TexData(GL_TEXTURE_1D,                    //texture type 
      vec3i(0,0,0),                     //origin
      vec3i(sx, 0, 0),                  //size
      0,                                //border
      inFmt,                            //internal format
      exFmt,                            //external format
      GL_FLOAT,                         //type
      data);                            //data pointer

   //////////////////////////////
   /// create texture object
   if(tdata)
   {
      MultiTexOState tstate;
      tstate << TS_S_CLAMP_TO_EDGE << TS_T_CLAMP_TO_EDGE << TS_LINEAR; //<< new MipMapTex(GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR, true);

      SingleTex* tout = new Tex1D(tstate, tdata);

      glErr(cerr,"SimTexture", "loadTexture1D - float");

      return tout;
   }
   else
   {
      cerr << " Simian Texture Utillities :: Error, failed to create 1D texture " << endl;
      return 0;
   }


   return 0; ///< should be unreachable
}

///////////////////////////////////////////////////////////////////////////
// 2D texture, float data
///////////////////////////////////////////////////////////////////////////
glift::SingleTex *loadTexture2D(float *data, int sx, int sy, int comp, int texType)
{
   //////////////////////////////
   /// create the tex data object

   GLenum inFmt = getInternalFormat(comp,texType);
   GLenum exFmt = getExternalFormat(comp,inFmt);

   TexData *tdata = new TexData(GL_TEXTURE_2D,                    //texture type 
      vec3i(0,0,0),                     //origin
      vec3i(sx, sy, 0),                 //size
      0,                                //border
      inFmt,                            //internal format
      exFmt,                            //external format
      GL_FLOAT,                         //type
      data);                            //data pointer

   //////////////////////////////
   /// create texture object
   if(tdata)
   {
      MultiTexOState tstate;
      tstate << TS_S_CLAMP_TO_EDGE << TS_T_CLAMP_TO_EDGE << TS_LINEAR; //<< new MipMapTex(GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR, true);

      SingleTex* tout = new Tex2D(tstate, tdata);

      glErr(cerr,"SimTexture", "loadTexture2D - float");

      return tout;
   }
   else
   {
      cerr << " Simian Texture Utillities :: Error, failed to create 2D texture " << endl;
      return 0;
   }


   return 0; ///< should be unreachable
}



///////////////////////////////////////////////////////////////////////////
// find the best fit texture type, returns the higest precision (interpolating) type 
//  for the current platform
///////////////////////////////////////////////////////////////////////////
GLenum getInternalFormat(int nComps, int simtType)
{
   /// try to identify the platform type
   /// this is a fucking hack, fix it, there must be a better way

   ///////////////////////////////////////////////////////
   /// NVIDIA
   if(glew.NV_texture_shader3 && (nComps <= 2) && (simtType == SIMT_BEST || simtType == SIMT_16FIXED))
   {
      derr("HILO16");
      return GL_HILO16_NV;
   }
   if(glew.NV_float_buffer && simtType == SIMT_16FLOAT)
   {
      derr("NV-16 float texture");
      if(nComps == 1)
         return GL_FLOAT_R16_NV;
      if(nComps == 2)
         return GL_FLOAT_RG16_NV;
      if(nComps == 3)
         return GL_FLOAT_RGB16_NV;
      if(nComps == 4)
         return GL_FLOAT_RGBA16_NV;             
   }
   if(glew.NV_float_buffer && simtType == SIMT_32FLOAT)
   {
      derr("NV-16 fixed texture");
      if(nComps == 1)
         return GL_FLOAT_R32_NV;
      if(nComps == 2)
         return GL_FLOAT_RG32_NV;
      if(nComps == 3)
         return GL_FLOAT_RGB32_NV;
      if(nComps == 4)
         return GL_FLOAT_RGBA32_NV;             
   }

   ///////////////////////////////////////////////////////
   /// ATI
   if(glew.ATI_texture_float && (simtType == SIMT_BEST || simtType == SIMT_16FIXED))
   {
      derr("ATI-16 Fixed texture");
      if(nComps == 1)
         return GL_LUMINANCE16;
      if(nComps == 2)
         return GL_LUMINANCE16_ALPHA16;
      if(nComps == 3)
         return GL_RGB16;
      if(nComps == 4)
         return GL_RGBA16;
   }
   if(glew.ATI_texture_float && simtType == SIMT_16FLOAT)
   {
      derr("ATI-16 float texture");
      if(nComps == 1)
         return GL_LUMINANCE_FLOAT16_ATI;
      if(nComps == 2)
         return GL_LUMINANCE_ALPHA_FLOAT16_ATI;
      if(nComps == 3)
         return GL_RGB_FLOAT16_ATI;
      if(nComps == 4)
         return GL_RGBA_FLOAT16_ATI;            
   }

   if(glew.ATI_texture_float && simtType == SIMT_32FLOAT)
   {
      derr("ATI-32 float texture");
      if(nComps == 1)
         return GL_LUMINANCE_FLOAT32_ATI;
      if(nComps == 2)
         return GL_LUMINANCE_ALPHA_FLOAT32_ATI;
      if(nComps == 3)
         return GL_RGB_FLOAT32_ATI;
      if(nComps == 4)
         return GL_RGBA_FLOAT32_ATI;            
   }

   ///////////////////////////////////////////////////////
   /// Default types
   if(nComps == 1)
   {
      derr("LUM8");
      return GL_LUMINANCE8;
   }
   if(nComps == 2)
   {
      derr("LUM8ALPH8");
      return GL_LUMINANCE8_ALPHA8;
   }
   if(nComps == 3)
   {
      derr("RGB8");
      return GL_RGB8;
   }
   if(nComps == 4)
   {
      derr("RGBA8");
      return GL_RGBA8;
   }

   derr("ERROR - internal texture type not found");


   return GL_RGBA8; ///< unreachable

}

///////////////////////////////////////////////////////////////////////////
// Get the gl texture format for the reqested number of components
GLenum getExternalFormat(int nComps, GLenum inFormat)
{
   if(inFormat)
   {
      if(inFormat == GL_HILO16_NV)
      {
         if(nComps != 2)
         {
            derr("invalid # of components for HILO", "getExternalFormat()");
         }
         derr("HILO");
         return GL_HILO_NV;
      }
   }

   if(nComps == 1)
   {
      derr("LUM");
      return GL_LUMINANCE;
   }
   if(nComps == 2)
   {
      derr("LUMALPH");
      return GL_LUMINANCE_ALPHA;
   }
   if(nComps == 3)
   {
      derr("RGB");
      return GL_RGB;
   }
   if(nComps == 4)
   {
      derr("RGBA");
      return GL_RGBA;
   }

   derr("ERROR - internal texture type not found");

   return GL_RGBA; ///< unreachable
}

---

Send questions, comments, and bug reports to: