Texture.cc

/***********************************************************************
 * Copyright 2011-2012 Computer Graphics Group RWTH Aachen University. *
 * All rights reserved.                                                *
 * Distributed under the terms of the MIT License (see LICENSE.TXT).   *
 **********************************************************************/

#include <ACGL/OpenGL/Objects/Texture.hh>
#include <ACGL/OpenGL/glloaders/extensions.hh> // for anisotrophic filtering

using namespace ACGL::OpenGL;

#ifndef ACGL_OPENGLES_VERSION_20
void TextureBase::setWrapS( GLenum _wrapS )
{
    glBindTexture(mTarget, mObjectName);
    mWrapS = _wrapS;
    glTexParameteri(mTarget, GL_TEXTURE_WRAP_S, mWrapS);
}

void TextureBase::setWrapT( GLenum _wrapT )
{
    glBindTexture(mTarget, mObjectName);
    mWrapT = _wrapT;
    glTexParameteri(mTarget, GL_TEXTURE_WRAP_T, mWrapT);
}

void TextureBase::setWrapR( GLenum _wrapR )
{
    glBindTexture(mTarget, mObjectName);
    mWrapR = _wrapR;
    glTexParameteri(mTarget, GL_TEXTURE_WRAP_R, mWrapR);
}

void TextureBase::setWrap( GLenum _wrapS, GLenum _wrapT, GLenum _wrapR )
{
    glBindTexture(mTarget, mObjectName);

    mWrapS = _wrapS;
    glTexParameteri(mTarget, GL_TEXTURE_WRAP_S, mWrapS);

    if(_wrapT != 0)
    {
        mWrapT = _wrapT;
        glTexParameteri(mTarget, GL_TEXTURE_WRAP_T, mWrapT);
    }

    if(_wrapR != 0)
    {
        mWrapR = _wrapR;
        glTexParameteri(mTarget, GL_TEXTURE_WRAP_R, mWrapR);
    }

    openGLRareError();
}
#endif // ACGL_OPENGLES_VERSION_20

void TextureBase::setAnisotropicFilter( GLfloat _sampleCount )
{
    if ( ACGL_EXT_texture_filter_anisotrophic() ) {
        // anisotrophic filtering is supported:
        _sampleCount = std::max( _sampleCount, 1.0f );
        _sampleCount = std::min( _sampleCount, ACGL_MAX_TEXTURE_MAX_ANISOTROPY );
        glBindTexture( mTarget, mObjectName );
        glTexParameterf( mTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, _sampleCount );
        openGLRareError();
    } else
    {
        if (_sampleCount != 1.0f ) {
            // anisotropic filtering will just increase the image quality, so this is just
            // a warning and no error, 1 sample is equal to no anisotrophic filtering, so ignore
            // that case entirely!
            ACGL::Utils::warning() << "Anisotropic filtering is not supported, ignored" << std::endl;
        }
    }
}

void TextureBase::generateMipmaps(void)
{
    glBindTexture(mTarget, mObjectName);
#if (!defined ACGL_OPENGL_PROFILE_CORE)
    // on some ATI systems texturing has to be enabled to generate MipMaps
    // this is not needed by the spec an deprecated on core profiles (generates
    // an error on MacOS X Lion)
    glEnable(mTarget);
    openGLRareError();
#endif
#ifdef ACGL_OPENGL_VERSION_21
    // OpenGL 2 way to generate MipMaps
    glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
#else
    glGenerateMipmap(mTarget);
#endif
    openGLRareError();
}

//////////////////////////////////////////////////////////////////////////
//
// old Texture class:

#ifndef ACGL_OPENGLES_VERSION_20
SharedTextureData Texture::getImageData(GLint _lod, GLenum _type) const
{
    if(_type == GL_INVALID_ENUM) _type = mType;

    // remember the previously bound texture
    GLint prevTexture;
    
    if     (mTarget == GL_TEXTURE_1D)                   glGetIntegerv(GL_TEXTURE_BINDING_1D,                   &prevTexture);
    else if(mTarget == GL_TEXTURE_2D)                   glGetIntegerv(GL_TEXTURE_BINDING_2D,                   &prevTexture);
    else if(mTarget == GL_TEXTURE_3D)                   glGetIntegerv(GL_TEXTURE_BINDING_3D,                   &prevTexture);
    else if(mTarget == GL_TEXTURE_1D_ARRAY)             glGetIntegerv(GL_TEXTURE_BINDING_1D_ARRAY,             &prevTexture);
    else if(mTarget == GL_TEXTURE_2D_ARRAY)             glGetIntegerv(GL_TEXTURE_BINDING_2D_ARRAY,             &prevTexture);
    else if(mTarget == GL_TEXTURE_RECTANGLE)            glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE,            &prevTexture);
    else if(mTarget == GL_TEXTURE_2D_MULTISAMPLE)       glGetIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE,       &prevTexture);
    else if(mTarget == GL_TEXTURE_2D_MULTISAMPLE_ARRAY) glGetIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, &prevTexture);
    // determine the required buffer size to hold the requested LOD level
    bind();
    GLint width, height, depth;
    glGetTexLevelParameteriv(mTarget, _lod, GL_TEXTURE_WIDTH,  &width);
    glGetTexLevelParameteriv(mTarget, _lod, GL_TEXTURE_HEIGHT, &height);
    glGetTexLevelParameteriv(mTarget, _lod, GL_TEXTURE_DEPTH,  &depth);

    // fetch the image data
    int channels = 4;
    if (mFormat == GL_RGB) channels = 3; // TODO: check the other channel types

    GLubyte* imageData = new GLubyte[width * height * getGLTypeSize(_type) * channels];
    glGetTexImage(mTarget, _lod, mFormat, _type, (GLvoid*)imageData);

    // revert to the previously bound texture
    glBindTexture(mTarget, prevTexture);

    // store the image data and meta information in a TextureData object
    SharedTextureData dataObject = SharedTextureData(new TextureData());
    dataObject->setWidth(width);
    dataObject->setHeight(height);
    dataObject->setDepth(depth);
    dataObject->setType(_type);
    dataObject->setFormat(mFormat);
    dataObject->setData(imageData); // dataObject will take care of freeing imageData

    return dataObject;
}
#endif // ES 2.0