primGL.cpp

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
////////////////////////////////////////////////////////////////////////
//
//  PrimGL - GLIFT wrapper for an OpenGL primitive
//
// 
/////////////////////////////////////////////////////////////////////

#include <drawable/primGL.h>
#include <iostream>
#include <assert.h>

using namespace std;
using namespace gutz;

using namespace glift;

PrimGL::PrimGL( GLenum primType, GLint minVerts, GLint vertDivisor, const vec3f& scale,
               const arrayw2f& vert, const arrayw2f& texCoord, const arrayw2f& normal,  
               const arrayw1ui& indices, DrawAlg drawAlgType)
{
   bool hasTexCoords = (texCoord.size() > 0);
   MultiTexCoord  texCoords = hasTexCoords ? MultiTexCoord(1,texCoord) : MultiTexCoord(1);
   MultiTexCoord* curTexCoords = hasTexCoords ? &m_texCoords : NULL;

   arrayw1ui* curIndices = indices.empty() ? NULL : &m_indices;

   initMembers( primType, minVerts, vertDivisor, scale, vert, 
      texCoords, curTexCoords, normal, indices, arrayo2f(), 
      arrayo1ub(), curIndices, makeDrawAlg( drawAlgType ) );
}

PrimGL::PrimGL( GLenum primType, GLint minVerts, GLint vertDivisor, const vec3f& scale,
               const arrayw2f& vert, const arrayw2f& texCoord, const arrayw2f& normal, 
               const arrayw1ui& indices, const arrayw2f& color, const arrayw1ub& edgeFlag, 
               DrawAlg drawAlgType )
{
   bool hasTexCoords = (texCoord.size() > 0);
   MultiTexCoord  texCoords = hasTexCoords ? MultiTexCoord(1,texCoord) : MultiTexCoord(1);
   MultiTexCoord* curTexCoords = hasTexCoords ? &m_texCoords : NULL;

   arrayw1ui* curIndices = indices.empty() ? NULL : &m_indices;

   initMembers( primType, minVerts, vertDivisor, scale, vert, 
      texCoords, curTexCoords, normal, indices, color, edgeFlag, 
      curIndices, makeDrawAlg( drawAlgType ) );
}

PrimGL::PrimGL( const PrimGL& rhs )
{
   initMembers( rhs );
}

PrimGL& PrimGL::operator=( const PrimGL& rhs )
{
   if( &rhs != this ) {
      initMembers(rhs);
   }
   return *this;
}

PrimGL::~PrimGL()
{
   delete m_drawAlg;
}

void PrimGL::initMembers( GLenum primType, GLint minVerts, GLint vertDivisor, const vec3f& scale,
                         const arrayw2f& vert, const MultiTexCoord& texCoords, const MultiTexCoord* curTexCoords,
                         const arrayw2f& normal, const arrayw1ui& indices, const arrayw2f& color, 
                         const arrayw1ub& edgeFlag, const arrayw1ui* curIndices, DrawAlgorithm* drawAlg )
{
   if( vert.size() == 0 ) {
      err() << "initMembers(...) Error:\n\tvert.size() == 0.\n";
      exit(1);
   }

   m_primType = primType;
   m_minVerts = minVerts;
   m_vertDiv  = vertDivisor; 
   m_scale    = scale;
   m_vert          = vert;
   m_texCoords= texCoords;
   m_curTexCoords = curTexCoords;
   m_norm     = normal;
   m_indices  = indices;
   m_color         = color;
   m_edgeFlag = edgeFlag;
   m_curIndices  = curIndices;
   m_drawAlg  = drawAlg;

   assert( m_drawAlg != NULL );
   verifyScale();
   verifySizes();
   verifyMinVerts();
   verifyPrimType();
   verifyNumPrims();
}

void PrimGL::initMembers(const PrimGL& rhs)
{
   initMembers( rhs.m_primType, rhs.m_minVerts, rhs.m_vertDiv, rhs.m_scale,
      rhs.m_vert, rhs.m_texCoords, rhs.m_curTexCoords, 
      rhs.m_norm, rhs.m_indices, rhs.m_color, rhs.m_edgeFlag, rhs.m_curIndices,
      rhs.m_drawAlg );
}

void PrimGL::verifyScale()
{               
   if( m_scale.x < 1.0 ||
      m_scale.y < 1.0 ||
      m_scale.z < 1.0 )
   {
      err() << "verifyScale() Warning:\n"
         << "\tm_scale has a component smaller than 1.0.\n";
   }

   const float SMALL = 1e-3f;
   if( m_scale.x < SMALL ||
      m_scale.y < SMALL ||
      m_scale.z < SMALL )
   {
      err() << "verifyScale() Error:\n"
         << "\tscale must not have any components that are less than " << SMALL << endl;
      exit(1);
   }
}

void PrimGL::verifySizes()
{
   if( m_vert.dim(0) != m_norm.dim(0) &&
      m_norm.size() > 0 ) {
         err() << "verifySizes() Error:\n"
            << "\tNot the same number of verts(" << m_vert.dim(0) << ") and normals ("
            << m_norm.dim(0) << ").\n";
         exit(1);
      }
      if( m_vert.dim(0) != m_color.dim(0) &&
         m_color.size() > 0 ) {
            err() << "verifySizes() Error:\n"
               << "\tNot the same number of verts(" << m_vert.dim(0) << ") and colors ("
               << m_color.dim(0) << ").\n";
            exit(1);
         }

         if( hasTexCoords() &&             
            m_vert.dim(0) != m_texCoords[0].dim(0) ) { /// Size must match verts
               err() << "verifySizes() Error:\n"
                  << "\tNot the same number of verts(" << m_vert.dim(0) << ") and texCoords ("
                  << m_texCoords[0].dim(0) << ").\n";
               exit(1);
            }

            if( m_texCoords.size() > 1 ) {
               err() << "verifySizes() Error:\n"
                  << "\tInput more than a single set of texture coordinates.\n"
                  << "\tMust apply a MultiTexture via ShadedPrim to generate multiple\n"
                  << "\tsets of texture coordinates.\n";
               exit(1);
            }

            if( m_edgeFlag.size() > 0 &&                /// Must specify none or all edges
               m_vert.dim(0) != m_edgeFlag.size() ) { 
                  err() << "verifySizes() Error:\n"
                     << "\tedgeFlag array (" << m_edgeFlag.size() << ") must be either empty or the same size as verts(" 
                     << m_vert.dim(0) << ").\n";                
               }
}

void PrimGL::verifyMinVerts()
{
   if( m_vert.dim(0) < m_minVerts ) {
      err() << "verifyMinVerts() Error:\n\tNot enough vertices (" << m_vert.dim(0) << ")\n"
         << "\tThis primitive requires at least " << m_minVerts << " number of vertices.\n";
      exit(1);
   }
}

void PrimGL::verifyPrimType()
{
   switch( m_primType )
   {
   case GL_POINTS:
   case GL_LINES:
   case GL_LINE_STRIP:
   case GL_LINE_LOOP:
   case GL_TRIANGLES:
   case GL_TRIANGLE_STRIP:
   case GL_TRIANGLE_FAN:
   case GL_QUADS:
   case GL_QUAD_STRIP:
   case GL_POLYGON:
      break;            //Supported primitive so alles klar.
   default:
      err() << "verifyPrimType() Error:\n\tUnsupported primitive (" << m_primType << ")\n";
      exit(1);
      break;
   }
}

void PrimGL::verifyNumPrims()
{
   bool bad = false;
   if( m_indices.empty() ) { //Check the number of verts
      if( (numVerts() % m_vertDiv ) != 0 ) {
         bad = true;
      }
   }                    /// Check number of indices if using index-drawing
   else if( (m_indices.size() % m_vertDiv ) != 0 ) {
      bad = true;
   }

   if( bad ) {
      err() << "verifyNumPrims() Error:\n"
         << "\tNumber of primitives must be divisible by\n"
         << m_vertDiv << " for this primitive (" << m_primType << ")\n";
      exit(1);
   }
}

void PrimGL::bindTexCoords( const MultiPrimTexCoord* texCoordsPtr )
{
   if( isCompiled() ) {
      err() << "bindTexCoords(...) Error:\n"
         << "\tCannot bind new tex coords to compiled\n"
         << "\tprimitive.\n";
      exit(1);
   }

   m_curTexCoords = (*texCoordsPtr)[0];
}

void PrimGL::bindTexCoords( const MultiTexCoord* texCoordsPtr )
{
   if( isCompiled() ) {
      err() << "bindTexCoords(...) Error:\n"
         << "\tCannot bind new tex coords to compiled\n"
         << "\tprimitive.\n";
      exit(1);
   }

   m_curTexCoords = texCoordsPtr;
}

void PrimGL::releaseTexCoords()
{
   m_curTexCoords = &m_texCoords;
}

void PrimGL::bindIndices(       const MultiPrimIndices* indices )
{
   if( isCompiled() ) {
      err() << "bindIndices(...) Error:\n"
         << "\tCannot bind new indices to compiled\n"
         << "\tprimitive.\n";
      exit(1);
   }

   m_curIndices = (*indices)[0];

   //   if( DrawAlgArr* drawAlg = dynamic_cast<DrawAlgArr*>(m_drawAlg) ) {
   //           drawAlg->enable( m_vert, m_curTexCoords, m_norm, m_color, m_edgeFlag  );
   //   }
}

void PrimGL::bindIndices( const arrayw1ui* indices )
{
   if( isCompiled() ) {
      err() << "bindIndices(...) Error:\n"
         << "\tCannot bind new indices to compiled\n"
         << "\tprimitive.\n";
      exit(1);
   }

   m_curIndices = indices;//Assign reference

   //   if( DrawAlgArr* drawAlg = dynamic_cast<DrawAlgArr*>(m_drawAlg) ) {
   //           drawAlg->enable( m_vert, m_curTexCoords, m_norm, m_color, m_edgeFlag  );
   //   }
}

void PrimGL::releaseIndices()
{
   /// Draw all vertices specified by the constructor
   m_curIndices = m_indices.empty() ? NULL : &m_indices;
}

void PrimGL::drawDef()
{
   m_drawAlg->draw( m_primType, m_vert, m_curTexCoords, m_norm, 
      m_color, m_edgeFlag, m_curIndices );
}

---

Send questions, comments, and bug reports to: