buffer.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_buffers( GLsizei size, GLuint* name ) { glGenBuffers( size, name ); }
    void delete_buffers( GLsizei size, const GLuint* name ) { glDeleteBuffers( size, name ); }
}

template<GLenum Target = GL_ARRAY_BUFFER, GLenum Usage = GL_DYNAMIC_DRAW>
class buffer {
public:
    GLuint name() const {
        return m_object.name();
    }

    GLsizeiptr size() const {
        return m_size;
    }

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

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

    template<typename T>
    void bind_range( GLuint index, GLintptr offset, T range_size ) {
        check_gl_error( glBindBufferRange( Target, index, m_object.name(), offset, static_cast<GLsizeiptr>( range_size ) ) );
    }

    template<typename T>
    void data( T data_size, const GLvoid* data_ptr ) {
        assert( data_size >= 0 );
        m_size = static_cast<GLsizeiptr>( data_size );

        bind();
        check_gl_error( glBufferData( Target, m_size, data_ptr, Usage ) );

        if( data_ptr ) {
            sub_data( 0, m_size, data_ptr );
        }
    }

    template<typename T>
    void sub_data( GLintptr offset, T data_size, const GLvoid* data_ptr ) {
        if( m_size < offset + static_cast<GLsizeiptr>( data_size ) ) {
            buffer new_buffer;

            new_buffer.data( offset + static_cast<GLsizeiptr>( data_size ), nullptr );
            new_buffer.copy_sub_data( *this, 0, 0, m_size );

            std::swap( *this, new_buffer );
        }

        bind();
        check_gl_error( glBufferSubData( Target, offset, static_cast<GLsizeiptr>( data_size ), data_ptr ) );
        unbind();
    }

    template<GLenum SourceTarget, GLenum SourceUsage, typename V>
    void copy_sub_data( const buffer<SourceTarget, SourceUsage>& source, GLintptr readoffset, GLintptr writeoffset, V data_size ) {
        assert( data_size > 0 );
        assert( source.size() >= readoffset + static_cast<GLsizeiptr>( data_size ) );

        if( m_size < writeoffset + static_cast<GLsizeiptr>( data_size ) ) {
            buffer new_buffer;

            new_buffer.data( writeoffset + static_cast<GLsizeiptr>( data_size ), nullptr );

            if( m_size ) {
                new_buffer.copy_sub_data( *this, 0, 0, m_size );
            }

            std::swap( *this, new_buffer );
        }

        check_gl_error( glBindBuffer( GL_COPY_READ_BUFFER, source.name() ) );
        check_gl_error( glBindBuffer( GL_COPY_WRITE_BUFFER, name() ) );

        check_gl_error( glCopyBufferSubData( GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, readoffset, writeoffset, static_cast<GLsizeiptr>( data_size ) ) );

        check_gl_error( glBindBuffer( GL_COPY_READ_BUFFER, 0 ) );
        check_gl_error( glBindBuffer( GL_COPY_WRITE_BUFFER, 0 ) );
    }

    template<typename T>
    void get_sub_data( GLintptr offset, T data_size, GLvoid* data_ptr ) {
        assert( m_size >= offset + static_cast<GLsizeiptr>( data_size ) );

        bind();
        check_gl_error( glGetBufferSubData( Target, offset, static_cast<GLsizeiptr>( data_size ), data_ptr ) );
        unbind();
    }

private:
    object<priv::gen_buffers, priv::delete_buffers> m_object;
    GLsizeiptr m_size = 0;
};

}