# glbuffer.h File Reference

/* This file is part of FineFramework project */
#ifndef FFW_GRAPHICS_GL_BUFFER
#define FFW_GRAPHICS_GL_BUFFER

#include <vector>
#include <cstdint>
#include "glrenderextensions.h"

namespace ffw {
    class RenderContext;
    class FFW_API GLBuffer {
    public:
        GLBuffer();
        GLBuffer(GLenum buffertype, const GLvoid* data, GLsizei size, GLenum type);
        GLBuffer(const GLBuffer& other) = delete;
        GLBuffer(GLBuffer&& other) NOEXCEPT;
        void swap(GLBuffer& other) NOEXCEPT;

        virtual ~GLBuffer();
        inline bool isCreated() const {
            return loaded;
        }
        void resize(const GLvoid* data, GLsizei size);
        void setData(const GLvoid* data, GLsizei offset, GLsizei size);
        void mapBuffer(GLvoid** pointer, GLenum access) const;
        void mapBufferRange(GLvoid** pointer, GLsizei offset, GLsizei size, GLenum access) const;
        void flushMappedBufferRange(GLsizei offset, GLsizei size) const;
        void unMapBuffer() const;
        void destroy();
        void bind() const;
        void unbind() const;
        inline GLuint getHandle() const {
            return buffer;
        }
        inline GLsizei getSize() const {
            return size;
        }
        inline GLenum getAccessType() const {
            return accesstype;
        }
        inline GLenum getBufferType() const {
            return buffertype;
        }
        void copyFrom(const GLBuffer* other, GLintptr readoffset,
            GLintptr writeoffset, GLsizeiptr size);
        void getData(GLvoid* data, GLsizei offset, GLsizei size);
        std::vector<uint8_t> getData(GLsizei offset, GLsizei size);
        GLBuffer& operator = (const GLBuffer& other) = delete;
        GLBuffer& operator = (GLBuffer&& other) NOEXCEPT;
    protected:
        GLenum accesstype;
        GLenum buffertype;
        bool loaded;
        GLuint buffer;
        GLsizei size;
    };
    class FFW_API GLVertexBuffer: public GLBuffer {
    public:
        GLVertexBuffer() = default;
        GLVertexBuffer(const GLvoid* data, const GLsizei size, const GLenum type):
        GLBuffer(GL_ARRAY_BUFFER, data, size, type) {
            
        }

        GLVertexBuffer(const GLVertexBuffer& other) = delete;
        GLVertexBuffer(GLVertexBuffer&& other) NOEXCEPT :GLBuffer(std::forward<GLBuffer>(other)){

        }
        GLVertexBuffer& operator = (const GLVertexBuffer& other) = delete;
        GLVertexBuffer& operator = (GLVertexBuffer&& other) NOEXCEPT {
            GLBuffer::operator=(std::forward<GLBuffer>(other));
            return *this;
        }
    };
    class FFW_API GLElementBuffer: public GLBuffer {
    public:
        GLElementBuffer() = default;
        GLElementBuffer(const GLvoid* data, const GLsizei size, const GLenum type):
        GLBuffer(GL_ELEMENT_ARRAY_BUFFER, data, size, type) {
            
        }

        GLElementBuffer(const GLElementBuffer& other) = delete;
        GLElementBuffer(GLElementBuffer&& other) NOEXCEPT :GLBuffer(std::forward<GLBuffer>(other)) {

        }
        GLElementBuffer& operator = (const GLElementBuffer& other) = delete;
        GLElementBuffer& operator = (GLElementBuffer&& other) NOEXCEPT {
            GLBuffer::operator=(std::forward<GLBuffer>(other));
            return *this;
        }
    };
};

inline void swap(ffw::GLBuffer& first, ffw::GLBuffer& second) NOEXCEPT {
    first.swap(second);
}
inline void swap(ffw::GLVertexBuffer& first, ffw::GLVertexBuffer& second) NOEXCEPT {
    first.swap(second);
}
inline void swap(ffw::GLElementBuffer& first, ffw::GLElementBuffer& second) NOEXCEPT {
    first.swap(second);
}
#endif