Buffers.hpp

#pragma once
#ifndef KJY_OBJECT_ORIENTED_OPENGL_BUFFERS_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_BUFFERS_HPP_
#include "../OOOGL_Core.hpp"
#include "../Core_Utilities.hpp"
#include <glad/glad.h>
#include <memory>
#include <string>
#include <stack>

namespace OOOGL{

class OpenGlBuffer : public OglObject{
 public:
    OpenGlBuffer(GLenum buffer_type) : OglObject(_destroyBuffer), buffer_type(buffer_type) {
        glGenBuffers(1, getIdPtr());
        glBindBuffer(buffer_type, getNameDirect());
        glBindBuffer(buffer_type, 0);
        binding_purity = BINDINGS_UNCLEAN;
    }
    OpenGlBuffer(const OpenGlBuffer& other) : OglObject(other), buffer_type(other.buffer_type) {}

    virtual void bind() const {glBindBuffer(buffer_type, getNameDirect());};
    virtual void unbind() const {glBindBuffer(buffer_type, 0);};

    virtual void bufferData(GLsizeiptr size, const GLvoid* data, GLenum usage) {
        glBindBuffer(buffer_type, getNameDirect());
        CONDITIONALLY_CHECKED_GL_CALL(glBufferData(buffer_type, size, data, usage));
        glBindBuffer(buffer_type, 0);
    }
    virtual void bufferSubData(GLintptr offset, GLsizeiptr size, const GLvoid* data) {
        glBindBuffer(buffer_type, getNameDirect());
        CONDITIONALLY_CHECKED_GL_CALL(glBufferSubData(buffer_type, offset, size, data));
        glBindBuffer(buffer_type, 0);
    }
    virtual void bufferStorage(GLsizeiptr size, const GLvoid* data, GLbitfield flags) {
        glBindBuffer(buffer_type, getNameDirect());
        CONDITIONALLY_CHECKED_GL_CALL(glBufferStorage(buffer_type, size, data, flags));
        glBindBuffer(buffer_type, 0);
    }
    virtual void clearBufferData(GLenum internal_format, GLenum format, GLenum type, const void* data) {
        glBindBuffer(buffer_type, getNameDirect());
        CONDITIONALLY_CHECKED_GL_CALL(glClearBufferData(buffer_type, internal_format, format, type, data));
        glBindBuffer(buffer_type, 0);
    }
    virtual void clearBufferSubData(GLenum internal_format, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data) {
        glBindBuffer(buffer_type, getNameDirect());
        CONDITIONALLY_CHECKED_GL_CALL(glClearBufferSubData(buffer_type, internal_format, offset, size, format, type, data));
        glBindBuffer(buffer_type, 0);
    }
    virtual void invalidateBufferData() {
        glBindBuffer(buffer_type, getNameDirect());
        CONDITIONALLY_CHECKED_GL_CALL(glInvalidateBufferData(getNameDirect()));
        glBindBuffer(buffer_type, 0);
    }
    virtual void invalidateBufferSubData(GLintptr offset, GLsizeiptr length) {
        glBindBuffer(buffer_type, getNameDirect());
        CONDITIONALLY_CHECKED_GL_CALL(glInvalidateBufferSubData(buffer_type, offset, length));
        glBindBuffer(buffer_type, 0);
    }

    static void copy_buffer_subdata(const OpenGlBuffer& read_buffer, const OpenGlBuffer& write_buffer, GLintptr read_offset, GLintptr write_offset, GLsizei size){
        // CONDITIONALLY_CHECKED_GL_CALL((read_buffer.getNameDirect(), write_buffer.getNameDirect(), read_offset, write_offset, size));
    }

    inline GLenum getBufferType() const {return(buffer_type);}

 private:
    static void _destroyBuffer(const GLuint* name){
        glDeleteBuffers(1, name);
    }
    GLenum buffer_type = GL_INVALID_ENUM;
};

/* Indicates the buffer as one compatible with the `bindBufferBase` family of functions.
 * GL_ATOMIC_COUNTER_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER, GL_UNIFORM_BUFFER and GL_SHADER_STORAGE_BUFFER. 
 */ 
class IndexBindableBuffer : public OpenGlBuffer {
 public:
    IndexBindableBuffer(GLenum buffer_type) : OpenGlBuffer(buffer_type) {}
    virtual void bindBase(GLuint index) {
        _is_index_bound_ = true;
        _bound_index_ = index;
        CONDITIONALLY_CHECKED_GL_CALL(glBindBufferBase(getBufferType(), index, getNameDirect()));
    }
    virtual void bindBaseRange(GLuint index, GLintptr offset, GLsizeiptr size) {
        _is_index_bound_ = true;
        _bound_index_ = index;
        CONDITIONALLY_CHECKED_GL_CALL(glBindBufferRange(getBufferType(), index, getNameDirect(), offset, size));
    }
    virtual void unbindFromBase() {
        if(_is_index_bound_) CONDITIONALLY_CHECKED_GL_CALL(glBindBufferBase(getBufferType(), _bound_index_, 0));
        _is_index_bound_ = false;
    }
 private:
    bool _is_index_bound_ = false;
    GLuint _bound_index_ = 0;
};

/* Other families of buffers that might justify another interface
 * glGetBufferParameteriv: GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, and GL_PIXEL_UNPACK_BUFFER. 
 * None others I can find so far. 
 */


class ArrayBuffer : public OpenGlBuffer{
 public:
    ArrayBuffer() : OpenGlBuffer(GL_ARRAY_BUFFER) {}

    struct PointerConfig{
        enum AttribPtrType {FLOATING, INTEGRAL, LONG_INTEGRAL};
        AttribPtrType attrib_pointer_type = FLOATING;
        GLint size = 3;
        GLenum type = GL_FLOAT;
        GLboolean normalized = GL_FALSE;
        GLsizei stride = 0;
        const GLvoid* offset = (const GLvoid*) 0;
    };

    PointerConfig preferred_config;
};
class AtomicCounterBuffer : public IndexBindableBuffer{
 public:
    AtomicCounterBuffer() : IndexBindableBuffer(GL_ATOMIC_COUNTER_BUFFER) {}
};
class CopyReadBuffer : public OpenGlBuffer{
 public:
    CopyReadBuffer() : OpenGlBuffer(GL_COPY_READ_BUFFER) {}
};
class CopyWriteBuffer : public OpenGlBuffer{
 public:
    CopyWriteBuffer() : OpenGlBuffer(GL_COPY_WRITE_BUFFER) {}
};
class DispatchIndirectBuffer : public OpenGlBuffer{
 public:
    DispatchIndirectBuffer() : OpenGlBuffer(GL_DISPATCH_INDIRECT_BUFFER) {}
};
class DrawIndirectBuffer : public OpenGlBuffer{
 public:
    DrawIndirectBuffer() : OpenGlBuffer(GL_DRAW_INDIRECT_BUFFER) {}
};
class ElementArrayBuffer : public OpenGlBuffer{
 public:
    ElementArrayBuffer() : OpenGlBuffer(GL_ELEMENT_ARRAY_BUFFER) {}
};
class PixelPackBuffer : public OpenGlBuffer{
 public:
    PixelPackBuffer() : OpenGlBuffer(GL_PIXEL_PACK_BUFFER) {}
};
class PixelUnpackBuffer : public OpenGlBuffer{
 public:
    PixelUnpackBuffer() : OpenGlBuffer(GL_PIXEL_UNPACK_BUFFER) {}
};
class QueryBuffer : public OpenGlBuffer{
 public:
    QueryBuffer() : OpenGlBuffer(GL_QUERY_BUFFER) {}
};
class ShaderStorageBuffer : public IndexBindableBuffer{
 public:
    ShaderStorageBuffer() : IndexBindableBuffer(GL_SHADER_STORAGE_BUFFER) {}
};
class TextureBuffer : public OpenGlBuffer{
 public:
    TextureBuffer() : OpenGlBuffer(GL_TEXTURE_BUFFER) {}
};
class TransformFeedbackBuffer : public IndexBindableBuffer{
 public:
    TransformFeedbackBuffer() : IndexBindableBuffer(GL_TRANSFORM_FEEDBACK_BUFFER) {}
};
class UniformBuffer : public IndexBindableBuffer{
 public:
    UniformBuffer() : IndexBindableBuffer(GL_UNIFORM_BUFFER) {}
};


} // Namespace OOOGL

#endif