primGL.h

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////
// 6/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_PRIM_GL_H__
#define GLIFT_PRIM_GL_H__

#include "rawPrim.h"
#include "drawAlgorithm.h"
#include <GL/glew.h>

namespace glift {

/////////////////////////////////////////////////////////////////////////
///
///  PrimGL - GLIFT wrapper for an OpenGL primitive
///
///  - The 'm_scale' member requires some explaining:
///    It is the dimensions of the primitive that are used to determine
///    what size primitive is being texture mapped. It's values should
///    match the x,y,z dimensions (perhaps bounding box?) of the primitive.
///    It's values must be greater than 0 and should default to 1.0;
///
///  - 'drawAlgType' is one of the enumerated types def'd in "drawAlgorithm.h"
///    It defines the drawing algorithm to use (immediate, vertex array, etc).
///
///////////////////////////////////////////////////////////////////////

class _export_ PrimGL : public SinglePrim
{
public: 
   PrimGL( GLenum primType, GLint minVerts, GLint vertDivisor, const gutz::vec3f& scale,
      const gutz::arrayw2f&     vert, 
      const gutz::arrayw2f&     texCoord, 
      const gutz::arrayw2f&     norm            = gutz::arrayo2f(),  
      const gutz::arrayw1ui&    indices         = gutz::arrayo1ui(), 
      DrawAlg                                   drawAlgType = GLIFT_DRAW_IMM ); 

   PrimGL( GLenum primType, GLint minVerts, GLint vertDivisor, const gutz::vec3f& scale,
      const gutz::arrayw2f&     vert, 
      const gutz::arrayw2f&     texCoord, 
      const gutz::arrayw2f&     normalize       = gutz::arrayo2f(), 
      const gutz::arrayw1ui&    indices         = gutz::arrayo1ui(), 
      const gutz::arrayw2f&     color           = gutz::arrayo2f(), 
      const gutz::arrayw1ub&    edgeFlag        = gutz::arrayo1ub(), 
      DrawAlg                                   drawAlgType     = GLIFT_DRAW_IMM ); 

   PrimGL( const PrimGL& rhs );
   PrimGL& operator=( const PrimGL& rhs );

   virtual ~PrimGL();

   /// Set Functions
   virtual void bindTexCoords( const MultiPrimTexCoord* texCoords );
   virtual void bindTexCoords( const MultiTexCoord* texCoords );
   virtual void releaseTexCoords();

   virtual void bindIndices( const MultiPrimIndices* indices );
   virtual void bindIndices( const gutz::arrayw1ui* indices ); 
   virtual void releaseIndices();

   /// Constant Accessors
   virtual const gutz::arrayo2f&  vert()          const                         {return m_vert;}
   virtual const gutz::arrayo2f&  texCoord() const                              {return m_curTexCoords ? (*m_curTexCoords)[0]           : m_texCoords[0];}
   virtual const gutz::arrayo2f&  texCoord(int texUnit) const   {return m_curTexCoords ? (*m_curTexCoords)[texUnit] : m_texCoords[0];}
   virtual int                             numVerts() const                     {return m_vert.dim(0);}
   virtual const gutz::vec3f&     scale()    const                      {return m_scale;}
   virtual bool                                    hasTexCoords() const                 {return !m_texCoords[0].empty(); }

protected:
   virtual void drawDef();

private:
   GLenum                       m_primType;
   GLint                        m_minVerts;
   GLint                        m_vertDiv;
   gutz::vec3f                  m_scale;

   gutz::arrayo2f                       m_vert;
   MultiTexCoord                        m_texCoords;    /// m_texCoord[ texUnit ][ vertNum ][ texCoord ]
   const MultiTexCoord*         m_curTexCoords; /// The ptr to the current texture coordinates
   gutz::arrayo2f                       m_norm;
   gutz::arrayo2f                       m_color;
   gutz::arrayo1ub                      m_edgeFlag;             /// Is each vertex GL_TRUE/GL_FALSE an edge-forming vert?
   gutz::arrayo1ui                      m_indices;              /// Original indices (empty if all verts are to be drawn)
   const gutz::arrayw1ui*       m_curIndices;   /// Indices of which verts to draw (all drawn if empty)
   DrawAlgorithm*                       m_drawAlg;

   PrimGL();
   void initMembers(const PrimGL& rhs);
   void initMembers( GLenum primType, GLint minVerts, GLint vertDivisor, const gutz::vec3f& scale,
      const gutz::arrayw2f& vert,               const MultiTexCoord& texCoord,                  const MultiTexCoord* curTexCoords,
      const gutz::arrayw2f& normal,     const gutz::arrayw1ui& indices,         const gutz::arrayw2f& color, 
      const gutz::arrayw1ub& edgeFlag,  const gutz::arrayw1ui* curIndices,      DrawAlgorithm* drawAlg );

   void verifyScale();
   void verifySizes();
   void verifyMinVerts();
   void verifyPrimType();
   void verifyNumPrims();
   void setVertPos(             const gutz::arrayw2f& vert, int vertNum );
   void setTexCoords(           const Vecarrayw2f* curTexCoords, GLint vert );  /// Multi-texturing
   void outputTexCoords(        const MultiTexCoord& texCoords, int texCoordDimen, int texUnit, int vertNum );
};

} /// End of namespace glift

#endif

---

Send questions, comments, and bug reports to: