singleTex.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_SINGLE_TEXTURE_H_
#define GLIFT_SINGLE_TEXTURE_H_

#include "multiTexState.h"
#include "texture.h"
#include "texData.h"
#include "../state/pbuffGlift.h"
#include <GL/glew.h>
#include <mathGutz.h>
#include <arrayGutz.h>
#include <vector>
#include <smartptr.h>

namespace glift {

/////////////////////////////////////////////////////////////////////////
///
/// SingleTex - Single texture base class.
///                      - NOT publicly constructable
///                      - Data may be passed in with 'setTexData(...)' or the pbuffer 
///                 memory may be used.
///                      - StateGLI is handled by calling 'setTexState(...)' 
///                 on the objects in the 'm_texState' array.
///                      - Designed to encapsulate all OpenGL texture functionality
///                      - Designed to be extensible by defining additional TexState classes
///
/// SingleTex - Abstract base class for all 
///                             Single texture classes
//////////////////////////////////////////////////
class _export_ SingleTex : 
   public Texture
{

public:
   virtual ~SingleTex() {}

   /// The 'Texture' interface
   virtual int                  numTexUnits() const     {return 1;} 
   /// 1D, 2D, 3D, CUBE_MAP, ...
   virtual GLenum                       texType() const                 = 0;
   /// The OpenGL texture number (name)
   virtual GLuint                       texNum() const                  = 0;
   /// Ptr to the pbuffer
   virtual PBuffGlift*  pbuff() const                   = 0;
   /// Dimen of the current data
   virtual gutz::vec3i  dimen() const                   = 0;
   /// will it try to use a pbuffer
   virtual bool                 tryToBindPbuff() const  = 0;

   /// set/get the texture coordinate number this texture should use
   virtual void            setTexCoordNum(int texCNum) = 0;
   virtual int             getTexCoordNum()            = 0;

   // Read texture data back from the card
   virtual void                 getDataub( GLenum format, int mipLevel, gutz::arraybub& data ) = 0;
   virtual void                 getDataf(  GLenum format, int mipLevel, gutz::arraybf&  data ) = 0;

   /// Set Functions
   /// Assume no cube map (Cube map subclass handles this)
   virtual void setTexData( TexData* texData, int mipLevel=0, bool setTexSize=true ) = 0;
   /// Add texture object state
   virtual void setTexState( TexObjState* state )                               = 0; 
   /// Bind new texState vector and set the state therein
   virtual void setTexState( const MultiTexOState& texState )  = 0; 
   /// Should the pbuffer be bound with the texture?
   virtual void tryToBindPbuff( bool tryToUsePbuff )                    = 0; 

   /// Call correct copyToTex. "texOrig" will ignore unused components depending on dimension of texture
   virtual void copyToTex( int mipLevel,
      const gutz::vec3i& texOrig, 
      const gutz::vec2i& screenOrig, 
      const gutz::vec2i& copySize   ) = 0;

protected:
   virtual void bindDef() = 0;
   virtual void releaseDef() = 0;
};

typedef gutz::SmartPtr<SingleTex> SingleTexSP;
typedef std::vector<SingleTexSP>  SingleTexSPVec;
typedef SingleTexSPVec::iterator  SingleTexSPVecIter;
const SingleTexSPVec              SingleTexSPVec_empty;


typedef std::vector<SingleTex*>  VecTexP;
typedef VecTexP::iterator        VecTexPIter;
const VecTexP  VecTexP_empty;

///////////////////////////////////////////////////////////////
/// CoreTex base class
//      - The "almost-concrete" implementation base class for single
//    textures. The only pure-virtual function is 'copyToTex(...)'
//  - Note: CoreTex does NOT own the 'texState' object...it just uses it.
//      - Note: The constructor can only be called by a subclass.
///////////////////////////////////////////////////////////////
class _export_ CoreTex : public SingleTex
{
public:
   /// Default copy constructor and assignment operator
   virtual ~CoreTex();

   /// Accessors
   virtual GLenum               texType() const                    {return m_texType; } /// 1D, 2D, 3D, CUBE_MAP, ...
   virtual GLuint                       texNum() const                     {return m_texNum;}           /// The OpenGL texture number
        virtual PBuffGlift*     pbuff() const                           {return m_pbuff; }              /// Ptr to the  pbuffer
   virtual gutz::vec3i  dimen() const                   {return m_dataDimen; }  /// Dimen of the current data
   virtual bool                 tryToBindPbuff() const  {return m_tryToBindPbuff; }

   /// set/get the texture coordinate number this texture should use
   virtual void            setTexCoordNum(int texCNum) {m_tcNum = texCNum;}
   virtual int             getTexCoordNum()            {return m_tcNum;}


   // Read texture data back from the card
   virtual void                 getDataub( GLenum format, int mipLevel, gutz::arraybub& data );
   virtual void                 getDataf(  GLenum format, int mipLevel, gutz::arraybf&  data );

   /// Set Functions
   /// Assume no cube map (Cube map subclass handles this)
   virtual void setTexData(  TexData* texData, int mipLevel=0, bool setTexSize=true );
   /// Set individual texObjState (gets added to m_texObjState)
   virtual void setTexState( TexObjState* state );                      
   /// Set all texture object state specified by 'texState'
   virtual void setTexState( const MultiTexOState& texState );  
   /// Should the pbuffer be bound with the texture?
   virtual void tryToBindPbuff( bool tryToUsePbuff ) {m_tryToBindPbuff = tryToUsePbuff;} 

protected:
   CoreTex( GLenum texType, const MultiTexOState& texState, TexData* texData, PBuffGlift* pbuff=NULL );

   /// The 'StateGLI' interface
   virtual void bindDef();
   virtual void releaseDef();

   /// Sanity checkers
   void checkTexType( GLenum texType );                                         /// Check for valid texType (1D, 2D, 3D, or CUBE)       

   /// Set functions
   void dataDimen( const gutz::vec3i& dimen ) { m_dataDimen = dimen; }

private:
   GLenum                        m_texType;        /// 1D, 2D, 3D, CUBE_MAP, ...
   //MultiTexOState m_texObjState;         /// Vector of TexObjState objects
   PBuffGlift*           m_pbuff;                  /// Ptr to pbuffer to bind as texture memory (or NULL)
   GLuint                        m_texNum;                 /// OpenGL texture object ID
   bool                     m_tryToBindPbuff; /// Should the pbuff be bound with the texture? (default to true)
   bool                     m_pbuffBound;          /// Is a pbuffer currently bound?
   gutz::vec3i   m_dataDimen;      /// Dimen of passed-in data

   int             m_tcNum;

   /// Ensure that texObj and data have compatible tex target types
   void checkTexType( GLenum objTexType, GLenum dataTexType );  

   CoreTex();           /// Disallow default construction                                         
};

} /// End of namespace glift

#endif

---

Send questions, comments, and bug reports to: