drawAttrib.h

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////
// 6/19/03      Joe Kniss       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_DRAWATTRIB_DOT_H
#define __GLIFT_DRAWATTRIB_DOT_H

#include "../core/gliftObject.h"
#include <GL/glew.h>
#include <GL/gl.h>
#include <utilGlift.h>
#include <arrayGutz.h>
#include <mathGutz.h>
#include <smartptr.h>
#include <iostream>

namespace glift {

/////////////////////////////////////////////////////////////////////////
///
/// drawAttrib.h
///
/// drawable Attributes, basic classes defining things like:
///  vertex arrays
///  texture coordinate arrays
///  etc...
/// Base Attribute
///////////////////////////////////////////////////////////////////////

class DrawAttrib : public GliftObject {
public:
   DrawAttrib(bool active = true):_active(active){}
   virtual ~DrawAttrib(){}

   void enable(){enableDef();}
   void disable(){enableDef();}

   ///////////////////////////////////////////
   /// turn an attribute on and off
   void activate(){_active = true;}
   void deactivate() {_active = false;}
   void setActive(bool onoff) {_active = onoff;}
   bool isActive(){return _active;}

protected:
   virtual void enableDef(){}
   virtual void disableDef(){}
   bool _active;
};

///////////////////////////////////////////////////////////////////////
/// Generic Attributes, usefull for vertex program attribute arrays
/// you can pick exactly what type of vector data you want for
/// an attribute (array of vectors for GL) by selecting the
/// appropriate type from "gutzAttrib.h", this will be the
/// template parameter for the attribute class.
///  For example, I want float 4 vectors, I create an attribute:
///  GenDrawAttrib<FloatV4A> my4vectorAttrib;
///////////////////////////////////////////////////////////////////////

template < class AT  > /// type of this attribute: see gutzAttrib.h
class GenDrawAttrib : public DrawAttrib, public gutz::Counted
{
public:
   GenDrawAttrib(unsigned int size,              // how big of an array
      unsigned int attribNum  = 0,    // attribute number (GL)
      GLboolean    normalized = false)// normalize fixed point types?
      :_v(size, typename AT::STORTYPE(0)),
      _size(size),
      _attribNum(attribNum), 
      _norm(normalized)
   {}
   GenDrawAttrib(const GenDrawAttrib &gda)
      :_v(gda._v),_size(gda._size),_attribNum(gda._attribNum),_norm(gda._norm)
   {}

   virtual ~GenDrawAttrib(){}

   /////////////////////////////////////////////////
   /// attribute vector storage type, float, vec2f, etc..
   typedef typename AT::STORTYPE STORTYPE;
   typedef typename AT::SYSTYPE SYSTYPE;
   typedef gutz::arrayWrap1<STORTYPE> ARRAY_TYPE;
   enum{
      DIM    = AT::DIM,
      GLTYPE = AT::GLTYPE
   };

   /////////////////////////////////////////////////
   /// Get the Data Array
   gutz::arrayWrap1<STORTYPE> 
      getArray() const {return gutz::arrayWrap1<STORTYPE>(_v);}

      /////////////////////////////////////////////////
      /// Set the Data Array
      void      setArray(gutz::arrayWrap1<STORTYPE> v){_v = v;}

      /////////////////////////////////////////////////
      /// The array should be bigger than what you need,
      /// if it is a dynamic array, set the size to
      /// indicate how much of the array is valid,
      /// should be -1 if none of it is.
      void         setSize(unsigned int size){_size = size;}
      unsigned int getSize() {return _size;}
protected:
   virtual void enableDef()
   {
      glEnableVertexAttribArrayARB(_attribNum);
      glVertexAttribPointerARB(_attribNum, DIM, GLTYPE, _norm, 0,_v.data());
      glerr("enableDef()");
   }
   virtual void disableDef()
   {
      glDisableVertexAttribArrayARB(_attribNum);
      glerr("disableDef()");
   }
   gutz::arrayOwn1<STORTYPE> _v;
   int        _attribNum;
   int        _size;
   GLboolean  _norm;
};

///////////////////////////////////////////////////////////////////////
/// Specific Attributes
/// The correspond to the standard openGL primitive vectors:
/// Vertex, Color, Normal, Texture etc...
/// Here are my mappings to generic Attributes:
/// Vertex = 0, Color1 = 1, Color2 = 2, Norm = 3, TEX = 4-20 
/// There may be a standard OGL mapping, but it isn't published ;)
///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////
/// Vertex array attribute
///////////////////////////////////////////////////////////////////////
template <class VAT> /// attribute type for a vertex array
class VertAttrib : public GenDrawAttrib<VAT>{
public:
   VertAttrib(int size)
      : GenDrawAttrib<VAT>(size, 0){}
      virtual ~VertAttrib(){}
protected:
   virtual void enableDef()
   { 
      glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(VAT::DIM, VAT::GLTYPE, 0, _v.data());
      glerr("enableDef()");
   }
   virtual void disableDef()
   {
      glDisableClientState(GL_VERTEX_ARRAY);
      glerr("disbleDef()");
   }
};
/// usefull typedefs, try to use these, no templates! hurray
typedef VertAttrib<FloatV2A> VertAttribV2F;
typedef VertAttrib<FloatV3A> VertAttribV3F;
typedef VertAttrib<FloatV4A> VertAttribV4F;

typedef VertAttrib<DoubleV2A> VertAttribV2D;
typedef VertAttrib<DoubleV3A> VertAttribV3D;
typedef VertAttrib<DoubleV4A> VertAttribV4D;

typedef VertAttrib<IntV2A> VertAttribV2I;
typedef VertAttrib<IntV3A> VertAttribV3I;
typedef VertAttrib<IntV4A> VertAttribV4I;

typedef VertAttrib<ShortV2A> VertAttribV2S;
typedef VertAttrib<ShortV3A> VertAttribV3S;
typedef VertAttrib<ShortV4A> VertAttribV4S;

///////////////////////////////////////////////////////////////////////
/// TexCoord array attribute
///////////////////////////////////////////////////////////////////////
template <class VAT> /// attribute type for a vertex array
class TexCoordAttrib : public GenDrawAttrib<VAT>{
public:
   TexCoordAttrib(int size, unsigned int texCoordNum=0)
      : GenDrawAttrib<VAT>(size, 4+texCoordNum ),_texNum(texCoordNum)
   {}
   virtual ~TexCoordAttrib(){}

protected:
   virtual void enableDef()
   { 
      glClientActiveTextureARB(GL_TEXTURE0_ARB + _texNum);
      glEnableClientState(GL_TEXTURE_COORD_ARRAY);
      glTexCoordPointer(VAT::DIM, VAT::GLTYPE, 0, _v.data());
      glClientActiveTextureARB(GL_TEXTURE0_ARB);
      glerr("enableDef()");
   }
   virtual void disableDef()
   {
      glClientActiveTextureARB(GL_TEXTURE0_ARB + _texNum);
      glDisableClientState(GL_TEXTURE_COORD_ARRAY);
      glClientActiveTextureARB(GL_TEXTURE0_ARB);
      glerr("disableDef()");
   }
   unsigned int _texNum;
};
/// usefull typedefs, try to use these, no templates! hurray
typedef TexCoordAttrib<FloatV1A> TexCoordAttribV1F;
typedef TexCoordAttrib<FloatV2A> TexCoordAttribV2F;
typedef TexCoordAttrib<FloatV3A> TexCoordAttribV3F;
typedef TexCoordAttrib<FloatV4A> TexCoordAttribV4F;

typedef TexCoordAttrib<DoubleV1A> TexCoordAttribV1D;
typedef TexCoordAttrib<DoubleV2A> TexCoordAttribV2D;
typedef TexCoordAttrib<DoubleV3A> TexCoordAttribV3D;
typedef TexCoordAttrib<DoubleV4A> TexCoordAttribV4D;

///////////////////////////////////////////////////////////////////////
/// Index array attribute
///////////////////////////////////////////////////////////////////////
template <class VAT> /// attribute type for a vertex array
class IndexAttrib : public GenDrawAttrib<VAT>
{
public:
   IndexAttrib(int size, unsigned int texCoordNum=0)
      : GenDrawAttrib<VAT>(size, 16 ){}
      virtual ~IndexAttrib(){}
protected:
   virtual void enableDef()
   { 
      glEnableClientState(GL_INDEX_ARRAY);
      glIndexPointer(VAT::GLTYPE, 0, _v.data());
      glerr("enableDef()");
   }
   virtual void disableDef()
   {
      glDisableClientState(GL_INDEX_ARRAY);
      glerr("disableDef()");
   }
};
typedef IndexAttrib<UIntV1A> IndexAttribV1UI;
typedef IndexAttrib<UIntV2A> IndexAttribV2UI;
typedef IndexAttrib<UIntV3A> IndexAttribV3UI;
typedef IndexAttrib<UIntV4A> IndexAttribV4UI;

typedef IndexAttrib<UShortV1A> IndexAttribV1US;
typedef IndexAttrib<UShortV2A> IndexAttribV2US;
typedef IndexAttrib<UShortV3A> IndexAttribV3US;
typedef IndexAttrib<UShortV4A> IndexAttribV4US;

typedef IndexAttrib<UByteV1A> IndexAttribV1UB;
typedef IndexAttrib<UByteV2A> IndexAttribV2UB;
typedef IndexAttrib<UByteV3A> IndexAttribV3UB;
typedef IndexAttrib<UByteV4A> IndexAttribV4UB;

///////////////////////////////////////////////////////////////////////
/// Normal array attribute
///////////////////////////////////////////////////////////////////////
template <class VAT> /// attribute type for a vertex array
class NormalAttrib : public GenDrawAttrib<VAT>
{
public:
   NormalAttrib(int size, unsigned int texCoordNum=0)
      : GenDrawAttrib<VAT>(size, 16 ){}
      virtual ~NormalAttrib(){}
protected:
   virtual void enableDef()
   { 
      glEnableClientState(GL_NORMAL_ARRAY);
      glNormalPointer(VAT::GLTYPE, 0, _v.data());
      glerr("enableDef()");
   }
   virtual void disableDef()
   {
      glDisableClientState(GL_NORMAL_ARRAY);
      glerr("disbleDef()");
   }
};
typedef NormalAttrib<FloatV3A>  NormalAttribV3F;
typedef NormalAttrib<DoubleV3A> NormalAttribV3D;
typedef NormalAttrib<IntV3A>    NormalAttribV3I;
typedef NormalAttrib<ShortV3A>  NormalAttribV3S;
typedef NormalAttrib<ByteV3A>   NormalAttribV3B;



}//end namespace glift

#endif

---

Send questions, comments, and bug reports to: