texture.hpp

Go to the documentation of this file.

#ifndef __TEXTURE__
#define __TEXTURE__

#include "tucano/texturemanager.hpp"
#include <iostream>
#include <GL/glew.h>
#include <memory>
#include <Eigen/Eigen>

using namespace std;

namespace Tucano
{

class Texture {
private:

    GLuint tex_id;

    GLenum tex_type;

    GLenum internal_format;

    int width;

    int height;

    int depth;

    GLenum format;

    GLenum pixel_type;

    int lod;

    int unit;

    int num_samples = 1;

    std::shared_ptr < GLuint > texID_sptr;

public:

    Texture (void)
    {
        glGenTextures(1, &tex_id);        

        texID_sptr = std::shared_ptr < GLuint > (
                new GLuint (tex_id),
                [] (GLuint *p) {
                    glDeleteTextures(1, p);
                    delete p;
                }
                );
    }

    int getWidth (void)
    {
        return width;
    }

    int getHeight (void)
    {
        return height;
    }

    Eigen::Vector2i getDimensions (void)
    {
        return Eigen::Vector2i(width, height);
    }

    void setNumSamples (int num)
    {
        num_samples = num;
    }

    GLuint create (GLenum type, GLenum int_format, int w, int h, GLenum fmt, GLenum pix_type, const GLvoid* data = NULL, int dpt = 256)
    {
        tex_type = type;
        internal_format = int_format;
        width = w;
        height = h;
        format = fmt;
        pixel_type = pix_type;
        lod = 0;
        depth = dpt;

        // create new texture 
        glBindTexture(tex_type, *texID_sptr);
        if(tex_type == GL_TEXTURE_2D || tex_type == GL_TEXTURE_RECTANGLE)
        {            
            glTexImage2D(tex_type, lod, internal_format, width, height, 0, format, pixel_type, data);           
        }
        else if(tex_type == GL_TEXTURE_2D_MULTISAMPLE)
        {            
            glTexImage2DMultisample(tex_type, num_samples, internal_format, width, height, GL_TRUE);           
        }
        else if (tex_type == GL_TEXTURE_3D)
        {
            glTexImage3D(tex_type, lod, internal_format, width, height, depth, 0, format, pixel_type, data);
        }
        else if (tex_type == GL_TEXTURE_1D)
        {
            glTexImage1D(tex_type, lod, internal_format, width, 0, format, pixel_type, data);
        }

        // default parameters
        setTexParameters();
        glBindTexture(tex_type, 0);

        #ifdef TUCANODEBUG
        Tucano::Misc::errorCheckFunc(__FILE__, __LINE__, "texture create");
        #endif

        return *texID_sptr;
    }

    GLuint create (int w, int h, const GLvoid* data = NULL)
    {
        return create (GL_TEXTURE_2D, GL_RGBA32F, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data, 0);
    }


    /*void destroy (void)
    {
        if (tex_id != 0) {
            glDeleteTextures(1, &tex_id);
        }
        tex_id = 0;
    }*/

    void setTexParameters (GLenum wraps = GL_CLAMP, GLenum wrapt = GL_CLAMP, GLenum magfilter = GL_NEAREST, GLenum minfilter = GL_NEAREST)
    {
        // multisampled textures are not filtered, setting filter parameters might result in glerror
        if (num_samples == 1)
        {
            glTexParameteri(tex_type, GL_TEXTURE_WRAP_S, wraps);
            glTexParameteri(tex_type, GL_TEXTURE_WRAP_T, wrapt);
            glTexParameteri(tex_type, GL_TEXTURE_MAG_FILTER, magfilter);
            glTexParameteri(tex_type, GL_TEXTURE_MIN_FILTER, minfilter);
        }
    }

    void setTexParametersMipMap (int maxlevel, int baselevel = 0, GLenum wraps = GL_CLAMP, GLenum wrapt = GL_CLAMP, GLenum magfilter = GL_NEAREST, GLenum minfilter = GL_NEAREST_MIPMAP_NEAREST)
    {
        glTexParameteri(tex_type, GL_TEXTURE_MIN_FILTER, minfilter);
        glTexParameteri(tex_type, GL_TEXTURE_MAG_FILTER, magfilter);
        glTexParameteri(tex_type, GL_TEXTURE_WRAP_S, wraps);
        glTexParameteri(tex_type, GL_TEXTURE_WRAP_T, wrapt);
        glTexParameteri(tex_type, GL_TEXTURE_BASE_LEVEL, baselevel );
        glTexParameteri(tex_type, GL_TEXTURE_MAX_LEVEL, maxlevel );

        glGenerateMipmap(tex_type);
    }


    void update (const GLvoid* data)
    {
        glBindTexture(tex_type, *texID_sptr);
        if(tex_type == GL_TEXTURE_2D || tex_type == GL_TEXTURE_RECTANGLE) {
            glTexSubImage2D(tex_type, lod, 0, 0, width, height, format, pixel_type, data);
        }
        else if (tex_type == GL_TEXTURE_3D) {
            glTexSubImage3D(tex_type, lod, 0, 0, 0, width, height, depth, format, pixel_type, data);
        }
        else if (tex_type == GL_TEXTURE_1D) {
            glTexSubImage1D(tex_type, lod, 0, width, format, pixel_type, data);
        }
        glBindTexture(tex_type,0);

    }

    void bind (int texture_unit)
    {
        unit = texture_unit;
        texManager.bindTexture(tex_type, *texID_sptr, texture_unit);
    }

    int bind (void)
    {
        unit = texManager.bindTexture(tex_type, *texID_sptr);
        return unit;
    }

    int bindImageRW (void)
    {
        unit = texManager.bindTexture(tex_type, *texID_sptr);
        if (unit != -1)
        {
            glBindImageTexture(unit, *texID_sptr, 0, false, 0,  GL_READ_WRITE, internal_format);
        }
        return unit;
    }

    void bindImageRW (int texture_unit)
    {
        unit = texture_unit;
        texManager.bindTexture(tex_type, *texID_sptr, texture_unit);
        glBindImageTexture(texture_unit, *texID_sptr, 0, false, 0,  GL_READ_WRITE, internal_format);
    }

    int bindImageFormatRW (GLenum fmt)
    {
        unit = texManager.bindTexture(tex_type, *texID_sptr);

        if (unit != -1)
        {
            glBindImageTexture(unit, *texID_sptr, 0, false, 0,  GL_READ_WRITE, fmt);
        }
        return unit;
    }

    void bindImageFormatRW (int texture_unit, GLenum fmt)
    {
        unit = texture_unit;
        texManager.bindTexture(tex_type, *texID_sptr, texture_unit);
        glBindImageTexture(texture_unit, *texID_sptr, 0, false, 0,  GL_READ_WRITE, fmt);
    }

    void unbind (void)
    {
        texManager.unbindTextureID(tex_type, *texID_sptr);
        unit = -1;
    }

    GLuint texID (void) const
    {
        return *texID_sptr;
    }

    int textureUnit (void) const
    {
        return unit;
    }
};

}

#endif