texState.h

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


#ifndef GLIFT_TEXSTATE_H_
#define GLIFT_TEXSTATE_H_

#include "../core/gliftObject.h"
#include <GL/glew.h>
#include "../state/stateGLI.h"
#include <mathGutz.h>
#include <vector>

namespace glift {

/// Typedefs
class TexState;
typedef std::vector<TexState>           VecTexState;
typedef std::vector<TexState*>          VecTexStateP;

class TexObjState;
typedef std::vector<TexObjState>        VecTexOState;
typedef std::vector<TexObjState*>       VecTexOStateP;

class TexUnitState;
typedef std::vector<TexUnitState>       VecTexUState;
typedef std::vector<TexUnitState*>      VecTexUStateP;

////////////////////////////////////////////////////////
/// Global, pre-defined TexState pointers
/// - These are here for conveniently pre-defined states that are common
////////////////////////////////////////////////////////
class EdgeModeTex;
class FilterTex;
class MipMapTex;
class FuncTex;
class CoordGenTex;

extern const EdgeModeTex        *TS_S_CLAMP, *TS_T_CLAMP, *TS_R_CLAMP, 
                           *TS_S_CLAMP_TO_EDGE, *TS_T_CLAMP_TO_EDGE, *TS_R_CLAMP_TO_EDGE, 
                           *TS_S_REPEAT, *TS_T_REPEAT, *TS_R_REPEAT;
extern const FilterTex          *TS_NEAREST, *TS_LINEAR;
extern const MipMapTex          *TS_NEAREST_MIPMAP_NEAREST, *TS_LINEAR_MIPMAP_NEAREST, *TS_LINEAR_MIPMAP_LINEAR;
extern const FuncTex               *TS_MODULATE, *TS_REPLACE, *TS_DECAL;


/////////////////////////////////////////////////////////////////////////
///
/// TexState - Abstract base class for all texture object state.
///                     - 'texType' is GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_CUBE_MAP_ARB, ...
///                     - Each subclass makes the appropriate OpenGL, texturing call when 'setTexState(...)' is called.
///                     - This is designed to be called after a texture is bound and only by 'SingleTex'.
///                       'setTexState(...)' has been left public for flexibility...use at your own risk.
///                     - This is _not_ part of the 'StateGLI' tree because of the need to pass 'texType' to
///                       'bind(texType)'. It is also justified because all of this OpenGL
///                       state is associated with a particular texture object or texture unit
///                       and is thus not general OpenGL state.
///                       
/// TexObjState         - TexState associated with an OpenGL texture object. \n
/// TexUnitState        - TexState associated with an OpenGL texture unit. \n
///
////////////////////
/// Concrete classes:
////////////////////
///
/// EdgeModeTex         - Boundary conditions. GL_REPEAT, GL_CLAMP, ... \n
/// FilterTex      - Filter mode: GL_NEAREST, GL_LINEAR. No mipmapping allowed \n
/// MipMapTex      - Filter modes for mipmapping, mipmap generation, LOD, ... \n
/// FuncTex                - Texture function: GL_REPLACE, GL_MODULATE, ... \n
/// PriorityTex - Texture priority: [0,1] \n
/// BorderTex      - Texture border color: gutz::vec4f \n
/// CoordGenTex - Automatic texture coordinate generation: GL_OBJECT_LINEAR,GL_NORMAL_MAP_ARB, .... \n
///
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////
/// TexState - Abstract base class for all texture state
////////////////////////////////////////////////////////
class _export_ TexState : public GliftObject
{
public:
   virtual ~TexState() {}
   virtual void bind( GLenum texType ) const = 0;
   virtual void release() const {}                      /// Most subclasses will not be 'release()'able.
};

////////////////////////////////////////////////////////
/// TexObjState - Abstract base class for all texture 
///                              state associated with a texture object
////////////////////////////////////////////////////////
class _export_ TexObjState : public TexState
{
public:
   virtual ~TexObjState() {}
   virtual void bind( GLenum texType ) const = 0;
   virtual void release() const {}                      /// Most subclasses will not be 'release()'able.
};

////////////////////////////////////////////////////////
/// TexUnitState - Abstract base class for all texture 
///                               state associated with a texture unit
////////////////////////////////////////////////////////
class _export_ TexUnitState : public TexState
{
public:
   virtual ~TexUnitState() {}
   virtual void bind( GLenum texType ) const = 0;
   virtual void release() const {}                      /// Most subclasses will not be 'release()'able.
};

////////////////////////////////////////////////////////
/// EdgeModeTex         - 'coord' is GL_S, GL_T, GL_R, GL_Q
///                             - 'edgeMode' is GL_CLAMP, GL_REPEAT, ...
////////////////////////////////////////////////////////
class _export_ EdgeModeTex : public TexObjState
{
public:
   EdgeModeTex( GLenum coord, GLenum edgeMode );
   virtual void bind( GLenum texType ) const;

   /// Set function
   void edgeMode( GLenum mode ) {m_edgeMode = mode;}

private:
   GLenum m_coord;
   GLenum m_edgeMode;

   void checkInput();
};

////////////////////////////////////////////////////////
/// FilterTex - 'minFilter' is minification filter: GL_NEAREST or GL_LINEAR
///                      - 'magFilter' is magnification filter: GL_NEAREST or GL_LINEAR
///                      -  Note: To use mipmapping, use the 'MipMapTex' class
////////////////////////////////////////////////////////
class _export_ FilterTex : public TexObjState
{
public:
   FilterTex( GLenum minFilter, GLenum magFilter );
   virtual void bind( GLenum texType ) const;

   /// Set functions
   void minFilter( GLenum filter ) {m_minFilter=filter;}
   void magFilter( GLenum filter ) {m_magFilter=filter;}

private:
   GLenum m_minFilter;
   GLenum m_magFilter;

   void checkInput( GLenum minFilter, GLenum magFilter );
};

////////////////////////////////////////////////////////
/// MipMapTex - 'minFilter' is minification filter:
///                                     GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, 
///                                     GL_NEAREST_MIPMAP_LINEAR,  GL_LINEAR_MIPMAP_LINEAR
///                      - 'magFilter' is magnification filter: GL_NEAREST or GL_LINEAR
///                      - 'autoMipGen' enables/diables GL_GENERATE_MIPMAP_SGIS
///                      - 'minLevel' is minimum mipmap level
///                      - 'maxLevel' is maximum mipmap level
///                      - 'minLOD'   is minimum mipmap lambda value
///                      - 'maxLOD'       is maximum mipmap lambda value
///                        Note: lambda = lg( rho ) base2 
///                                      rho   = scale factor between texture size and polygon
////////////////////////////////////////////////////////
class _export_ MipMapTex : public TexObjState
{
public:
   MipMapTex( GLenum minFilter, GLenum magFilter, bool autoMipGen=false );      /// Calls FilterTex constructor
   MipMapTex( GLenum minFilter, GLenum magFilter, bool autoMipGen,                      /// Calls FilterTex constructor
      int minLevel, int maxLevel, float minLOD, float maxLOD );

   virtual void bind( GLenum texType ) const;/// Calls FilterTex.bind(...)
   virtual void release() const;                          /// Disable autoMipGen, set level and LOD back to default (false, 0, 1000, -1000, +1000)

   /// Get/Set Functions
   bool         autoMipGen() const      {return m_autoMipGen;}
   int          minLevel() const        {return m_minLevel;}
   int          maxLevel() const        {return m_maxLevel;}
   float        minLOD() const          {return m_minLOD;}
   float        maxLOD() const          {return m_minLOD;}

   void minFilter( GLenum filt){m_minFilter = filt;}
   void magFilter( GLenum filt){m_magFilter = filt;}
   void autoMipGen( bool val )  {m_autoMipGen= val; }
   void minLevel( int val )     {m_minLevel      = val; }
   void maxLevel( int val )     {m_maxLevel      = val; }
   void minLOD(   float val )   {m_minLOD        = val; }
   void maxLOD(   float val )   {m_maxLOD        = val; }

private:
   const int    m_MIN_LEVEL; /// OpenGL defaults (according to RedBook 1.2)
   const int    m_MAX_LEVEL;
   const float m_MIN_LOD;
   const float m_MAX_LOD;

   GLenum       m_minFilter;    /// Input params
   GLenum       m_magFilter;
   bool m_autoMipGen;    
   int  m_minLevel;
   int          m_maxLevel;
   float        m_minLOD;
   float        m_maxLOD;

   void checkInput( GLenum minFilter, GLenum magFilter );
};

//////////////////////////////////////////////////////////////
/// FuncTex - 'texFunc' is GL_REPLACE, GL_MODULATE, GL_DECAL
///                -  Use the 'blendColor' constructor to use GL_BLEND
//////////////////////////////////////////////////////////////
class _export_ FuncTex : public TexUnitState
{
public:
   FuncTex( GLenum texFunc );                   
   FuncTex( const gutz::vec4f& blendColor );

   virtual void bind( GLenum texType ) const;

   gutz::vec4f color() const                    {return m_blendColor;}
   void  color( const gutz::vec4f& val ) {m_blendColor = val;}
   void  texFunc( GLenum mode ) {m_texFunc = mode;}

private:
   GLenum       m_texFunc;
   gutz::vec4f  m_blendColor;
};

////////////////////////////////////////////////////////////////////////////
/// PriorityTex - 'priority' is in [0,1] and sets the texture object's priority
///                        - 0.0 is lowest, 1.0 is highest priority
////////////////////////////////////////////////////////////////////////////
class _export_ PriorityTex : public TexObjState
{
public:
   PriorityTex( GLfloat priority );
   virtual void bind( GLenum texType ) const;

   GLfloat priority() const             {return m_priority;}
   void priority( GLfloat val ) {m_priority = val;}

private:
   GLfloat m_priority;
};

//////////////////////////////////////////////////////////////
/// BorderTex - 'color' sets the texture border color
//////////////////////////////////////////////////////////////
class _export_ BorderTex : public TexObjState
{
public:
   BorderTex( const gutz::vec4f& color );

   virtual void bind( GLenum texType ) const;

   gutz::vec4f color() const                    {return m_color;}
   void  color( const gutz::vec4f& col ) {m_color = col;}

private:
   gutz::vec4f m_color;
};

////////////////////////////////////////////////////////////////////////////
/// CoordGenTex - Set state for automatic texture coordinate generation
///                        - 'coord' is GL_S, GL_T, GL_R, GL_S
///                        - 'genMode' is GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, 
///                                                       GL_REFLECTION_MAP_ARB, GL_NORMAL_MAP_ARB
///                        - 'planeCoeff' contains the coefficients for the plane equation
///                        - 'state' is a vector of GenState ptrs to set the state before 
///                          setting the plane eqn with GL_EYE_LINEAR.
///                          Note: bind() and release() will be called for all pts in 'state'
////////////////////////////////////////////////////////////////////////////
class _export_ CoordGenTex : public TexUnitState
{
public:
   CoordGenTex( GLenum coord, GLenum genMode );
   CoordGenTex( GLenum coord, GLenum genMode, const gutz::vec4f& planeCoeff, const VecStateP& state=VecStateP() );

   virtual void bind( GLenum texType ) const;
   virtual void release() const;        /// Default: Disable automatic coordGen

   /// Accessors
   gutz::vec4f plane() const {return m_plane;}

   /// Set functions
   void plane( const gutz::vec4f& planeCoeff ) {m_plane = planeCoeff;}
   void genMode( GLenum mode )                    {m_genMode = mode;}

private:
   GLenum                       m_coord;        /// GL_S, GL_T, ...
   GLenum                       m_genMode;      /// GL_OBJECT_LINEAR, ...
   gutz::vec4f  m_plane;        /// Plane equation coefficients
   GLenum                       m_coordGen; /// GL_TEXTURE_GEN_S, ...
   VecStateP            m_state;        /// Vector of GenState pointers for setting EyeLinear plane.

   void checkInput();
};

} /// End of namespace glift

#endif

---

Send questions, comments, and bug reports to: