pbuffGlift.h

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////////////
// 10/02/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 PBUFF_GLIFT_H
#define PBUFF_GLIFT_H

#include "stateGLI.h"
#include "../util/command.h"
#include <GL/pbuffer.h>
#include <mathGutz.h>
#include <vector>

namespace glift {

// Typedefs
class PBuffGlift;
typedef std::vector<PBuffGlift>  VecPbuff;
typedef std::vector<PBuffGlift*> VecPbuffP;

/////////////////////////////////
/// PBuffGlift
/////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////
//
/// PBuffGlift - An adapter class to turn a PBuffer into a StateGLI object
///                        - Adds the ability to initialize the render context via a 
///                              member or non-member callback, 'initCB'
//
///////////////////////////////////////////////////////////////////////////////
class PBuffGlift : public StateGLI
{
public:
   PBuffGlift( PBuffer* pbuff );
   PBuffGlift( int xDim, int yDim, uint mode, PBuffRenCTX renderCTX=NULL );

   // Initialize renderCTX by calling 'initCB'. Can be a member or non-member fcn callback.
   PBuffGlift( int xDim, int yDim, uint mode, VoidFuncPtr initCB, PBuffRenCTX renderCTX=NULL );
   PBuffGlift( int xDim, int yDim, uint mode, Command*   initCB, PBuffRenCTX renderCTX=NULL );

   // Using default copy constructor and assignment operator
   virtual ~PBuffGlift();

   // Enable/Disable pbuffer as a draw target
   // Disable will restore previous state if enable(true) was called.
   virtual void enable(bool saveState=false) {m_pbuff->enable(saveState);}
   void disable()                                         {m_pbuff->disable();           }

   // Set WGL_FRONT_LEFT_ARB,   WGL_AUX0_ARB, etc.
   void setSurface( GLenum surface )              {m_pbuff->setSurface(surface);}

   // Set mip level that is rendered to. Default = 0
   void setMipLevel( int level )                          {m_pbuff->setMipLevel(level);}

   // Set       WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, etc. : Default = POSITIVE_X
   void setCubeFace( GLenum cubeFace )            {m_pbuff->setCubeFace(cubeFace);}

   // Accessors
   inline PBuffer* pbuff() const;
   inline gutz::vec2i   dimen() const;                                           
   inline void                  dimen( int& xDim, int& yDim ) const;
   inline unsigned int  mode() const;
   inline int                   numSurfaces() const;
   inline PBuffRenCTX   renderCTX() const;

   // Convenience mode accessors
   bool hasRendToTex()  const {return m_pbuff->hasRendToTex();}
   bool hasMipMap()     const {return m_pbuff->hasMipMap();      }
   bool hasCube()               const {return m_pbuff->hasCube();        }

protected:
   virtual void bindDef()               { m_pbuff->bind(); }
   virtual void releaseDef()    { m_pbuff->release(); }

private:
   PBuffer* m_pbuff;
   Command* m_initCB;
   bool  m_deletePBuff;

   PBuffGlift();        // Disallow default construction
   void init(); // Initialize RenCTX via 'm_initCB'
};

// Inline accessors
inline PBuffer* PBuffGlift::pbuff() const
{
   return m_pbuff;
}

inline gutz::vec2i PBuffGlift::dimen() const
{
   int x,y; 
   m_pbuff->dimen(x,y); 
   return gutz::vec2i(x,y);
}

inline void PBuffGlift::dimen(int& x, int& y) const
{
   m_pbuff->dimen(x,y);
}

inline unsigned int PBuffGlift::mode() const
{
   return m_pbuff->mode();
}

inline int PBuffGlift::numSurfaces() const
{
   return m_pbuff->numSurfaces();
}

inline PBuffRenCTX PBuffGlift::renderCTX() const
{
   return m_pbuff->renderCTX();
}


} // End namespace

#endif

---

Send questions, comments, and bug reports to: