texCoordPerturb.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////
// 6/26/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/texCoordPerturb.h>
#include <iostream>

using namespace std;
using namespace gutz;

using namespace glift;

/*TexCoordPerturb::TexCoordPerturb( uint numTexUnits, const Vecarrayo1f& bias, const VecTexConst& texConst )
{
checkTexUnitMin( numTexUnits );

/// Create transforms from bias vectors.
VecTexTrans texTransform( bias.size() );
for(uint i=0; i < texTransform.size(); i++) {
texTransform[i] = TexTrans( bias[i] );
}

/// Initialize the perturbations
initTexTrans( numTexUnits, texTransform );
initTexConst( numTexUnits, texConst );
}
*/
TexCoordPerturb::TexCoordPerturb( uint numTexUnits, const VecTexConst& texConst )
{
   checkTexUnitMin( numTexUnits );

   /// Initialize the perturbations
   initTexConst( numTexUnits, texConst );

   //Identity transform for all texture units.
   m_texTrans = VecVecTexTrans(numTexUnits); 
   for(uint i=0; i < m_texTrans.size(); i++) {
      m_texTrans[i] = VecTexTrans(1,TexTrans());
   }
}

TexCoordPerturb::TexCoordPerturb( uint numTexUnits, const VecTexTrans& texTransform, const VecTexConst& texConst )
{
   checkTexUnitMin( numTexUnits );

   /// Initialize the perturbations
   initTexTrans( numTexUnits, texTransform );
   initTexConst( numTexUnits, texConst );
}

void TexCoordPerturb::initTexConst( uint numTexUnits, const VecTexConst& texConst )
{
   m_texConst = VecVecTexConst( numTexUnits );   /// Create "no-op" texture constants for all texture units
   arrayo1ui usedCoords(numTexUnits,(uint)0); /// Track which coords have been set for each texture unit

   /// Assign constants to the requested texture units 
   for(uint i=0; i < texConst.size(); i++) {
      uint t = texConst[i].texUnit();
      uint c = texConst[i].coords();            

      /// Ensure that 't' is in range.
      checkTexUnit( "initTexConst(...)", "texConst", t, i, numTexUnits );

      /// Set the constant for this texture unit unless one has already been set
      /// - Also ensure that the texture coordinates used do not overlap
      if( (usedCoords[t] & c)==0 ) {
         m_texConst[t].push_back( texConst[i] );
         usedCoords[t] |= c;
      }
      else {
         err() << "initTexConst(...) Error:\n"
            << "\tTexture unit " << t << " has conflicting constants assigned to it.\n";
         exit(1);
      }
   }
}

void TexCoordPerturb::initTexTrans( uint numTexUnits , const VecTexTrans& texTransform )
{
   m_texTrans = VecVecTexTrans( numTexUnits ); /// Create Identity transforms for all texture units
   VecBool hasConst(numTexUnits, false);         /// Track which texUnits have coord transforms to prevent multiples.

   for(uint i=0; i < texTransform.size(); i++) {
      uint t = texTransform[i].texUnit();

      /// Ensure that 't' is in range.
      checkTexUnit( "initTexTrans(...)", "texTransform", t, i, numTexUnits );

      /// Set the transform for this unit unless one has already been set.
      if( hasConst[t] == false ) {
         m_texTrans[t].push_back( texTransform[i] );
         hasConst[t]   = true;
      }
      else {
         err() << "initTexTrans(...) Error:\n"
            << "\tTexture unit " << t << " cannot have more than one coordinate transform assigned to it.\n";
         exit(1);
      }
   }
}

void TexCoordPerturb::checkTexUnitMin( uint numTexUnits )
{
   if( numTexUnits < 1 ) {
      err() << "checkTexUnitMin(...) Error:\n"
         << "\tnumTexUnits must be > 1.\n";
      exit(1);
   }
}

/// TODO: These 'char*'s should become std::strings when everything is moved over to std::
void TexCoordPerturb::checkTexUnit( const char* callingFuncName, const char* inputVecName,
                                   uint texUnit, uint vecIndex, uint maxTexUnits )
{
   if( texUnit >= maxTexUnits ) {
      err() << callingFuncName << " Error:\n"
         << "\t" << inputVecName << "[" << vecIndex << "] specifies a texture unit (" << texUnit
         << ") that is larger than\n" << "\t TexCoordPerturb::numTexUnits (" 
         << maxTexUnits << ").\n";
      exit(1);
   }
}

/// Generate appropriate texture coordinates, taking into account 
/// multiTexturing, texCoordTransforms, and texture contants
MultiTexCoord* TexCoordPerturb::genTexCoords( const arrayw2f& rawTexCoord, const vec3f& primScale )
{
   uint numTexUnits       = m_texConst.size(); /// Constructor ensures texConst.size() == texTrans.size()
   int  numVerts                  = rawTexCoord.dim(0);
   int  rawTexCoordDimen = rawTexCoord.dim(1);

   /// Create return data...
   MultiTexCoord* texCoordPtr = new MultiTexCoord( numTexUnits );
   MultiTexCoord& texCoords   = *texCoordPtr;

   /// Generate texture coords for each texture unit.
   /// - There are up to "n" texTrans and "m" texConsts for each texUnit
   for(uint t=0; t < numTexUnits; t++) {
      bool initialized = false;

      for(uint n=0; n < m_texTrans[t].size(); n++) {
         if(!initialized) {
            texCoords[t] = m_texTrans[t][n]( rawTexCoord,  primScale ); /// Apply transform
            initialized = true;
         }
         else {
            texCoords[t] = m_texTrans[t][n]( texCoords[t],  primScale );/// Apply transform
         }
      }

      for(uint m=0; m < m_texConst[t].size(); m++) {
         if(!initialized) {
            texCoords[t] = m_texConst[t][m]( rawTexCoord, primScale );  /// Apply constant
            initialized = true;
         }
         else {
            texCoords[t] = m_texConst[t][m]( texCoords[t], primScale ); /// Apply constant
         }
      }
   }

   return texCoordPtr;
}

---

Send questions, comments, and bug reports to: