texture.hpp

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#pragma once

#include <gls/headercheck.hpp>
#include <gls/errorcheck.hpp>
#include <gls/objects/object.hpp>
#include <cassert>

namespace gls {

namespace priv {
    void gen_textures( GLsizei size, GLuint* name ) { glGenTextures( size, name ); }
    void delete_textures( GLsizei size, const GLuint* name ) { glDeleteTextures( size, name ); }
}

template<GLenum Target = GL_TEXTURE_2D>
class texture {
public:
    texture() {
        parameter( GL_TEXTURE_MIN_FILTER, GL_LINEAR );
        parameter( GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    }

    GLuint name() const {
        return m_object.name();
    }

    GLsizei width() const {
        return m_width;
    }

    GLsizei height() const {
        return m_height;
    }

    GLsizei depth() const {
        return m_depth;
    }

    void bind() {
        check_gl_error( glBindTexture( Target, m_object.name() ) );
    }

    static void unbind() {
        check_gl_error( glBindTexture( Target, 0 ) );
    }

    void parameter( GLenum pname, GLfloat param ) {
        bind();
        check_gl_error( glTexParameterf( Target, pname, param ) );
        unbind();
    }

    void parameter( GLenum pname, GLint param ) {
        bind();
        check_gl_error( glTexParameteri( Target, pname, param ) );
        unbind();
    }

    void parameter( GLenum pname, const GLfloat* param ) {
        bind();
        check_gl_error( glTexParameterfv( Target, pname, param ) );
        unbind();
    }

    void parameter( GLenum pname, const GLint* param ) {
        bind();
        check_gl_error( glTexParameteriv( Target, pname, param ) );
        unbind();
    }

    template<typename T>
    void image_1d( GLint level, GLint internal_format, T the_width, GLenum format, GLenum type, const GLvoid* data ) {
        m_width = static_cast<GLsizei>( the_width );
        bind();
        check_gl_error( glTexImage1D( Target, level, internal_format, m_width, 0, format, type, data ) );
        unbind();
    }

    template<typename T, typename U>
    void image_2d( GLint level, GLint internal_format, T the_width, U the_height, GLenum format, GLenum type, const GLvoid* data ) {
        m_width = static_cast<GLsizei>( the_width );
        m_height = static_cast<GLsizei>( the_height );
        bind();
        check_gl_error( glTexImage2D( Target, level, internal_format, m_width, m_height, 0, format, type, data ) );
        unbind();
    }

    template<typename T, typename U, typename V>
    void image_3d( GLint level, GLint internal_format, T the_width, U the_height, V the_depth, GLenum format, GLenum type, const GLvoid* data ) {
        m_width = static_cast<GLsizei>( the_width );
        m_height = static_cast<GLsizei>( the_height );
        m_depth = static_cast<GLsizei>( the_depth );
        bind();
        check_gl_error( glTexImage3D( Target, level, internal_format, m_width, m_height, m_depth, 0, format, type, data ) );
        unbind();
    }

    template<typename T, typename U>
    void sub_image_1d( GLint level, T xoffset, U the_width, GLenum format, GLenum type, const GLvoid* data ) {
        assert( xoffset + the_width < m_width );
        bind();
        check_gl_error( glTexSubImage1D( Target, level, static_cast<GLint>( xoffset ), static_cast<GLsizei>( the_width ), format, type, data ) );
        unbind();
    }

    template<typename T, typename U, typename V, typename W>
    void sub_image_2d( GLint level, T xoffset, U yoffset, V the_width, W the_height, GLenum format, GLenum type, const GLvoid* data ) {
        assert( xoffset + the_width < m_width );
        assert( yoffset + the_height < m_height );
        bind();
        check_gl_error( glTexSubImage2D( Target, level, static_cast<GLint>( xoffset ), static_cast<GLint>( yoffset ), static_cast<GLsizei>( the_width ), static_cast<GLsizei>( the_height ), format, type, data ) );
        unbind();
    }

    template<typename T, typename U, typename V, typename W, typename X, typename Y>
    void sub_image_3d( GLint level, T xoffset, U yoffset, V zoffset, W the_width, X the_height, Y the_depth, GLenum format, GLenum type, const GLvoid* data ) {
        assert( xoffset + the_width < m_width );
        assert( yoffset + the_height < m_height );
        assert( zoffset + the_depth < m_depth );
        bind();
        check_gl_error( glTexSubImage3D( Target, level, static_cast<GLint>( xoffset ), static_cast<GLint>( yoffset ), static_cast<GLint>( zoffset ), static_cast<GLsizei>( the_width ), static_cast<GLsizei>( the_height ), static_cast<GLsizei>( the_depth ), format, type, data ) );
        unbind();
    }

    void get_image( GLint level, GLint format, GLenum type, GLvoid* img ) {
        bind();
        check_gl_error( glGetTexImage( Target, level, format, type, img ) );
        unbind();
    }

    void generate_mipmap() {
        bind();
        check_gl_error( glGenerateMipmap( Target ) );
        unbind();
    }

protected:
    texture(int) {
    }

private:
    object<priv::gen_textures, priv::delete_textures> m_object;
    GLsizei m_width = 0;
    GLsizei m_height = 0;
    GLsizei m_depth = 0;
};

}