texConst.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////
// 6/28/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 <texCoordGen/texConst.h>
#include <GL/glew.h>
#include <util/gliftUtil.h>
#include <iostream>

using namespace std;
using namespace gutz;

using namespace glift;

static const uint f_NUM_COORDS = 4;
static uint f_COORD_NUM[9]                         = { 0, 0, 1, 0, 2, 0, 0, 0, 3 }; /// Mapping from [GLIFT_S, GLIFTQ] to [0, 3]
static uint f_COORD_NAME[f_NUM_COORDS] = { 1, 2, 4, 8 };                                /// Mapping from [0, 3] to [GLIFT_S, GLIFT_Q]

TexConst::TexConst() : m_val(arrayo1f()), m_texUnit(0), m_coords(GLIFT_NONE), m_size(0), m_maxCoordDimen(0)
{}

TexConst::TexConst( float val, uint texUnit, uint coords )
: m_val(arrayo1f(1,val)), m_texUnit(texUnit), 
m_coords(coords), m_size( numOnesInWord(coords) ),
m_maxCoordDimen( maxCoordDimen(coords) )
{
   if( m_size != 1 ) {
      err() << "TexConst(...) Error:\n"
         << "\tScalar constant constructor must specify exactly 1 texture coordinate destination.\n";
      exit(1);
   }

   checkCoords();
}

TexConst::TexConst( const vec2f& val, uint texUnit, uint coords )
: m_val(arrayo1f(2,val.v())), m_texUnit(texUnit), m_coords(coords), 
m_size( numOnesInWord(coords) ), m_maxCoordDimen( maxCoordDimen(coords) )
{
   if( m_size != 2 ) {
      err() << "TexConst(...) Error:\n"
         << "\tvec2f constant constructor must specify exactly 2 texture coordinate destinations.\n";
      exit(1);
   }

   checkCoords();
}

TexConst::TexConst( const vec3f& val, uint texUnit, uint coords )
: m_val(arrayo1f(3,val.v())), m_texUnit(texUnit), m_coords(coords), 
m_size( numOnesInWord(coords) ), m_maxCoordDimen( maxCoordDimen(coords) )
{
   if( m_size != 3 ) {
      err() << "TexConst(...) Error:\n"
         << "\tvec3f constant constructor must specify exactly 3 texture coordinate destinations.\n";
      exit(1);
   }

   checkCoords();
}

// Return array of bools to show which texCoords are used by const
vec4<bool> TexConst::usedTexCoords() const
{
   vec4<bool> usedCoords(false);

   for(int c=0; c < f_NUM_COORDS; c++) {
      usedCoords[c] = (m_coords & f_COORD_NAME[c]) > 0;
   }

   return usedCoords;
}

/// Find the maximum coordinate index that is being used
/// TODO: There is a MUCH smarter way to do this!!
uint TexConst::maxCoordDimen( uint coords )
{
   uint maxCoord=0;
   if( GLIFT_Q_BIT & coords ) {
      maxCoord = f_COORD_NUM[ GLIFT_Q_BIT ];
   }
   else if( GLIFT_R_BIT & coords ) {
      maxCoord = f_COORD_NUM[ GLIFT_R_BIT ];
   }
   else if( GLIFT_T_BIT & coords ) {
      maxCoord = f_COORD_NUM[ GLIFT_T_BIT ];
   }
   else if( GLIFT_S_BIT & coords ) {
      maxCoord = f_COORD_NUM[ GLIFT_S_BIT ];
   }

   return maxCoord + 1;
}

void TexConst::checkCoords()
{       
   if( ((GLIFT_S_BIT & m_coords) && (f_COORD_NUM[GLIFT_S_BIT] > (uint)getLimitsGL().maxTexCoords)) ||
      ((GLIFT_T_BIT & m_coords) && (f_COORD_NUM[GLIFT_T_BIT] > (uint)getLimitsGL().maxTexCoords)) ||
      ((GLIFT_R_BIT & m_coords) && (f_COORD_NUM[GLIFT_R_BIT] > (uint)getLimitsGL().maxTexCoords)) ||
      ((GLIFT_Q_BIT & m_coords) && (f_COORD_NUM[GLIFT_Q_BIT] > (uint)getLimitsGL().maxTexCoords)) ) {
         err() << "checkCoords() Error:\n"
            << "\tOnly " << getLimitsGL().maxTexCoords << " are supported on this card.\n";
         exit(1);
      }
}

arrayo2f TexConst::operator()( const arrayw2f& rawTexCoord, const vec3f& primScale )
{
   int numVerts = rawTexCoord.dim(0);
   int coordDimen = max( (int)m_maxCoordDimen, rawTexCoord.dim(1) );
   arrayo2f texCoords( numVerts, coordDimen, (float)0 );

   if( m_coords==GLIFT_NONE ) {
      texCoords = rawTexCoord;
   }
   else {       //Set the constants where requested.
      for(int v=0; v < numVerts; v++) {
         int index=0;
         for(int c=0; c < coordDimen; c++) {
            if( f_COORD_NAME[c] & m_coords ) {
               texCoords[v][c] = m_val[index];
               index++;
            }
            else {      
               texCoords[v][c] = rawTexCoord[v][c];
            }
         }
      }
   }

   return texCoords;
}

---

Send questions, comments, and bug reports to: