texture.cpp

/**********************************************************************
 *                                                                    *
 * cgt - CAMP Graphics Toolbox, Copyright (C) 2012-2015               *
 *     Chair for Computer Aided Medical Procedures                    *
 *     Technische Universitaet Muenchen, Germany.                     *
 *     <http://campar.in.tum.de/>                                     *
 *                                                                    *
 * forked from tgt - Tiny Graphics Toolbox, Copyright (C) 2006-2011   *
 *     Visualization and Computer Graphics Group, Department of       *
 *     Computer Science, University of Muenster, Germany.             *
 *     <http://viscg.uni-muenster.de>                                 *
 *                                                                    *
 * This file is part of the cgt library. This library is free         *
 * software; you can redistribute it and/or modify it under the terms *
 * of the GNU Lesser General Public License version 2.1 as published  *
 * by the Free Software Foundation.                                   *
 *                                                                    *
 * 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 in the file "LICENSE.txt" along with this library.         *
 * If not, see <http://www.gnu.org/licenses/>.                        *
 *                                                                    *
 **********************************************************************/

#include "cgt/texture.h"
#include "cgt/types.h"

#include "cgt/gpucapabilities.h"
#include "cgt/filesystem.h"

#include "texturemanager.h"

namespace cgt {

Texture::Texture(GLenum type, const cgt::ivec3& dimensions, GLint internalFormat, Filter filter /*= LINEAR*/) 
    : dimensions_(dimensions)
    , internalformat_(internalFormat)
    , filter_(filter)
    , wrapping_(CLAMP_TO_EDGE)
    , id_(0)
    , type_(type)
    , bpp_(0)
{
    init();
}

Texture::Texture(GLenum type, const cgt::ivec3& dimensions, GLint internalFormat, GLubyte* data, GLint format, GLenum dataType, Filter filter /*= LINEAR*/) 
    : dimensions_(dimensions)
    , internalformat_(internalFormat)
    , filter_(filter)
    , wrapping_(CLAMP_TO_EDGE)
    , id_(0)
    , type_(type)
    , bpp_(0)
{
    init();
    uploadTexture(data, format, dataType);
}


Texture::~Texture() {
    if (id_)
        TexMgr.releaseId(id_, type_, dimensions_, internalformat_);
}


void Texture::init() {
    bpp_ = calcBpp(internalformat_);
    generateId();
    applyFilter();
    applyWrapping();
    LGL_ERROR;
}

int Texture::calcBpp(GLint format, GLenum dataType) {

    int numChannels = calcNumChannels(format);

    int typeSize = 0;
    switch (dataType) {
        case GL_BYTE:
        case GL_UNSIGNED_BYTE:
            typeSize = 1;
            break;

        case GL_SHORT:
        case GL_UNSIGNED_SHORT:
            typeSize = 2;
            break;

        case GL_INT:
        case GL_UNSIGNED_INT:
        case GL_FLOAT:
            typeSize = 4;
            break;

        default:
            LWARNINGC("cgt.Texture", "unknown dataType");
    }

    return typeSize * numChannels;
}

int Texture::calcBpp(GLint internalformat) {
    auto ft = GLTextureFormatTraits::get(internalformat);

    if (ft.known())
        return ft.bpp();
    else {
        cgtAssert(false, "Unknown internal format, this should not happen!");
        return 0;
    }
}

int Texture::calcNumChannels(GLint internalFormat) {
    auto ft = GLTextureFormatTraits::get(internalFormat);

    if (ft.known())
        return ft.channels();
    else {

        switch (internalFormat) {
        case 1:
        case GL_RED:
            return 1;
            break;
        case 2:
        case GL_DEPTH_STENCIL:
        case GL_RG:
            return 2;
            break;

        case 3:
        case GL_RGB:
            return 3;
            break;
        case 4:
        case GL_RGBA:
            return 4;
            break;

        default:
            cgtAssert(false, "Unknown internal format, this should not happen!");
            return 0;
        }

    }
}

int Texture::getSizeOnGPU() const {
    int bpp = calcBpp(internalformat_);
    return bpp * hmul(dimensions_);
}

void Texture::bind() const
{
    glBindTexture(type_, id_);
}

GLuint Texture::generateId()
{
    id_ = TexMgr.generateId(type_, dimensions_, internalformat_);
    return id_;
}

void Texture::setFilter(Filter filter) {
    filter_ = filter;
    applyFilter();
}

void Texture::applyFilter() {
    bind();

    switch(filter_) {
        case NEAREST:
            glTexParameteri(type_,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
            glTexParameteri(type_,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
            break;

        case LINEAR:
            glTexParameteri(type_, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(type_, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            break;

        case ANISOTROPIC:
            glTexParameterf(type_, GL_TEXTURE_MAX_ANISOTROPY_EXT, GpuCaps.getMaxTextureAnisotropy());

        case MIPMAP:
            glTexParameteri(type_,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
            glTexParameteri(type_,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
            break;
    }
}

void Texture::setWrapping(Wrapping w) {
    wrapping_ = w;
    applyWrapping();
}

void Texture::applyWrapping() {
    bind();
    GLint wrap = wrapping_;

    // set wrapping for all diminesions
    glTexParameteri(type_, GL_TEXTURE_WRAP_S, wrap);

    if (type_ == GL_TEXTURE_2D || type_ == GL_TEXTURE_2D_ARRAY || type_ == GL_TEXTURE_3D )
        glTexParameteri(type_, GL_TEXTURE_WRAP_T, wrap);
    if (GL_TEXTURE_3D)
        glTexParameteri(type_, GL_TEXTURE_WRAP_R, wrap);
}

void Texture::uploadTexture(const GLubyte* data, GLint format, GLenum dataType) {
    bind();

    switch (type_) {
        case GL_TEXTURE_1D:
            glTexSubImage1D(type_, 0, 0, dimensions_.x, format, dataType, data);
            if (filter_ == MIPMAP)
                glGenerateMipmap(GL_TEXTURE_1D);
            break;

        case GL_TEXTURE_1D_ARRAY: // fallthrough
        case GL_TEXTURE_2D:
            glTexSubImage2D(type_, 0, 0, 0, dimensions_.x, dimensions_.y, format, dataType, data);
            if (filter_ == MIPMAP)
                glGenerateMipmap(GL_TEXTURE_2D);
            break;

        case GL_TEXTURE_2D_ARRAY: // fallthrough
        case GL_TEXTURE_3D:
            glTexSubImage3D(type_, 0, 0, 0, 0, dimensions_.x, dimensions_.y, dimensions_.z, format, dataType, data);
            if (filter_ == MIPMAP)
                glGenerateMipmap(GL_TEXTURE_3D);
            break;
    }

    LGL_ERROR;
}

GLubyte* Texture::downloadTextureToBuffer(GLint format, GLenum dataType) const {
    bind();

    int arraySize = hmul(dimensions_) * calcBpp(format, dataType);
    GLubyte* pixels = new GLubyte[arraySize];

    glFlush(); // better to use a barrier here but too lazy to figure out which one would be correct

    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glGetTexImage(type_, 0, format, dataType, pixels);
    return pixels;
}

bool Texture::isDepthTexture() const {
    return internalformat_ == GL_DEPTH_COMPONENT
        || internalformat_ == GL_DEPTH_COMPONENT16 
        || internalformat_ == GL_DEPTH_COMPONENT24
        || internalformat_ == GL_DEPTH_COMPONENT32
        || internalformat_ == GL_DEPTH_COMPONENT32F;
}

void Texture::setPriority(GLclampf p) {
    glPrioritizeTextures(1, &id_, &p);
}

bool Texture::isResident() const {
    GLboolean resident;
    return glAreTexturesResident(1, &id_, &resident) == GL_TRUE;
}

GLint Texture::calcInternalFormat(GLint format, GLenum dataType) {
    switch (format) {
        case GL_RED:
            switch (dataType) {
                case GL_UNSIGNED_BYTE:
                case GL_BYTE:
                    return GL_R8;
                case GL_UNSIGNED_SHORT:
                case GL_SHORT:
                    return GL_R16;
                case GL_UNSIGNED_INT:
                case GL_INT:
                    return GL_R32F;
                case GL_FLOAT:
                    return GL_R32F;
                default:
                    cgtAssert(false, "Should not reach this - wrong base data type!");
                    return GL_RED;
            }
        case GL_RG:
            switch (dataType) {
                case GL_UNSIGNED_BYTE:
                case GL_BYTE:
                    return GL_RG8;
                case GL_UNSIGNED_SHORT:
                case GL_SHORT:
                    return GL_RG16;
                case GL_UNSIGNED_INT:
                case GL_INT:
                    return GL_RG32F;
                case GL_FLOAT:
                    return GL_RG32F;
                default:
                    cgtAssert(false, "Should not reach this - wrong base data type!");
                    return GL_RG;
            }
        case GL_RGB:
            switch (dataType) {
                case GL_UNSIGNED_BYTE:
                case GL_BYTE:
                    return GL_RGB8;
                case GL_UNSIGNED_SHORT:
                case GL_SHORT:
                    return GL_RGB16;
                case GL_UNSIGNED_INT:
                case GL_INT:
                    return GL_RGB32F;
                case GL_FLOAT:
                    return GL_RGB32F;
                default:
                    cgtAssert(false, "Should not reach this - wrong base data type!");
                    return GL_RGB;
            }
        case GL_RGBA:
            switch (dataType) {
                case GL_UNSIGNED_BYTE:
                case GL_BYTE:
                    return GL_RGBA8;
                case GL_UNSIGNED_SHORT:
                case GL_SHORT:
                    return GL_RGBA16;
                case GL_UNSIGNED_INT:
                case GL_INT:
                    return GL_RGBA32F;
                case GL_FLOAT:
                    return GL_RGBA32F;
                default:
                    cgtAssert(false, "Should not reach this - wrong base data type!");
                    return GL_RGBA;
            }
        default:
            cgtAssert(false, "Should not reach this, wrong number of channels!");
            return GL_RED;
    }
}

GLint Texture::calcMatchingPixelFormat(GLint internalFormat) {
    auto ft = GLTextureFormatTraits::get(internalFormat);

    if (ft.known())
        return ft.pixelFormat();
    else {
        cgtAssert(false, "Unknown internal format, this should not happen!");
        return 0;
    }
}

GLenum Texture::calcMatchingPixelDataType(GLint internalFormat) {
    auto ft = GLTextureFormatTraits::get(internalFormat);

    if (ft.known())
        return ft.pixelDataType();
    else {
        cgtAssert(false, "Unknown internal format, this should not happen!");
        return 0;
    }
}

std::string Texture::calcMatchingWriteFormat(GLint internalFormat) {
    //// supports all formats from https://www.opengl.org/sdk/docs/man4/html/glBindImageTexture.xhtml
    //switch (internalFormat) {
    //    case GL_RGBA32F: return "rgba32f";
    //    case GL_RGBA16F: return "rgba16f";
    //    case GL_RG32F: return "rg32f";
    //    case GL_RG16F: return "rg16f";
    //    case GL_R11F_G11F_B10F: return "r11f_g11f_b10f";
    //    case GL_R32F: return "r32f";
    //    case GL_R16F: return "r16f";
    //    case GL_RGBA32UI: return "rgba32ui";
    //    case GL_RGBA16UI: return "rgba16ui";
    //    case GL_RGB10_A2UI: return "rgb10_a2ui";
    //    case GL_RGBA8UI: return "rgba8ui";
    //    case GL_RG32UI: return "rg32ui";
    //    case GL_RG16UI: return "rg16ui";
    //    case GL_RG8UI: return "rg8ui";
    //    case GL_R32UI: return "r32ui";
    //    case GL_R16UI: return "r16ui";
    //    case GL_R8UI: return "r8ui";
    //    case GL_RGBA32I: return "rgba32i";
    //    case GL_RGBA16I: return "rgba16i";
    //    case GL_RGBA8I: return "rgba8i";
    //    case GL_RG32I: return "rg32i";
    //    case GL_RG16I: return "rg16i";
    //    case GL_RG8I: return "rg8i";
    //    case GL_R32I: return "r32i";
    //    case GL_R16I: return "r16i";
    //    case GL_R8I: return "r8i";
    //    case GL_RGBA16: return "rgba16";
    //    case GL_RGB10_A2: return "rgb10_a2";
    //    case GL_RGBA8: return "rgba8";
    //    case GL_RG16: return "rg16";
    //    case GL_RG8: return "rg8";
    //    case GL_R16: return "r16";
    //    case GL_R8: return "r8";
    //    case GL_RGBA16_SNORM: return "rgba16_snorm";
    //    case GL_RGBA8_SNORM: return "rgba8_snorm";
    //    case GL_RG16_SNORM: return "rg16_snorm";
    //    case GL_RG8_SNORM: return "rg8_snorm";
    //    case GL_R16_SNORM: return "r16_snorm";
    //    case GL_R8_SNORM: return "r8_snorm";

    //    default:
    //        cgtAssert(false, "Unknown internal format, this should not happen!");
    //        return 0;
    //}
    auto ft = GLTextureFormatTraits::get(internalFormat);

    if (ft.known())
        return ft.glslFormatQualifier();
    else {
        cgtAssert(false, "Unknown internal format, this should not happen!");
        return "UNKNOWN";
    }
}

void Texture::unbind() const
{
    glBindTexture(type_, 0);
}

} // namespace cgt