texState.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/texState.h>
#include <iostream>

using namespace std;
using namespace gutz;

using namespace glift;

namespace glift {
///////////////////////////////////////////////////////
/// Global, pre-defined TexState pointers
/// - These are here for conveniently pre-defined states that are common
///////////////////////////////////////////////////////
const EdgeModeTex* TS_S_CLAMP             = new EdgeModeTex(GL_S, GL_CLAMP);
const EdgeModeTex* TS_T_CLAMP             = new EdgeModeTex(GL_T, GL_CLAMP);
const EdgeModeTex* TS_R_CLAMP             = new EdgeModeTex(GL_R, GL_CLAMP);
const EdgeModeTex* TS_S_CLAMP_TO_EDGE = new EdgeModeTex(GL_S, GL_CLAMP_TO_EDGE);
const EdgeModeTex* TS_T_CLAMP_TO_EDGE = new EdgeModeTex(GL_T, GL_CLAMP_TO_EDGE);
const EdgeModeTex* TS_R_CLAMP_TO_EDGE = new EdgeModeTex(GL_R, GL_CLAMP_TO_EDGE);
const EdgeModeTex* TS_S_REPEAT            = new EdgeModeTex(GL_S, GL_REPEAT);
const EdgeModeTex* TS_T_REPEAT            = new EdgeModeTex(GL_T, GL_REPEAT);
const EdgeModeTex* TS_R_REPEAT            = new EdgeModeTex(GL_R, GL_REPEAT);

const FilterTex* TS_NEAREST = new FilterTex( GL_NEAREST, GL_NEAREST );
const FilterTex* TS_LINEAR      = new FilterTex( GL_LINEAR,  GL_LINEAR  );

const MipMapTex* TS_NEAREST_MIPMAP_NEAREST = new MipMapTex( GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST );
const MipMapTex* TS_LINEAR_MIPMAP_NEAREST  = new MipMapTex( GL_LINEAR_MIPMAP_NEAREST,  GL_LINEAR  );
const MipMapTex* TS_LINEAR_MIPMAP_LINEAR   = new MipMapTex( GL_LINEAR_MIPMAP_LINEAR,   GL_LINEAR  );

const FuncTex*   TS_MODULATE = new FuncTex( GL_MODULATE );
const FuncTex*   TS_REPLACE  = new FuncTex( GL_REPLACE  );
const FuncTex*   TS_DECAL        = new FuncTex( GL_DECAL        );
}

///////////////////////////////////////////////////////
/// EdgeModeTex
///////////////////////////////////////////////////////
EdgeModeTex::EdgeModeTex( GLenum coord, GLenum edgeMode )
: m_coord(coord), m_edgeMode(edgeMode)
{
   checkInput();

   /// Set the m_coord to the real value. No reason for default b/c checkInput() took care of it.
   switch(m_coord) {
   case GL_S: m_coord = GL_TEXTURE_WRAP_S;      break;
   case GL_T: m_coord = GL_TEXTURE_WRAP_T;      break;
   case GL_R: m_coord = GL_TEXTURE_WRAP_R; break;
   }
}

void EdgeModeTex::checkInput()
{
   if( m_coord != GL_S &&
      m_coord != GL_T &&
      m_coord != GL_R ) {
         err() << "checkInput() Error:\n"
            << "\tCoord must be GL_S, GL_T, or GL_R\n";
         exit(1);
      }

      /// TODO: Add arch-dependent extensions here
      if( m_edgeMode != GL_REPEAT &&
         m_edgeMode != GL_CLAMP &&
         m_edgeMode != GL_CLAMP_TO_EDGE ) //&&
         /*m_edgeMode != GL_CLAMP_TO_BORDER_ARB &&
         m_edgeMode != GL_MIRROR_CLAMP_ATI &&
         m_edgeMode != GL_MIRROR_CLAMP_TO_EDGE_ATI &&*/
      {
         err() << "checkInput() Error:\n"
            << "\tedgeMode not supported\n";
      }
}       

void EdgeModeTex::bind( GLenum texType ) const
{
   glTexParameteri( texType, m_coord, m_edgeMode );
}


///////////////////////////////////////////////////////
/// FilterTex 
///////////////////////////////////////////////////////
FilterTex::FilterTex( GLenum minFilter, GLenum magFilter )
: m_minFilter(minFilter), m_magFilter(magFilter)
{
   checkInput( m_minFilter, m_magFilter );
}

void FilterTex::bind( GLenum texType ) const
{
   glTexParameteri( texType, GL_TEXTURE_MIN_FILTER, m_minFilter );
   glTexParameteri( texType, GL_TEXTURE_MAG_FILTER, m_magFilter );
}

void FilterTex::checkInput( GLenum minFilter, GLenum magFilter )
{
   if( minFilter != GL_NEAREST &&
      minFilter != GL_LINEAR ) {
         err() << "checkInput() Error:\n"
            << "\tminFilter must be GL_NEAREST or GL_LINEAR. Use MipMapTex for mipmapping filters.\n";
         exit(1);
      }

      if( magFilter != GL_NEAREST &&
         magFilter != GL_LINEAR  ) {
            err() << "FilterTex::checkInput() Error:\n"
               << "\tmagFilter must be GL_NEAREST or GL_LINEAR.\n";
            exit(1);
         }
}

///////////////////////////////////////////////////////
/// MipMapTex
///////////////////////////////////////////////////////
MipMapTex::MipMapTex( GLenum minFilter, GLenum magFilter, bool autoMipGen )
: m_MIN_LEVEL( 0 ),                     /// OpenGL defaults (according to RedBook 1.2)
m_MAX_LEVEL( 1000 ),
m_MIN_LOD(  -1000.0f ),
m_MAX_LOD(   1000.0f ),
m_minFilter( minFilter ),
m_magFilter( magFilter ),
m_autoMipGen( autoMipGen ),
m_minLevel(     m_MIN_LEVEL ),          
m_maxLevel(     m_MAX_LEVEL ),
m_minLOD(               m_MIN_LOD ),
m_maxLOD(       m_MAX_LOD )
{       
   checkInput( minFilter, magFilter );
}               

MipMapTex::MipMapTex( GLenum minFilter, GLenum magFilter, bool autoMipGen,
                     int minLevel, int maxLevel, float minLOD, float maxLOD )
                     : m_MIN_LEVEL( 0 ),                        /// OpenGL defaults (according to RedBook 1.2)
                     m_MAX_LEVEL( 1000 ),
                     m_MIN_LOD(  -1000.0f ),
                     m_MAX_LOD(   1000.0f ),
                     m_minFilter( minFilter ),
                     m_magFilter( magFilter ),
                     m_autoMipGen( autoMipGen ),
                     m_minLevel( minLevel ),
                     m_maxLevel( maxLevel ),
                     m_minLOD(    minLOD   ),
                     m_maxLOD(   maxLOD   )
{       
   checkInput( minFilter, magFilter );
}

void MipMapTex::bind( GLenum texType ) const
{
   glTexParameteri( texType, GL_TEXTURE_MIN_FILTER, m_minFilter );
   glTexParameteri( texType, GL_TEXTURE_MAG_FILTER, m_magFilter );

   if( m_autoMipGen ) {
      glTexParameteri( texType, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
   }

   if( m_minLevel != m_MIN_LEVEL ) {
      glTexParameteri( texType, GL_TEXTURE_BASE_LEVEL, m_minLevel );
   }

   if( m_maxLevel != m_MAX_LEVEL ) {
      glTexParameteri( texType, GL_TEXTURE_MAX_LEVEL,  m_maxLevel );
   }

   if( m_minLOD != m_MIN_LOD ) {
      glTexParameterf( texType, GL_TEXTURE_MIN_LOD,      m_minLOD );
   }

   if( m_minLOD != m_MAX_LOD ) {
      glTexParameterf( texType, GL_TEXTURE_MAX_LOD,      m_maxLOD );
   }
}

void MipMapTex::release() const
{
   /*   glTexParameteri( texType, GL_GENERATE_MIPMAP_SGIS, GL_FALSE      );
   glTexParameteri( texType, GL_TEXTURE_BASE_LEVEL, m_MIN_LEVEL );
   glTexParameteri( texType, GL_TEXTURE_MAX_LEVEL,  m_MAX_LEVEL );
   glTexParameteri( texType, GL_TEXTURE_MIN_LOD,         m_MIN_LOD   );
   glTexParameteri( texType, GL_TEXTURE_MAX_LOD,         m_MAX_LOD   );
   */
}

void MipMapTex::checkInput( GLenum minFilter, GLenum magFilter )
{
   if( minFilter != GL_NEAREST_MIPMAP_NEAREST &&
      minFilter != GL_LINEAR_MIPMAP_NEAREST &&
      minFilter != GL_NEAREST_MIPMAP_LINEAR &&
      minFilter != GL_LINEAR_MIPMAP_LINEAR ) {
         err() << "MipMapTex::checkInput() Error:\n"
            << "\tminFilter must be GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST,\n" 
            << "\tGL_NEAREST_MIPMAP_LINEAR,  GL_LINEAR_MIPMAP_LINEAR\n";
         exit(1);
      }

      if( magFilter != GL_NEAREST &&
         magFilter != GL_LINEAR  ) {
            err() << "MipMapTex::checkInput() Error:\n"
               << "\tmagFilter must be GL_NEAREST or GL_LINEAR.\n";
            exit(1);
         }
}

/////////////////////////////////////////////////////////////
/// FuncTex
/////////////////////////////////////////////////////////////
FuncTex::FuncTex( GLenum texFunc )
: m_texFunc( texFunc ),
m_blendColor( vec4f(0.0f) )
{
   if( m_texFunc != GL_MODULATE &&
      m_texFunc != GL_REPLACE &&
      m_texFunc != GL_DECAL  ) {
         err() << "FuncTex::FuncTex(...) Error:\n"
            << "\ttexFunc must be GL_MODULATE, GL_REPEAT, or GL_DECAL.\n"
            << "\tUse the 'blendColor' constructor if GL_BLEND is required.\n";
         exit(1);
      }
}

FuncTex::FuncTex( const vec4f& blendColor )
: m_texFunc( GL_BLEND ),
m_blendColor( blendColor )
{}

void FuncTex::bind( GLenum texType ) const
{               
   glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, m_texFunc );

   if( m_texFunc ) {
      glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, m_blendColor.v() );
   }
}

