drawAlgArr.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////
// 8/13/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
////////////////////////////////////////////////////////////////////////

#include <drawable/drawAlgorithm.h>
#include <iostream>
#include <util/gliftUtil.h>
#include <GL/glUtil.h>

using namespace gutz;
using namespace std;

using namespace glift;

extern const GLenum g_texUnitName[NUM_TEX_UNIT_NAMES];

#ifndef NDEBUG 
//      #define SPEW_TEX_COORDS
#endif

/// WARNING: This assumes that all necessary arrays have been enabled. It sets pointers, but does
//                      not check for enabled state.
void DrawAlgArr::draw( GLenum primType, const arrayw2f& vert, const MultiTexCoord* curTexCoords,
                      const arrayw2f& norm, const arrayw2f& color, const arrayw1ub& edgeFlag,
                      const gutz::arrayw1ui* curIndices )
{
   /// Enable client state and set pointers
   /// TODO: Should only set pointers here. Enable client state
   ///       in 'init()' and leave enabled
   enable( vert, curTexCoords, norm, color, edgeFlag );

   /// Draw it!!
   if( curIndices==NULL ) {
      glDrawArrays( primType, 0, vert.dim(0) );
   }
   else {
      const arrayw1ui& indices = *curIndices;

      if( indices.dim(0) > 0 ) {
         /// TODO: Can/Should this be glRangeElements? Would have to pass in begin/end of indices
         glDrawElements( primType, indices.dim(0), GL_UNSIGNED_INT, indices.data() );
         //cerr << "DrawAlgArr::indices.dim(0) = " << indices.dim(0) << ", indices.data() = " << indices.data() << endl;
      }
   }

   /// TODO: Should not disable here, but still need to set glActiveTexture to 0.
   disable( vert, curTexCoords, norm, color, edgeFlag );

   glerr("draw(...)");
}

//static GLfloat*                       f_curVertPtr = NULL;
//static MultiTexCoord* f_curTexCoordsPtr = NULL;
//static vector<GLfloat*> f_curTexPtr(32,NULL);

void DrawAlgArr::enable( const arrayw2f& vert, const MultiTexCoord* curTexCoords,
                        const arrayw2f& norm, const arrayw2f& color, const arrayw1ub& edgeFlag )
{
   //   if( f_curVertPtr != vert.data() ) {     
   //           f_curVertPtr = (GLfloat*)vert.data();
   glEnableClientState(GL_VERTEX_ARRAY); /// Setup vertices
   glVertexPointer( vert.dim(1), GL_FLOAT, 0, vert.data() );
   //   }

   //   if( f_curTexCoordsPtr != curTexCoords ) {
   //           f_curTexCoordsPtr = (MultiTexCoord*)curTexCoords;

   if( curTexCoords ) {                 
      for( uint t=0; t < (*curTexCoords).size(); t++) { /// Setup texture coords        
         int texCoordDimen = (*curTexCoords)[t].dim(1);

         const GLfloat* dataPtr = (*curTexCoords)[t].data();
         //if( f_curTexPtr[t] != dataPtr) {
         //     f_curTexPtr[t] = (GLfloat*)dataPtr;
         glClientActiveTexture( g_texUnitName[t] );
         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
         glTexCoordPointer( texCoordDimen, GL_FLOAT, 0, dataPtr );
         //}
      }
   }
   //   }

   if( !norm.empty() ) {                                  /// Setup normals
      glEnableClientState(GL_NORMAL_ARRAY);
      glNormalPointer( GL_FLOAT, 0, norm.data() );
   }

   if( !color.empty() ) {                                 /// Setup colors
      glEnableClientState(GL_COLOR_ARRAY);
      glColorPointer( color.dim(1), GL_FLOAT, 0, color.data() );                
   }

   if( !edgeFlag.empty() ) {                      /// Setup edgeFlags
      glEnableClientState(GL_EDGE_FLAG);
      glEdgeFlagPointer(0, edgeFlag.data());
   }
}

void DrawAlgArr::disable(const arrayw2f& vert, const MultiTexCoord* curTexCoords,
                         const arrayw2f& norm, const arrayw2f& color, const arrayw1ub& edgeFlag )
{
   glDisableClientState(GL_VERTEX_ARRAY);
   if( !norm.empty() ) {
      glDisableClientState(GL_NORMAL_ARRAY);
   }
   if( !color.empty() ) {
      glDisableClientState(GL_COLOR_ARRAY);
   }
   if( !edgeFlag.empty() ) {
      glDisableClientState(GL_EDGE_FLAG_ARRAY);
   }

   if( curTexCoords ) {
      for( uint t=0; t < (*curTexCoords).size(); t++) { 
         glClientActiveTexture( g_texUnitName[t] );
         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
      }
   }
}

---

Send questions, comments, and bug reports to: