vertexarray.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 <gls/objects/buffer.hpp>
#include <cassert>

namespace gls {

namespace priv {
    void gen_vertex_arrays( GLsizei size, GLuint* name ) { glGenVertexArrays( size, name ); }
    void delete_vertex_arrays( GLsizei size, const GLuint* name ) { glDeleteVertexArrays( size, name ); }
}

class vertexarray {
public:
    GLuint name() const {
        return m_object.name();
    }

    void bind() {
        check_gl_error( glBindVertexArray( m_object.name() ) );
    }

    static void unbind() {
        check_gl_error( glBindVertexArray( 0 ) );
    }

    template<GLenum BufferType, typename T, typename U>
    void bind_attribute( const program& the_program, const std::string& attribute_name, const buffer<BufferType>& the_buffer, GLint size, GLenum type, GLboolean normalized, T stride, U offset ) {
        auto attribute_location = the_program.get_attribute_location( attribute_name );

        if( attribute_location < 0 ) {
            return;
        }

        bind_attribute( static_cast<GLuint>( attribute_location ), the_buffer, size, type, normalized, stride, offset );
    }

    template<GLenum BufferType, typename T, typename U>
    void bind_attribute( GLuint attribute_location, const buffer<BufferType>& the_buffer, GLint size, GLenum type, GLboolean normalized, T stride, U offset ) {
        bind();
        check_gl_error( glBindBuffer( GL_ARRAY_BUFFER, the_buffer.name() ) );
        check_gl_error( glEnableVertexAttribArray( attribute_location ) );
        check_gl_error( glVertexAttribPointer( attribute_location, size, type, normalized, static_cast<GLsizei>( stride ), reinterpret_cast<const GLvoid*>( offset ) ) );
        check_gl_error( glBindBuffer( GL_ARRAY_BUFFER, 0 ) );
        unbind();
        check_gl_error( glDisableVertexAttribArray( attribute_location ) );
    }

    void unbind_attribute( const program& the_program, const std::string& attribute_name ) {
        auto attribute_location = the_program.get_attribute_location( attribute_name );

        if( attribute_location < 0 ) {
            return;
        }

        unbind_attribute( static_cast<GLuint>( attribute_location ) );
    }

    void unbind_attribute( GLuint attribute_location ) {
        bind();
        check_gl_error( glDisableVertexAttribArray( static_cast<GLuint>( attribute_location ) ) );
        unbind();
    }

    void clear_attribute_bindings() {
        auto max_vertex_attributes = GLint();

        check_gl_error( glGetIntegerv( GL_MAX_VERTEX_ATTRIBS, &max_vertex_attributes ) );

        bind();

        for( GLuint index = 0; index < static_cast<GLuint>( max_vertex_attributes ); ++index ) {
            check_gl_error( glDisableVertexAttribArray( index ) );
        }

        unbind();
    }

    template<GLenum BufferType>
    void bind_index_buffer( const buffer<BufferType>& the_buffer ) {
        bind();
        check_gl_error( glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, the_buffer.name() ) );
        unbind();
        check_gl_error( glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ) );
    }

    void unbind_index_buffer() {
        bind();
        check_gl_error( glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ) );
        unbind();
    }

private:
    object<priv::gen_vertex_arrays, priv::delete_vertex_arrays> m_object;
};

}