VertexArrayObject.hpp

#pragma once
#ifndef KJY_OBJECT_ORIENTED_OPENGL_VERTEX_ARRAY_OBJECT_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_VERTEX_ARRAY_OBJECT_HPP_
#include "../OOOGL_Core.hpp"
#include "Buffers.hpp"
#include <map>
#include <string.h>

namespace OOOGL{

class VertexArrayObject : public OglObject, public OglPossessorInterface<ArrayBuffer, ElementArrayBuffer>{
 public:
    VertexArrayObject() : OglObject(_destroyVAO) {
        glGenVertexArrays(1, getIdPtr());
        glGetInteger64v(GL_MAX_VERTEX_ATTRIBS, reinterpret_cast<GLint64*>(&(attrib_count)));
        attrib_enabled_LUT.resize(attrib_count, false);
    }

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

    void enableVertexAttribArray(GLuint index);
    void disableVertexAttribArray(GLuint index);
    void enableAllVertexAttribs();
    void disableAllVertexAttribs();
    bool isAttribArrayEnabled(GLuint index) const;

    void setVertexAtrribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer) const;
    void setVertexAttribPointerIntegral(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) const;
    void setVertexAttribPointerLong(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) const;
    void setVertexAttribPointer(GLuint index, const ArrayBuffer::PointerConfig& config) const;

    void autoVertexAttribPointer(GLuint index, ArrayBuffer vbo);
    
    virtual size_t numPossessed() const override {return(_possessed_buffers.size());}
    virtual void possessObject(ArrayBuffer buffer) override;
    virtual void possessObject(ElementArrayBuffer buffer) override;
    virtual bool doesPossessObject(ArrayBuffer buffer) const override;
    virtual bool doesPossessObject(ElementArrayBuffer buffer) const override;
    virtual void dispossessObject(const ArrayBuffer& buffer) override;
    virtual void dispossessObject(const ElementArrayBuffer& buffer) override;

    void possessBuffer(ArrayBuffer buffer) {possessObject(buffer);}
    void possessBuffer(ElementArrayBuffer buffer) {possessObject(buffer);}
    bool doesPossessBuffer(ArrayBuffer buffer) const {return(doesPossessObject(buffer));}
    bool doesPossessBuffer(ElementArrayBuffer buffer) const {return(doesPossessObject(buffer));}
    void dispossessBuffer(const ArrayBuffer& buffer) {dispossessObject(buffer);};
    void dispossessBuffer(const ElementArrayBuffer& buffer) {dispossessObject(buffer);};

 protected:
    std::vector<bool> attrib_enabled_LUT;
    size_t attrib_count = 0;

 private:
    static void _destroyVAO(const GLuint* self){
        glDeleteVertexArrays(1, self);
    }

    std::map<GLuint, OpenGlBuffer> _possessed_buffers;

 protected:
    class AttributeIndexOutOfBoundsException : public BaseGraphicsException{
     public:
        AttributeIndexOutOfBoundsException(GLuint index) : _whatstr("Out of bounds attribute index '" + std::to_string(index) + "'") {}
        virtual const char* what() const noexcept override{return(_whatstr.c_str());}
     private:
        const std::string _whatstr;
    };

    class NoBufferAtAttribIndexException : public BaseGraphicsException{
     public:
        NoBufferAtAttribIndexException(GLuint index) : _whatstr("No buffer bound at attribute index '" + std::to_string(index) + "'") {}
        virtual const char* what() const noexcept override{return(_whatstr.c_str());}
     private:
        const std::string _whatstr;
    };
};


class CommonVertexFormatVAO : public VertexArrayObject{
 public:
    CommonVertexFormatVAO() : VertexArrayObject(), linked_vbos(attrib_count) {linked_elbos.reserve(attrib_count);}

    size_t numLinkedArrayBuffers() const {return(linked_vbos.size());}
    size_t numLinkedElementBuffers() const {return(linked_elbos.size());}
    void linkArrayBuffer(GLuint index, ArrayBuffer buffer);
    void linkElementBuffer(ElementArrayBuffer buffer);

    void unlinkArrayBuffer(GLuint index);
    void unlinkArrayBuffer(ArrayBuffer buffer);
    void unlinkAllArrayBuffers();
    void unlinkElementBuffer(ElementArrayBuffer buffer);
    void unlinkAllElementBuffers();

    bool hasLinkedBuffer(GLuint index) const;
    const ArrayBuffer getArrayBuffer(GLuint index) const;
    ArrayBuffer getArrayBuffer(GLuint index);

protected:
    typedef OptionalIndexedBindingVector<ArrayBuffer> LinkedArraysVector_t;
    typedef std::vector<ElementArrayBuffer> LinkedElementsVector_t;
    
    LinkedArraysVector_t linked_vbos;
    LinkedElementsVector_t linked_elbos;

public:
    using vboiterator = LinkedArraysVector_t::iterator;
    using const_vboiterator = LinkedArraysVector_t::const_iterator;

    inline const_vboiterator linkedArrayBufsBegin() const {return(linked_vbos.begin());}
    inline vboiterator linkedArrayBufsBegin() {return(linked_vbos.begin());}
    inline const_vboiterator linkedArrayBufsEnd() const {return(linked_vbos.end());}
    inline vboiterator linkedArrayBufsEnd() {return(linked_vbos.end());}
    inline std::vector<ElementArrayBuffer>::const_iterator linkedElementBufsBegin() const {return(linked_elbos.begin());}
    inline std::vector<ElementArrayBuffer>::iterator linkedElementBufsBegin() {return(linked_elbos.begin());}
    inline std::vector<ElementArrayBuffer>::const_iterator linkedElementBufsEnd() const {return(linked_elbos.end());}
    inline std::vector<ElementArrayBuffer>::iterator linkedElementBufsEnd() {return(linked_elbos.end());}

    void autoSetupBuffersForDraw();
    void autoDisableBuffersAfterDraw();
};

} // Namespace OOOGL

#endif