subdivPlanarQuadS.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
////////////////////////////////////////////////////////////////////////
//
// SubdivPlanarQuadS.cpp: implementation of the SubdivPlanarQuadS class.
//
/////////////////////////////////////////////////////////////////////

#include <drawable/subdivPlanarQuadS.h>
#include <drawable/primsGL.h>

#include <iostream>
#include <math.h>

using namespace std;
using namespace gutz;

using namespace glift;

SubdivPlanarQuadS::SubdivPlanarQuadS( GLenum primType, const vec2i& subDiv, const vec2f& lowerLeft, 
                                     const vec2f& upperRight, bool genTexCoords, bool genNorms,
                                     bool sharedVerts, TexCoordGen* texGen )
{
   m_useShared = sharedVerts;

   init( primType, subDiv, lowerLeft, upperRight, 0.0f, 
      genTexCoords, genNorms, texGen ); 
}

SubdivPlanarQuadS::SubdivPlanarQuadS( GLenum primType, const vec2i& subDiv, const vec2f& lowerLeft, 
                                     const vec2f& upperRight, float z, bool genTexCoords, bool genNorms,
                                     bool sharedVerts, TexCoordGen* texGen )
{
   m_useShared = sharedVerts;

   init( primType, subDiv, lowerLeft, upperRight, z, 
      genTexCoords, genNorms, texGen ); 
}

SubdivPlanarQuadS::~SubdivPlanarQuadS()
{
   /*   for(int i=0; i < m_tiles.dim(0); i++) {
   for(int j=0; j < m_tiles.dim(1); j++) {
   delete m_tiles[i][j];
   }
   }
   */
}

/// Create subDivQuad with shared vertices (minimum number of possible verts)
void SubdivPlanarQuadS::init( GLenum primType, const vec2i& subDiv,
                             const vec2f& lowerLeft, const vec2f& upperRight, 
                             float z, bool genTexCoords, bool genNorms,
                             TexCoordGen* texGen )
{
   m_lowerLeft = lowerLeft;
   m_upperRight = upperRight;
   m_subDiv = subDiv;
   m_z = z;
   m_numActivePatches = subDiv.x * subDiv.y;

   if( isPowOfTwo(m_subDiv.x) && isPowOfTwo(m_subDiv.y) ) {
      m_lgSubDiv = vec2i( int(log(float(m_subDiv.x))/log(2.0f)), int(log(float(m_subDiv.y))/log(2.0f)) );
   }

   int numPatches = subDiv.x * subDiv.y;
   m_indices = arrayo1ui( numPatches*4, (unsigned int)0 );/// Possibility of 4 vertices per patch

   if( primType != GL_QUADS ) {//&&
      //        primType != GL_TRIANGLES ) {
      err() << "initMembers Error:\n"
         << "\tprimType must be GL_QUADS.\n";/// or GL_TRIANGLES.\n";
      exit(1);
   }

   /// Setup the texture coordinate generation functor
   bool createdTexGen = false;
   if( genTexCoords && texGen==NULL )  {
      texGen = new ScaleTexGen2D();
      createdTexGen = true;
   }
   else if( genTexCoords==false && texGen ) {
      err() << "createStrips(...) Error:\n"
         << "\tIllegal to disable texCoordGeneration and pass\n"
         << "\tin alternate texCoordGenerator.\n";
      exit(1);
   }

   vec3f normVec(0.0f, 0.0f, 1.0f);     //Constant for this primitive since always orthog to z-axis.
   vec3f quadScale( (float)fabs(upperRight.x - lowerLeft.x),  /// Scale factor for entire quad
      (float)fabs(upperRight.y - lowerLeft.y),
      1.0f );

   /// Generate vertices, norms, and indices
   arrayo2f vert, norm;
   arrayo1ui indices;

   if( m_useShared ) {
      initShared( subDiv, quadScale, z, normVec, vert, norm, indices );
   }
   else {
      initRedundant( subDiv, quadScale, z, normVec, vert, norm, indices );
   }

   norm = genNorms ? norm : arrayo2f();

   /// Generate texture coordinates based on vertices and dimen of quad
   arrayo2f texCoord = genTexCoords ? texGen->genTexCoords( vert, quadScale ) : arrayo2f();

   /// Generate the PixelTiles
   //initTiles( vert, texCoord, indices );

   /// Generate the primitive
   PrimGL* prim=NULL;
   switch(primType) {
   case GL_QUADS:       
      prim = new QuadsGL( vert, texCoord, quadScale, norm, indices, 
         arrayo2f(), arrayo1ub(), GLIFT_DRAW_IMM );
      break;
      /*        case GL_TRIANGLES: 
      prim = new TrianglesGL( vert, texCoord, quadScale, norm, indices, 
      gutz::arrayo2f(), gutz::arrayo1ub(), GLIFT_DRAW_ARR );
      break;
      */
   default: err() << "init(...):\n\tUnsupported primitive.\n\n";
      exit(1);
   }

   if( createdTexGen ) {
      delete texGen;
   }

   WrappedPrim::init( prim );
   m_prim = prim;
}

// Create the tiles 
/*void SubdivPlanarQuadS::initTiles( const arrayo2f& vert, const arrayo2f& texCoord, arrayo1ui& indices )
{
const int NUM_TILES = m_subDiv.y * m_subDiv.x;
const int NUM_INDICES = NUM_TILES * 4;
assert( indices.dim(0) == NUM_INDICES );

m_tiles = arrayOwn2<PixelTile*>(m_subDiv.y, m_subDiv.x, (PixelTile*)NULL);

int startIndex=0;
int tileIndex =0;
for(int r=0; r < m_subDiv.y; r++ ) {            /// Row
for(int c=0; c < m_subDiv.x; c++) {     /// Column
arrayw1ui tileIndices(4, &(indices[startIndex]));
startIndex += 4;

m_tiles[r][c] = new PixelTile( vert, texCoord, tileIndices, tileIndex );
tileIndex++;
}
}
}*/

void SubdivPlanarQuadS::initShared( const vec2i& subDiv, const vec3f& quadScale, float z, const vec3f& normVec, 
                                   arrayo2f& vert, arrayo2f& norm, arrayo1ui& indices )
{
   const int NUM_VERTS_SHARE = (subDiv.x + 1) * (subDiv.y + 1);
   const int NUM_VERTS_ALL   = (subDiv.x + subDiv.y) * (subDiv.x + subDiv.y);
   vec2f     patchDimen( quadScale.x/subDiv.x,             /// Dimension of each subdivision patch
      quadScale.y/subDiv.y );

   /// Allocate memory for the data.
   /// TODO: Joe hacked these, I don't know what the intent of the original was!!!!
   //vert = arrayo2f( NUM_VERTS_SHARE, 3, (int)0 );
   vert = arrayo2f( NUM_VERTS_SHARE, 3, (float)0.0f );
   //norm = arrayo2f( NUM_VERTS_SHARE, 3, (int)0 );
   norm = arrayo2f( NUM_VERTS_SHARE, 3, (float)0.0f );
   //indices = arrayo1ui( NUM_VERTS_ALL,  (int)0);
   indices = arrayo1ui( NUM_VERTS_ALL,  (unsigned int)0);

   /// Create all vertices, norms, and indices
   int v=0; //Vertex  number
   int i=0; //Indices number

   for(int r=0; r <= subDiv.y; r++ ) {          /// Row
      for(int c=0; c <= subDiv.x; c++) {        /// Column

         vec3f curPos( patchDimen.x*c, patchDimen.y*r, z );/// Start at bottom-left corner

         vert[v][0] = curPos.x;
         vert[v][1] = curPos.y;
         vert[v][2] = curPos.z;

         norm[v][0] = normVec[0];
         norm[v][1] = normVec[1];
         norm[v][2] = normVec[2];

         if( r < subDiv.y ) {/// Set Indices
            if( c == 0 ) {  /// Left edge
               indices[i] = v;
               i++;
            }
            else {
               /// Finish out this quad
               indices[i+0] = v; 
               indices[i+1] = v + subDiv.x + 1; 
               indices[i+2] = v + subDiv.x;
               i+=3;

               if( c != subDiv.x ) { /// Not on right edge...TODO: Should this be c < subDiv.w?
                  /// First vertex of the next quad
                  indices[i] = v;
                  i++;
               }
            }
         }

         v++; //Increment vertex number
      }
   }
}

void SubdivPlanarQuadS::initRedundant( const vec2i& subDiv, const vec3f& quadScale, float z, const vec3f& normVec,
                                      gutz::arrayo2f& vert, gutz::arrayo2f& norm, arrayo1ui& indices )
{       
   const int NUM_VERTS = (subDiv.x + subDiv.y) * (subDiv.x + subDiv.y);//All vertices are repeated!!
   vec2f     patchDimen( quadScale.x/subDiv.x,             /// Dimension of each subdivision patch
      quadScale.y/subDiv.y );
   vec2f          dim = patchDimen;

   /// Allocate memory for the data.
   vert = gutz::arrayo2f( NUM_VERTS, 3, (float)0 );
   norm = gutz::arrayo2f( NUM_VERTS, 3, (float)0 );
   indices = arrayo1ui( NUM_VERTS, (unsigned int)0 );

   /// Create all vertices, norms, and indices
   int v = 0;                                                           /// Vertex index
   for(int r=0; r < subDiv.y; r++ ) {           /// Row
      for(int c=0; c < subDiv.x; c++) { /// Column

         Vecvec3f pos(4);
         pos[0] = vec3f(dim.x*c,                dim.y*r,         z );/// Start at bottom-left corner
         pos[1] = vec3f(dim.x*(c+1), dim.y*r,    z );
         pos[2] = vec3f(dim.x*(c+1), dim.y*(r+1), z );
         pos[3] = vec3f(dim.x*c,                dim.y*(r+1), z );

         /// Compute all vertices, norms, and indices for this patch
         for(int i=0; i < 4; i++) { 
            vert[v][0] = pos[i].x;
            vert[v][1] = pos[i].y;
            vert[v][2] = pos[i].z;

            norm[v][0] = normVec[0];
            norm[v][1] = normVec[1];
            norm[v][2] = normVec[2];

            indices[v] = v;

            v++;
         }
      }
   }
}

void SubdivPlanarQuadS::bindQuads( const arrayw1ui& patchIndices )
{
   /// Optimization Note: The Conditionals in the loop are loop-invariant
   //                                     so they should be optimized out by any decent compiler.

   int i=0; //Indices counter
   m_indices.reshape( m_subDiv.x * m_subDiv.y * 4 );//Reset to original size
   vec2i numVerts( m_subDiv.x + 1, m_subDiv.y + 1 );
   bool wIsPowOfTwo = isPowOfTwo( m_subDiv.x );

   m_numActivePatches = patchIndices.dim(0);
   for(int p=0; p < patchIndices.dim(0); p++) { /// Loop over all enabled indices
      int index = patchIndices[p];

      /// Get (row, col) coords for this index
      int r,c;
      if( wIsPowOfTwo ) {       
         r = index >> m_lgSubDiv.x;
         c = mod_fast(index, m_subDiv.x);
      }
      else {
         r = index / m_subDiv.x;
         c = index % m_subDiv.x;
      }

      if( m_useShared ) {
         m_indices[i+0] = numVerts.x * r + c;
         m_indices[i+1] = numVerts.x * r + (c + 1);
         m_indices[i+2] = numVerts.x * (r + 1) + (c + 1);
         m_indices[i+3] = numVerts.x * (r + 1) + c;
         i+=4;
      }
      else {
         int start = (m_subDiv.x * r + c) * 4;

         for(int v=0; v < 4; v++) {
            m_indices[i] = start + v;
            i++;
         }
      }
   }

   if( m_useShared ) {
      m_indices.reshape( i-3 );
   }
   else {
      m_indices.reshape( i );
   }

   bindIndices( &m_indices );
}

/// Specify which patches are to be drawn by their subdiv coords
void SubdivPlanarQuadS::bindQuads( const Vecvec2i& patches )
{
   int i=0; //Indices counter
   m_indices.reshape( m_subDiv.x * m_subDiv.y * 4 );//Reset to original size
   m_numActivePatches = patches.size();

   if( m_useShared ) {
      vec2i numVerts( m_subDiv.x + 1, m_subDiv.y + 1 );

      for(int p=0; p < (int)patches.size(); p++) {
         vec2i patch = patches[p];

         if( patch >= m_subDiv ) {
            err() << "bindQuads(...):\n\tPatch coordinate out of bounds.\n";
            exit(1);
         }

         m_indices[i+0] = numVerts.x * patch.y + patch.x;
         m_indices[i+1] = numVerts.x * patch.y + patch.x + 1;
         m_indices[i+2] = numVerts.x * (patch.y + 1) + patch.x + 1;
         m_indices[i+3] = numVerts.x * (patch.y + 1) + patch.x;
         i+=4;
      }

      m_indices.reshape(i-3); //Shrink current size, but do NOT delallocate memory
   }
   else { /// Redundant vertices
      for(int p=0; p < (int)patches.size(); p++){
         if( patches[p] >= m_subDiv ) {
            err() << "bindQuads(...):\n\tPatch coordinate out of bounds.\n";
            exit(1);
         }

         int start = (m_subDiv.x * patches[p].y + patches[p].x) * 4;

         for(int v=0; v < 4; v++) {
            m_indices[i] = start + v;
            i++;
         }
      }

      m_indices.reshape(i); //Shrink current size, but do NOT delallocate memory
   }

   bindIndices( &m_indices );
}

---

Send questions, comments, and bug reports to: