glfCubeMap.cpp

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

 Copyright (C) 2003-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 "glfCubeMap.hh"
#include "glfException.hh"
#include <Base/Image/ImageIO.hh>
#include "glfFormatDB.hh"

using namespace BIAS;

// border is currently not used.
const int BORDER_WIDTH = 0;

glfCubeMap::glfCubeMap() : glfTexture(GL_TEXTURE_CUBE_MAP)
{
}

void glfCubeMap::UploadImage(GLenum target, const ImageBase& image,
                             GLenum internalFormat, int mipmap)
{
  if (enlargeToPot_) {
    int potWidth = NextPowerOfTwo(image.GetWidth());
    int potHeight = NextPowerOfTwo(image.GetHeight());
    if ((int)image.GetWidth() != potWidth || (int)image.GetHeight() != potHeight) {
      ImageBase paddedImage;
      image.Pad(paddedImage, potWidth, potHeight);
      UploadImage(target, paddedImage, internalFormat, mipmap);
      return;
    }
  }

  // choose internal format if none is given
  if (internalFormat == 0) {
    internalFormat = glfFormatDB::ProposeInternalFormat(image.GetStorageType(), image.GetColorModel());
  }

  // get pixel format and pixel type of given image
  GLenum format = glfFormatDB::GetFormatForColorModel(image.GetColorModel());
  GLenum pixelType = glfFormatDB::GetPixelTypeForStorageType(image.GetStorageType());

  // upload data.
  Bind();
  glTexImage2D(target, mipmap, internalFormat,
               image.GetWidth(), image.GetHeight(), BORDER_WIDTH,
               format, pixelType, image.GetImageData());

  GLF_THROW_ON_OPENGL_ERROR;
}

void glfCubeMap::UploadImageFromFile(GLenum target, const std::string& fileName,
                                     GLenum internalFormat, int mipmap)
{
  ImageBase image;
  if (ImageIO::Load(fileName, image) != 0) {
    GLF_THROW_EXCEPTION("Could not load image: " << fileName);
  }
  UploadImage(target, image, internalFormat, mipmap);

  GLF_THROW_ON_OPENGL_ERROR;
}

void glfCubeMap::Allocate(int width, int height,
                          GLenum internalFormat, int mipmap)
{
  if (enlargeToPot_) {
    width = NextPowerOfTwo(width);
    height = NextPowerOfTwo(height);
  }

  GLenum format;
  int numChannels;
  glfFormatDB::GetFormatForInternalFormat(internalFormat, format, numChannels);

  Bind();
  for (int i = 0; i < 6; i++) {
    glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, mipmap,
                 internalFormat, width, height, BORDER_WIDTH,
                 format, GL_UNSIGNED_BYTE, NULL);
  }

  GLF_THROW_ON_OPENGL_ERROR;
}

void glfCubeMap::Allocate(int width, int height,
                          ImageBase::EStorageType storageType,
                          ImageBase::EColorModel colorModel,
                          int mipmap)
{
  GLenum internalFormat = glfFormatDB::ProposeInternalFormat(storageType, colorModel);
  Allocate(width, height, internalFormat, mipmap);
}

void glfCubeMap::CopyToImage(GLenum target, ImageBase& image, int mipmap)
{
  Bind();

  // get internal format of texture.
  GLenum internalFormat;
  glGetTexLevelParameteriv(target, mipmap,
                           GL_TEXTURE_INTERNAL_FORMAT,
                           (GLint*)&internalFormat);

  // get size
  int width = GetWidth(mipmap);
  int height = GetHeight(mipmap);

  // get format and number of channels
  GLenum format;
  int numChannels;
  glfFormatDB::GetFormatForInternalFormat(internalFormat, format, numChannels);

  // init image with size of texture and appropriate number of channels
  ImageBase::EStorageType storageType = image.GetStorageType();
  if (!image.IsEmpty()) {
    image.Release(); // ImageBase doesn't like re-Init ...
  }
  image.Init(width, height, numChannels, storageType);

  // get OpenGL pixel type
  GLenum type = glfFormatDB::GetPixelTypeForStorageType(image.GetStorageType());

  // copy texture to image
  glGetTexImage(target, mipmap, format, type, image.GetImageData());

  GLF_THROW_ON_OPENGL_ERROR;
}

void glfCubeMap::CopyChannelsToImage(GLenum target, BIAS::ImageBase& image,
                                     GLenum format, int mipmap)
{
  Bind();

  // get size
  int width = GetWidth(mipmap);
  int height = GetHeight(mipmap);

  // get number of channels
  int numChannels = 0;
  switch (format) {
  case GL_RED:
  case GL_GREEN:
  case GL_BLUE:
  case GL_ALPHA:
  case GL_LUMINANCE:
    numChannels = 1;
    break;
  case GL_LUMINANCE_ALPHA:
    numChannels = 2;
    break;
  case GL_RGB:
  case GL_BGR:
    numChannels = 3;
    break;
  case GL_RGBA:
  case GL_BGRA:
    numChannels = 4;
    break;
  default:
    GLF_THROW_EXCEPTION("Invalid format for CopyToImage");
    break;
  }

  // init image with size of texture and appropriate number of channels
  ImageBase::EStorageType storageType = image.GetStorageType();
  if (!image.IsEmpty()) {
    image.Release(); // ImageBase doesn't like re-Init ...
  }
  image.Init(width, height, numChannels, storageType);

  // get OpenGL pixel type
  GLenum type = glfFormatDB::GetPixelTypeForStorageType(image.GetStorageType());

  // copy texture to image
  glGetTexImage(target, mipmap, format, type, image.GetImageData());

  GLF_THROW_ON_OPENGL_ERROR;
}

int glfCubeMap::GetWidth(int mipmap) const
{
  GLint width;
  Bind();
  glGetTexLevelParameteriv(target_, mipmap, GL_TEXTURE_WIDTH, &width);
  GLF_THROW_ON_OPENGL_ERROR;
  return width;
}

int glfCubeMap::GetHeight(int mipmap) const
{
  GLint height;
  Bind();
  glGetTexLevelParameteriv(target_, mipmap, GL_TEXTURE_HEIGHT, &height);
  GLF_THROW_ON_OPENGL_ERROR;
  return height;
}