glfTexture.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C)  2008, 2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS 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.

 BIAS 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 BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "glfTexture.hh"
#include "glfException.hh"

using namespace BIAS;

namespace BIAS {
  BIASOpenGLFramework_EXPORT void SwapGLObjects(glfTexture& A, glfTexture& B)
  {
    if(A.id_ == 0) {
      GLF_THROW_EXCEPTION("First Swap partner has no GL-Object assigned!");
    }
    if(B.id_ == 0) {
      GLF_THROW_EXCEPTION("Second Swap partner has no GL-Object assigned!");
    }
    if(A.target_!= B.target_) {
      GLF_THROW_EXCEPTION("swap partners relate to different targets!");
    }
    GLuint swapCache = A.id_;
    A.id_ = B.id_;
    B.id_ = swapCache;
  }
}

glfTexture&
glfTexture::operator=(const glfTexture& b)
{
  id_ = 0;
  target_ = b.target_;
  textureNr_ = b.textureNr_;
  enlargeToPot_ = b.enlargeToPot_;
  return *this;
}

glfTexture::glfTexture(const glfTexture& t)
{
  (*this) = t;
}

glfTexture::glfTexture(GLenum target)
{
  id_ = 0;
  target_ = target;
  textureNr_ = GL_TEXTURE0;
  enlargeToPot_ = false;
}

glfTexture::~glfTexture()
{
  if (id_ != 0)
    {
      glDeleteTextures(1, &id_);
    }
}

void
glfTexture::Create()
{
  if (id_ == 0)
    {
      glGenTextures(1, &id_);
    }
}

void
glfTexture::SetMinFilter(GLenum minFilter)
{
  Bind();
  glTexParameteri(target_, GL_TEXTURE_MIN_FILTER, (GLint) minFilter);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetMagFilter(GLenum magFilter)
{
  Bind();
  glTexParameteri(target_, GL_TEXTURE_MAG_FILTER, (GLint) magFilter);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetWrapS(GLenum wrapS)
{
  Bind();
  glTexParameteri(target_, GL_TEXTURE_WRAP_S, (GLint) wrapS);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetWrapT(GLenum wrapT)
{
  Bind();
  glTexParameteri(target_, GL_TEXTURE_WRAP_T, (GLint) wrapT);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetWrapR(GLenum wrapR)
{
  Bind();
  glTexParameteri(target_, GL_TEXTURE_WRAP_R, (GLint) wrapR);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetGenerateMipMap(bool generateMipMap)
{
  Bind();
  glTexParameteri(target_, GL_GENERATE_MIPMAP, (GLint) generateMipMap);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetBaseLevel(int baseLevel)
{
  Bind();
  glTexParameteri(target_, GL_TEXTURE_BASE_LEVEL, (GLint) baseLevel);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetMaxLevel(int maxLevel)
{
  Bind();
  glTexParameteri(target_, GL_TEXTURE_MAX_LEVEL, (GLint) maxLevel);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::SetBorderColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
{
  Bind();
  GLfloat rgba[4] =
    { r, g, b, a };
  glTexParameterfv(target_, GL_TEXTURE_BORDER_COLOR, rgba);
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfTexture::EnlargeToPowerOfTwoIfRequired(bool enlargeToPotIfRequired)
{
  bool supportNonPot = false;

#ifdef BIAS_HAVE_GLEW
  if (GLEW_ARB_texture_non_power_of_two)
    {
      supportNonPot = true;
    }
#endif

  if (supportNonPot)
    {
      enlargeToPot_ = false;
    }
  else
    {
      enlargeToPot_ = enlargeToPotIfRequired;
    }
}

int
glfTexture::GetMaxSupportedTextureUnits()
{
  GLint TUs = 0;
  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &TUs);\

  return static_cast<int> (TUs);
}

void
glfTexture::GenerateMipMap()
{
  if (!glewIsSupported("GL_EXT_framebuffer_object"))
    {
        GLF_THROW_EXCEPTION(
            "GL_EXT_framebuffer_object is not supported but required "
            "for glfTexture::GenerateMipMap");
    }
  Bind();
  glGenerateMipmapEXT(target_);
}

void
glfTexture::SetTextureNr(GLint textureNr)
{
  MAX_TEXTURE_UNITS_ = GetMaxSupportedTextureUnits();
  if ((textureNr >= GL_TEXTURE0) && (textureNr < (GL_TEXTURE0
  + MAX_TEXTURE_UNITS_)))
    {
      textureNr_ = textureNr;
    }
#ifdef BIAS_DEBUG
  else
    {
      BIASWARN("Invalid texture unit! Valid range is GL_TEXTURE0 - GL_TEXTURE"<<MAX_TEXTURE_UNITS_-1);
    }
#endif
}

void
glfTexture::SetTextureNrInUniformFormat(int textureNr)
{
  MAX_TEXTURE_UNITS_ = GetMaxSupportedTextureUnits();
  GLint textureNrGl = textureNr + GL_TEXTURE0;
  if ((textureNrGl >= GL_TEXTURE0) && (textureNrGl < (GL_TEXTURE0
  + MAX_TEXTURE_UNITS_)))
    {
      textureNr_ = textureNrGl;
    }
#ifdef BIAS_DEBUG
  else
    {
      BIASWARN("Invalid texture unit! Valid range is 0 - "<<MAX_TEXTURE_UNITS_-1);
    }
#endif
}

void
glfTexture::Bind() const
{
  BIASASSERT(id_ != 0);
  glBindTexture(target_, id_);
}

void
glfTexture::BindTU() const
{
  BIASASSERT(id_ != 0);

  glActiveTexture(textureNr_);

  glBindTexture(target_, id_);
}

void
glfTexture::BindTU(int number) const
{
  BIASASSERT(id_ != 0);

  glActiveTexture(GL_TEXTURE0+number);

  glBindTexture(target_, id_);
}

int
glfTexture::NextPowerOfTwo(int i)
{
  int result = 1;
  while (result < i)
    {
      result <<= 1;
    }
  return result;
}

// void
// glfTexture::
// GetFormatForInternalFormat(GLenum internalFormat, GLenum& format,
//                                        int& numChannels)
// {
//   switch (internalFormat)
//     {
// #ifdef GL_VERSION_3_0
//     case GL_R32F:
//       format = GL_RED;
//       numChannels = 1;
//       break;
// #endif

//   case GL_ALPHA:
//   case GL_ALPHA4:
//   case GL_ALPHA8:
//   case GL_ALPHA12:
//   case GL_ALPHA16:
//   case GL_COMPRESSED_ALPHA:
//   case GL_INTENSITY:
//   case GL_INTENSITY4:
//   case GL_INTENSITY8:
//   case GL_INTENSITY12:
//   case GL_INTENSITY16:
//   case GL_COMPRESSED_INTENSITY:
//     format = GL_ALPHA;
//     numChannels = 1;
//     break;

//   case GL_LUMINANCE:
//   case GL_LUMINANCE4:
//   case GL_LUMINANCE8:
//   case GL_LUMINANCE12:
//   case GL_LUMINANCE16:
//     //case GL_SLUMINANCE:
//     //case GL_SLUMINANCE8:
//   case GL_COMPRESSED_LUMINANCE:
//   case GL_LUMINANCE16F_ARB:
//   case GL_LUMINANCE32F_ARB:
//     //format = GL_LUMINANCE;
//     format = GL_RED;
//     numChannels = 1;
//     break;

//   case GL_LUMINANCE_ALPHA:
//   case GL_LUMINANCE4_ALPHA4:
//   case GL_LUMINANCE6_ALPHA2:
//   case GL_LUMINANCE8_ALPHA8:
//   case GL_LUMINANCE12_ALPHA4:
//   case GL_LUMINANCE12_ALPHA12:
//   case GL_LUMINANCE16_ALPHA16:
//     //case GL_SLUMINANCE_ALPHA:
//     //case GL_SLUMINANCE8_ALPHA8:
//   case GL_COMPRESSED_LUMINANCE_ALPHA:
//   case GL_LUMINANCE_ALPHA16F_ARB:
//   case GL_LUMINANCE_ALPHA32F_ARB:
//     format = GL_LUMINANCE_ALPHA;
//     numChannels = 2;
//     break;

//   case GL_R3_G3_B2:
//   case GL_RGB:
//   case GL_RGB4:
//   case GL_RGB5:
//   case GL_RGB8:
//   case GL_RGB10:
//   case GL_RGB12:
//   case GL_RGB16:
//     //case GL_SRGB:
//     //case GL_SRGB8:
//   case GL_COMPRESSED_RGB:
//   case GL_RGB16F_ARB:
//   case GL_RGB32F_ARB:
//     format = GL_RGB;
//     numChannels = 3;
//     break;

//   case GL_RGBA:
//   case GL_RGBA2:
//   case GL_RGBA4:
//   case GL_RGB5_A1:
//   case GL_RGBA8:
//   case GL_RGB10_A2:
//   case GL_RGBA12:
//   case GL_RGBA16:
//     //case GL_SRGB_ALPHA:
//     //case GL_SRGB8_ALPHA8:
//   case GL_COMPRESSED_RGBA:
//   case GL_RGBA16F_ARB:
//   case GL_RGBA32F_ARB:
//     format = GL_RGBA;
//     numChannels = 4;
//     break;

//   case GL_DEPTH_COMPONENT:
//   case GL_DEPTH_COMPONENT16:
//   case GL_DEPTH_COMPONENT24:
//   case GL_DEPTH_COMPONENT32:
//     format = GL_DEPTH_COMPONENT;
//     numChannels = 1;
//     break;
//   case GL_DEPTH24_STENCIL8_EXT:
//     format = GL_DEPTH_STENCIL_EXT;
//     numChannels = 2;
//     break;

//   default:
//     GLF_THROW_EXCEPTION("Unknown or invalid internal texture format")
//     ;
//     break;
//     }
// }

// GLenum
// glfTexture::GetPixelTypeForStorageType(ImageBase::EStorageType storageType)
// {
//   switch (storageType)
//     {
//   case ImageBase::ST_invalid:
//     GLF_THROW_EXCEPTION("Invalid storage type")
//     ;
//     break;
//   case ImageBase::ST_unsignedchar:
//     return GL_UNSIGNED_BYTE;
//   case ImageBase::ST_char:
//     return GL_BYTE;
//   case ImageBase::ST_unsignedshortint:
//     return GL_UNSIGNED_SHORT;
//   case ImageBase::ST_shortint:
//     return GL_SHORT;
//   case ImageBase::ST_unsignedint:
//     return GL_UNSIGNED_INT;
//   case ImageBase::ST_int:
//     return GL_INT;
//   case ImageBase::ST_float:
//     return GL_FLOAT;
//   case ImageBase::ST_double:
//     GLF_THROW_EXCEPTION("Storage type 'double' is not supported by OpenGL")
//     ;
//     break;
//   default:
//     GLF_THROW_EXCEPTION("Unknown storage type")
//     ;
//     break;
//     }
// }

// GLenum
// glfTexture::GetFormatForColorModel(ImageBase::EColorModel colorModel)
// {
//   switch (colorModel)
//     {
//   case ImageBase::CM_Grey:
//   case ImageBase::CM_Depth:
//   case ImageBase::CM_Disparity:
//     return GL_LUMINANCE;
//   case ImageBase::CM_GreyA:
//     return GL_LUMINANCE_ALPHA;
//   case ImageBase::CM_RGB:
//     return GL_RGB;
//   case ImageBase::CM_RGBA:
//     return GL_RGBA;
//   case ImageBase::CM_BGR:
//     return GL_BGR;
//   case ImageBase::CM_BGRA:
//     return GL_BGRA;
//   case ImageBase::CM_LUV:
//   case ImageBase::CM_LAB:
//     return GL_RGB;
//   default:
//     GLF_THROW_EXCEPTION("Color model " << colorModel << " is not supported by OpenGL")
//     ;
//     }
// }

// GLenum
// glfTexture::ProposeInternalFormat(ImageBase::EStorageType storageType,
//     ImageBase::EColorModel colorModel)
// {

//   if (storageType == ImageBase::ST_float)
//     {
//       switch (colorModel)
//         {
//       case ImageBase::CM_Grey:
//       case ImageBase::CM_Depth:
//       case ImageBase::CM_Disparity:
//         return GL_LUMINANCE32F_ARB;
//       case ImageBase::CM_GreyA:
//         return GL_LUMINANCE_ALPHA32F_ARB;
//       case ImageBase::CM_RGB:
//       case ImageBase::CM_LUV:
//       case ImageBase::CM_LAB:
//       case ImageBase::CM_BGR:
//         return GL_RGB32F_ARB;
//       case ImageBase::CM_RGBA:
//       case ImageBase::CM_BGRA:
//         return GL_RGBA32F_ARB;

//       default:
//         break; // suppress warning
//         }
//     }

//   if (storageType == ImageBase::ST_unsignedchar || storageType
//       == ImageBase::ST_unsignedshortint || storageType
//       == ImageBase::ST_unsignedint)
//     {
//       switch (colorModel)
//         {
//       case ImageBase::CM_Grey:
//         return GL_LUMINANCE;
//       case ImageBase::CM_GreyA:
//         return GL_LUMINANCE_ALPHA;
//       case ImageBase::CM_RGB:
//       case ImageBase::CM_BGR:
//         return GL_RGB;
//       case ImageBase::CM_RGBA:
//       case ImageBase::CM_BGRA:
//         return GL_RGBA;
//       default:
//         break; // suppress warning
//         }
//     }

//     GLF_THROW_EXCEPTION("Could not find appropriate OpenGL pixel format for "
//         "storage type " << storageType << " and color model "
//         << colorModel);

// }