gr_opengl_texture.h

Go to the documentation of this file.

/* $Id: gr_opengl_texture.h 18278 2014-11-25 01:42:10Z ksimek $ */
/* {{{=========================================================================== *
   |
   |  Copyright (c) 1994-2010 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Kyle Simek
 * =========================================================================== }}}*/

// vim: tabstop=4 shiftwidth=4 foldmethod=marker
#ifndef KJB_CPP_OPENGL_TEXTURE
#define KJB_CPP_OPENGL_TEXTURE

// this must be before opengl.h
#include <gr_cpp/gr_opengl_headers.h>

#ifdef DEBUGGING
#include <gr_cpp/gr_glut.h>
#endif

#ifdef KJB_HAVE_OPENGL

#include <map>
#include <m_cpp/m_matrix.h>
#include <i_cpp/i_image.h>
#include <l_cpp/l_util.h>

typedef unsigned int GLunum;
namespace kjb 
{
namespace opengl
{

class Int_matrix;

class Texture
{
typedef Texture Self;

public:
    Texture();

    Texture(GLuint texture_id, int width, int height);

    Texture(const Texture& other);

    int get_width() const;

    int get_height() const;

    int get_num_cols() const;

    int get_num_rows() const;


    void free();

    Self& operator=(const Self& src);

    Texture& set(GLenum target, int level, GLint internal_format, GLsizei width, GLsizei height, int border, GLenum format, const GLfloat* data = 0);

    Texture& set(GLenum target, int level, GLint internal_format, GLsizei width, GLsizei height, int border, GLenum format, const GLint* data = 0);

    Texture& set(GLenum target, int level, GLint internal_format, GLsizei width, GLsizei height, int border, GLenum format, const GLuint* data = 0);

    Texture& set(GLenum target, int level, GLint internal_format, GLsizei width, GLsizei height, int border, GLenum format, const GLubyte* data = 0);

    Texture& set(GLenum target, int level, GLint internal_format, GLsizei width, GLsizei height, int border, GLenum format, const GLushort* data = 0);

    template <class T>
    Texture& set(GLsizei width, GLsizei height, GLenum format, const T* data = 0)
    {
        return set(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, format, data);
    }

    Self& allocate(GLenum internal_format, GLsizei width, GLsizei height);

    Self& allocate(GLenum internal_format, GLsizei width, GLsizei height, GLenum format);

    Texture& set(const Image& img);

    Texture& set(
            const Image& img,
            GLenum target,
            GLint level,
            GLint border = 0 );


    Texture& set(const Matrix& mat);


    Texture& set(const Matrix& mat, GLenum target, GLenum level, GLint border);


    Self& set_float(const Matrix& mat, GLenum target = GL_TEXTURE_2D);



    Self& set_packed_float(const Matrix& mat, GLenum target = GL_TEXTURE_2D);


    template <class Matrix_type>
    Self& set_mask_4ui(const Matrix_type& mat, GLenum target = GL_TEXTURE_2D)
    {
        GLubyte* array = create_gl_mask_4ui(mat);

        set(target, 0, GL_RGBA8, mat.get_num_cols(), mat.get_num_rows(), 0, GL_RGBA, array);

        delete[] array;
        return *this;
    }

    Self& set_mask_1f(const kjb::Matrix& mat, GLenum target = GL_TEXTURE_2D);


    Self& set_mask_1f(const kjb::Int_matrix& mat, GLenum target = GL_TEXTURE_2D);
    


    ~Texture();

    void bind() const;
    
    void unbind() const;

    static int max_color_attachments();

    operator GLuint() const;

    GLuint get() const;


protected:

    static float* create_gl_array(const Matrix& mat);

    template <class Matrix_type>
    static GLubyte* create_gl_mask_4ui(const Matrix_type& mat)
    {
        GLubyte* array = new GLubyte[mat.get_length() * 4];
        GLubyte* cur = array;

        const int num_rows = mat.get_num_rows();
        const int num_cols = mat.get_num_cols();

        for(int row = num_rows - 1; row >= 0; row--)
        for(int col = 0; col < num_cols; col++)
        {
            *cur++ = (mat(row, col) == 0 ? 0 : 255);
            *cur++ = (mat(row, col) == 0 ? 0 : 255);
            *cur++ = (mat(row, col) == 0 ? 0 : 255);
            *cur++ = (mat(row, col) == 0 ? 0 : 255);
        }

        return array;
    }

private:
    template <class T>
    Texture& set(
            GLenum target,
            int level,
            GLint internal_format,
            GLsizei width,
            GLsizei height,
            int border,
            GLenum format,
            const T* data = 0);
private:
    static std::map<int, int> ref_count_;

    GLuint handle_;
    int width_;
    int height_;
};

void draw_fullscreen_textured_quad(const Texture& texture);

} // namespace opengl
} // namespace kjb

#endif /* KJB_HAVE_OPENGL */
#endif /* KJB_OPENGL_TEXTURE */