///////////////////////////////////////////////////////////////////////////
/// PriorityTex - 'priority' is in [0,1] and sets the texture object's priority
///                        - 0.0 is lowest, 1.0 is highest priority
///////////////////////////////////////////////////////////////////////////
PriorityTex::PriorityTex( GLfloat priority )
{
   if( priority >= 0.0f &&
      priority <= 1.0f ) {
         m_priority = priority;
      }
   else {
      err() << "PriorityTex::PriorityTex(...) Error:\n"
         << "\tpriority must be in [0,1].\n";
      exit(1);
   }
}

void PriorityTex::bind( GLenum texType ) const
{
   glTexParameterf( texType, GL_TEXTURE_PRIORITY, m_priority );
}


/////////////////////////////////////////////////////////////
/// BorderTex
/////////////////////////////////////////////////////////////
BorderTex::BorderTex( const vec4f& color )
: m_color( color )
{}

void BorderTex::bind( GLenum texType ) const
{
   glTexParameterfv( texType, GL_TEXTURE_BORDER_COLOR, m_color.v() );
}

///////////////////////////////////////////////////////////////////////////
/// CoordGenTex 
///////////////////////////////////////////////////////////////////////////
CoordGenTex::CoordGenTex( GLenum coord, GLenum genMode )
: m_coord( coord ), m_genMode( genMode ), m_plane( vec4f(0.0f) ), m_state( VecStateP() )
{
   checkInput();
}

CoordGenTex::CoordGenTex( GLenum coord, GLenum genMode, const vec4f& planeCoeff, const VecStateP& state )
: m_coord( coord ), m_genMode( genMode ), m_plane( planeCoeff ), m_state( state )
{
   checkInput();
}

void CoordGenTex::checkInput()
{
   if( m_coord != GL_S &&
      m_coord != GL_T &&
      m_coord != GL_R &&
      m_coord != GL_Q  ) {
         err() << "CoordGenTex::checkInput() Error:\n"
            << "\tcoord must be GL_S, GL_T, GL_R, or GL_S.\n";
         exit(1);
      }

      if( m_genMode != GL_OBJECT_LINEAR &&
         m_genMode != GL_EYE_LINEAR &&
         m_genMode != GL_EYE_LINEAR &&
         m_genMode != GL_REFLECTION_MAP_ARB &&
         m_genMode != GL_NORMAL_MAP_ARB  ) {
            err() << "CoordGenTex::checkInput() Error:\n"
               << "\tgenMode must be GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP,\n" 
               << "\tGL_REFLECTION_MAP_ARB or GL_NORMAL_MAP_ARB.\n";
            exit(1);
         }

         switch( m_coord ) {
   case GL_S: m_coordGen = GL_TEXTURE_GEN_S; break;
   case GL_T: m_coordGen = GL_TEXTURE_GEN_T; break;
   case GL_R: m_coordGen = GL_TEXTURE_GEN_R; break;
   case GL_Q: m_coordGen = GL_TEXTURE_GEN_Q; break;
         }
}

void CoordGenTex::bind( GLenum texType ) const
{
   glEnable( m_coordGen );      
   glTexGeni( m_coord, GL_TEXTURE_GEN_MODE, m_genMode );

   if( m_genMode == GL_OBJECT_LINEAR ) {
      glTexGenfv(m_coord, GL_OBJECT_PLANE, m_plane.v() );
   }
   else if( m_genMode == GL_EYE_LINEAR ) {
      int i;
      for(i=0; i < (int)m_state.size(); i++) {
         m_state[i]->bind();
      }

      glTexGenfv(m_coord, GL_EYE_PLANE, m_plane.v() );

      for(i=m_state.size()-1; i >= 0; i--) {
         m_state[i]->release();
      }
   }
}

void CoordGenTex::release() const       /// Default: Disable automatic coordGen
{
   glDisable( m_coordGen );
}

---

Send questions, comments, and bug reports to: