texNd.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////
// 9/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
////////////////////////////////////////////////////////////////////////

#include <texture/texNd.h>
#include <iostream>

using namespace std;
using namespace gutz;

using namespace glift;

////////////////////////////////////////
/// Tex1D - 1D Textures
////////////////////////////////////////
Tex1D::Tex1D( const MultiTexOState& texState, PBuffGlift* pbuff )
: CoreTex( GL_TEXTURE_1D, texState, NULL, pbuff )
{}

Tex1D::Tex1D( const MultiTexOState& texState, TexData* texData, PBuffGlift* pbuff )
: CoreTex( GL_TEXTURE_1D, texState, texData, pbuff )
{}

/// Copy data from framebuffer to this texture
void Tex1D::copyToTex( int mipLevel, const vec3i& texOrig, 
                      const vec2i& screenOrig, const vec2i& copySize )
{
   bindDef();
   glCopyTexSubImage1D( texType(), mipLevel, 
      texOrig.x,
      screenOrig.x, screenOrig.y,
      copySize.x  );
   releaseDef();
}

////////////////////////////////////////
/// Tex2D - 2D Textures
////////////////////////////////////////
Tex2D::Tex2D( const MultiTexOState& texState, PBuffGlift* pbuff )
: CoreTex( GL_TEXTURE_2D, texState, NULL, pbuff )
{}

Tex2D::Tex2D( const MultiTexOState& texState, TexData* texData, PBuffGlift* pbuff )
: CoreTex( GL_TEXTURE_2D, texState, texData, pbuff )
{}

/// Fill entire 2D texture from framebuffer
void Tex2D::copyToTex2D()               
{
   int mipLevel = 0;
   vec2i texOrig(0);
   vec2i screenOrig(0);
   vec2i dimen( dimen().x, dimen().y );

   copyToTex( mipLevel, texOrig, screenOrig, dimen );
}

/// Copy data from framebuffer to this texture
void Tex2D::copyToTex( int mipLevel, const vec3i& texOrig, 
                      const vec2i& screenOrig, const vec2i& copySize )
{
   bindDef();
   glCopyTexSubImage2D( texType(), mipLevel, 
      texOrig.x, texOrig.y,
      screenOrig.x, screenOrig.y,
      copySize.x, copySize.y );
   releaseDef();
}

////////////////////////////////////////
/// TexRect - Rectangle Textures
////////////////////////////////////////
TexRect::TexRect( const MultiTexOState& texState, PBuffGlift* pbuff )
: CoreTex( getTarget(), texState, NULL, pbuff )
{}

TexRect::TexRect( const MultiTexOState& texState, TexData* texData, PBuffGlift* pbuff )
: CoreTex( getTarget(), texState, texData, pbuff )
{}

/// Fill entire 2D texture from framebuffer
void TexRect::copyToTex2D()             
{
   int mipLevel = 0;
   vec2i texOrig(0);
   vec2i screenOrig(0);
   vec2i dimen( dimen().x, dimen().y );

   copyToTex( mipLevel, texOrig, screenOrig, dimen );
}

/// Copy data from framebuffer to this texture
void TexRect::copyToTex( int mipLevel, const vec3i& texOrig, 
                        const vec2i& screenOrig, const vec2i& copySize )
{
   bindDef();
   glCopyTexSubImage2D( texType(), mipLevel, 
      texOrig.x, texOrig.y,
      screenOrig.x, screenOrig.y,
      copySize.x, copySize.y );
   releaseDef();
}

GLenum TexRect::getTarget()
{
   GLenum target;
   if( glew.NV_texture_rectangle ) {
      target = GL_TEXTURE_RECTANGLE_NV;
   }
   else if( glew.EXT_texture_rectangle ) {
      target = GL_TEXTURE_RECTANGLE_EXT;
   }
   else {
      err() << "getTarget() Error:\n\tTexture rectangles not supported on this GPU.\n";
      exit(1);
   }
   return target;
}

////////////////////////////////////////
/// Tex3D - 3D Textures
////////////////////////////////////////
Tex3D::Tex3D( const MultiTexOState& texState, TexData* texData )
: CoreTex( GL_TEXTURE_3D, texState, texData )
{}

/// Copy data from framebuffer to this texture
void Tex3D::copyToTex( int mipLevel, const vec3i& texOrig, 
                      const vec2i& screenOrig, const vec2i& copySize )
{
   bindDef();
   glCopyTexSubImage3D( texType(), mipLevel, 
      texOrig.x, texOrig.y, texOrig.z,
      screenOrig.x, screenOrig.y,
      copySize.x, copySize.y );
   releaseDef();
}

////////////////////////////////////////
/// TexCube - CubeMap Textures
////////////////////////////////////////
TexCube::TexCube( const MultiTexOState& texState, const VecTexDataP& texData )
: CoreTex( GL_TEXTURE_CUBE_MAP_ARB, texState, NULL ),
m_pbuff( VecPbuffP(6) ),
m_writeFace( GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB )
{
   initPbuffVec( NULL, NULL, NULL, NULL, NULL, NULL );

   if( texData.size() == 6 ) {
      initData( texData );
   }
   else if( texData.size() > 0 ) {
      err() << "TexCube(...) Error:\n"
         << "\ttexData must contain 6 TexData pointers.\n";
      exit(1);
   }
}

TexCube::TexCube( const MultiTexOState& texState, PBuffGlift* pbPX, PBuffGlift* pbNX, 
                 PBuffGlift* pbPY, PBuffGlift* pbNY, PBuffGlift* pbPZ, PBuffGlift* pbNZ,
                 const VecTexDataP& texData )
                 : CoreTex( GL_TEXTURE_CUBE_MAP_ARB, texState, NULL ),
                 m_pbuff( VecPbuffP(6) ),
                 m_writeFace( GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB )
{
   initPbuffVec( pbPX, pbNX, pbPY, pbNY, pbPZ, pbNZ );

   /// Ensure that no pbuffers are NULL
   for(uint i=0; i < m_pbuff.size(); i++) {
      if( m_pbuff[i] == NULL ) {
         err() << "TexCube(...) Error\n"
            << "\tPbuffer[" << i << "] == NULL. All pbuffers must be non-NULL.\n";
         exit(1);
      }
   }

   /// Initialize all 6 cube faces
   if( texData.size() == 6 ) {
      initData( texData );
   }
   else if( texData.size() > 0 ) {
      err() << "TexCube(...) Error:\n"
         << "\ttexData must contain 6 TexData pointers.\n";
      exit(1);
   }
}

void TexCube::initPbuffVec( PBuffGlift* pbPX, PBuffGlift* pbNX,  PBuffGlift* pbPY, PBuffGlift* pbNY, 
                           PBuffGlift* pbPZ, PBuffGlift* pbNZ )
{
   m_pbuff[0] = pbPX;
   m_pbuff[1] = pbPX;
   m_pbuff[2] = pbPY;
   m_pbuff[3] = pbNY;
   m_pbuff[4] = pbPZ;
   m_pbuff[5] = pbNZ;
}

void TexCube::initData(  const VecTexDataP& texData )
{
   setTexData( GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, texData[0] );
   setTexData( GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, texData[1] );
   setTexData( GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, texData[2] );
   setTexData( GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, texData[3] );
   setTexData( GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, texData[4] );
   setTexData( GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, texData[5] );
}

/// Set the target for a glCopyTexImage(...)
void TexCube::setCopyCubeFace( GLenum cubeFace )                
{
   checkCubeFace( cubeFace );
   m_writeFace = cubeFace;
}

/// Fill entire cubeFace with entire framebuffer contents
void TexCube::copyToTex( GLenum cubeFace )
{
   checkCubeFace( cubeFace ); /// Ensure that cubeFace is valid
   m_writeFace = cubeFace;

   vec2i texOrig(0);
   vec2i screenOrig(0);
   vec2i copyDimen( dimen().x, dimen().y );

   copyToTex( 0, texOrig, screenOrig, copyDimen );
}

/// Copy data from framebuffer to this texture
void TexCube::copyToTex( int mipLevel, const vec3i& texOrig, 
                        const vec2i& screenOrig, const vec2i& copySize )
{
   bindDef();
   glCopyTexSubImage2D( m_writeFace, mipLevel, 
      texOrig.x, texOrig.y,
      screenOrig.x, screenOrig.y,
      copySize.x, copySize.y );
   releaseDef();
}

/// CubeMap set function. 
/// - setTexSize controls whether the texture size is set by this call
//    * Set to "FALSE" if this is a subTexture replace
void TexCube::setTexData( GLenum cubeFace, TexData* texData, int mipLevel, bool setTexSize )
{
   /// Ensure that it is 2D data
   if( texData->texType() != GL_TEXTURE_2D ) {
      err() << "setTexData(...) Error:\n"
         << "\ttexData must be two dimensional.\n";
      exit(1);
   }

   /// Ensure that cubeFace is valid
   checkCubeFace( cubeFace );

   /// Set the texture data
   if( setTexSize ) {
      dataDimen( texData->dimen() );
   }
   bindDef();
   texData->setTexData(cubeFace, mipLevel);
   releaseDef();
}

/// Ensure that cubeFace is valid
void TexCube::checkCubeFace( GLenum cubeFace )
{
   if( cubeFace != GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
      cubeFace != GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB &&
      cubeFace != GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB &&
      cubeFace != GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB &&
      cubeFace != GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB &&
      cubeFace != GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB )
   {
      err() << "checkCubeFace(...) Error:\n\tInvalid cubeFace.\n";
      exit(1);
   }
}

void TexCube::bindDef()
{
   /// Bind this texture object
   CoreTex::bindDef();

   /// Bind the pbuffers for each face
   /// Note: If the 1st pbuffer is non-NULL, the constructor gaurantees that they are all non-NULL
   if( m_pbuff[0] && tryToBindPbuff() ) {
      for(uint i=0; i < m_pbuff.size(); i++) {
         m_pbuff[i]->bind();
      }
   }
}

void TexCube::releaseDef()
{
   /// Release the pbuffers for each face
   if( m_pbuff[0] && tryToBindPbuff() ) {
      for(uint i=0; i < m_pbuff.size(); i++) {
         m_pbuff[i]->release();
      }
   }

   /// Release the texture object
   CoreTex::releaseDef();
}

---

Send questions, comments, and bug reports to: