singleTex.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/singleTex.h>

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

using namespace std;
using namespace gutz;

using namespace glift;

CoreTex::CoreTex( GLenum texType, const MultiTexOState& texState, TexData* texData, PBuffGlift* pbuff)
: m_texType(texType), 
//m_texObjState(texState), 
m_pbuff(pbuff), 
m_texNum(0),
m_tryToBindPbuff(true),
m_pbuffBound(false),
m_dataDimen( m_pbuff ? m_pbuff->dimen() : vec2i(0)),
m_tcNum(0)
{
   checkTexType( m_texType );

   /// Allocate OpenGL texture object
   glErr(estr(),"CoreTex() 1");
   glGenTextures(1, &m_texNum);
   glErr(estr(),"CoreTex","CoreTex() 2");
   if( m_texNum==0 ) {
      err() << "CoreTexture(...) Error:\n\tglGenTextures(...) failed.\n";
      exit(1);
   }

   /// Set all TexState for this texture object
   setTexState( texState );

   if( texData ) {
      bindDef();
      setTexData( texData, 0 );
      releaseDef();
   }

   glErr(estr(),"CoreTex","CoreTex");
}

CoreTex::~CoreTex()
{
   if( m_texNum > 0 ) {
      glDeleteTextures( 1, &m_texNum );
   }
   m_texNum = 0;
}

void CoreTex::checkTexType( GLenum texType )
{
   if( texType != GL_TEXTURE_1D &&
      texType != GL_TEXTURE_2D &&
      texType != GL_TEXTURE_3D &&
      texType != GL_TEXTURE_CUBE_MAP_ARB &&
      texType != GL_TEXTURE_RECTANGLE_NV &&
      texType != GL_TEXTURE_RECTANGLE_EXT ) {
         err() << "checkTexType(...) Error:\n"
            << "\ttexType is not valid.\n";
         exit(1);
      }
}

void CoreTex::bindDef()
{
   assert( m_texNum != 0 );

   if(m_texType!=GL_TEXTURE_RECTANGLE_NV) {
      glEnable(m_texType);
   }
   glErr(estr(),"CoreTex","bindDef 1");
   glBindTexture( m_texType, m_texNum );
   glErr(estr(),"CoreTex","bindDef 2");

   if( m_pbuff && m_tryToBindPbuff ) {
      m_pbuff->bind();
      m_pbuffBound = true;
   }
}

void CoreTex::releaseDef()
{
   if( m_pbuff && m_pbuffBound ) {
      m_pbuff->release();
      m_pbuffBound = false;
   }

   glBindTexture( m_texType, 0);
   if(m_texType!=GL_TEXTURE_RECTANGLE_NV) {
      glDisable(m_texType); 
   }
}

// Read texture data back from the card
void CoreTex::getDataub( GLenum format, int mipLevel, arraybub& data )
{
   vec3i dim = m_dataDimen;
   int numChannels = getNumChannels( format );

   // Check that data is sized correctly
   if( m_texType == GL_TEXTURE_1D ) {
      assert( data.dim(0) == dim.x );
      assert( data.dim(1) == numChannels ); 
   }
   else if( m_texType == GL_TEXTURE_2D ) {
      assert( data.dim(0) == dim.y );
      assert( data.dim(1) == dim.x );
      assert( data.dim(2) == numChannels ); 
   }
   else if( m_texType == GL_TEXTURE_3D ) {
      assert( data.dim(0) == dim.z );
      assert( data.dim(1) == dim.y );
      assert( data.dim(2) == dim.x );
      assert( data.dim(3) == numChannels );
   }
   else {
      err() << "getDataub(...) Error:\n\t"
         << "Only 1D, 2D, and 3D textures are supported.\n\t"
         << "TexCube must define its own getData*(...) functions.\n";
      exit(1);
   }

   // Do readback
   if( m_pbuff == NULL ) {
      bindDef();
      glGetTexImage( m_texType, mipLevel, format, GL_UNSIGNED_BYTE, data.data() );
      releaseDef();
   }
   else {
      // Method 1: doesn't work...
      //drawSingleTexQuad(this,false);
      //glReadPixels(0,0, dim.x, dim.y, format, GL_UNSIGNED_BYTE, data.data() );

      // Method 2: doesn't work...
      m_pbuff->release();
      m_pbuff->enable(true);
      glReadPixels(0, 0, dim.x, dim.y, format, GL_UNSIGNED_BYTE, data.data() );
      m_pbuff->disable();
   }
}

// Read texture data back from the card
void CoreTex::getDataf( GLenum format, int mipLevel, arraybf&  data )
{
   vec3i dim = m_dataDimen;
   int numChannels = getNumChannels( format );

   // Check that data is sized correctly
   if( m_texType == GL_TEXTURE_1D ) {
      assert( data.dim(0) == dim.x );
      assert( data.dim(1) == numChannels ); 
   }
   else if( m_texType == GL_TEXTURE_2D ) {
      assert( data.dim(0) == dim.y );
      assert( data.dim(1) == dim.x );
      assert( data.dim(2) == numChannels ); 
   }
   else if( m_texType == GL_TEXTURE_3D ) {
      assert( data.dim(0) == dim.z );
      assert( data.dim(1) == dim.y );
      assert( data.dim(2) == dim.x );
      assert( data.dim(3) == numChannels );
   }
   else {
      err() << "CoreTex::getDataf(...) Error:\n\t"
         << "Only 1D, 2D, and 3D textures are supported.\n\t"
         << "TexCube must define its own getData*(...) functions.\n";
      exit(1);
   }

   // Do readback
   if( m_pbuff == NULL ) {
      bindDef();
      glGetTexImage( m_texType, mipLevel, format, GL_FLOAT, data.data() );
      releaseDef();
   }
   else {
      m_pbuff->enable(true);
      glReadPixels(0, 0, dim.x, dim.y, format, GL_FLOAT, data.data() );
      m_pbuff->disable();
   }

}


/// Set individual texObjState
void CoreTex::setTexState( TexObjState* state )
{
   //m_texObjState << state;
   bindDef();
   state->bind( m_texType );
   releaseDef();
}

/// Set all state in 'texState' for this texture object
void CoreTex::setTexState( const MultiTexOState& texState )
{
   //m_texObjState = texState;
   //setTexObjState();            /// Reset the texture object state. 
   bindDef();
   texState.bind( m_texType );
   releaseDef();
}

/// - 'setTexSize' controls whether the texture size is set by this call
//    * Set to "FALSE" if this is a subTexture replace
void CoreTex::setTexData( TexData* texData, int mipLevel, bool setTexSize)
{
   checkTexType( m_texType, texData->texType() );

   if( setTexSize ) {
      m_dataDimen = texData->dimen();
   }
   bindDef();
   texData->setTexData( m_texType, mipLevel );
   releaseDef();
}

/// Ensure that the texture object and the data have compatible teturxture target types
void CoreTex::checkTexType( GLenum objTexType, GLenum dataTexType )
{
   if( objTexType == dataTexType ) /// If they are equal, alles klar.
   {
      return;
   }
   else {
      err() << "checkTexType(...) Error:\n\tIncompatible texture object and data texture target types.\n";
      exit(1);
   }               
}

---

Send questions, comments, and bug reports to: