GLBuffer.h

#pragma once
#include "../Headers/GLESGraphicsDevice.h"
#include <NDEVR/GraphicsBuffer.h>
#include <NDEVR/GraphicsException.h>
#include <NDEVR/Translator.h>
#include <QOpenGLFunctions>
namespace NDEVR
{
    class OpenGLBuffer : public GraphicsBuffer
    {
    public:
        OpenGLBuffer(const StringView& label, const DynamicPointer<GLESGraphicsDevice>& device)
            : GraphicsBuffer(label)
            , m_context(device)
        {
            //m_context->glGenBuffers(1, &m_buffer);
        }

        OpenGLBuffer(const TableColumn& reference_data, const DynamicPointer<GLESGraphicsDevice>& device)
            : GraphicsBuffer(reference_data.label())
            , m_context(device)
        {
            copyData(reference_data, true);
        }

        OpenGLBuffer(OpenGLBuffer&& other) noexcept
            : GraphicsBuffer(std::move(other))
            , m_buffer(other.m_buffer)
            , m_context(other.m_context)
        {
            other.m_buffer = Constant<uint04>::Invalid;
        }

        ~OpenGLBuffer()
        {
            cleanup();
        }

        virtual void setDefaultValueFrom(const TableColumn&) override {}
        void* mapMemory(size_t offset, size_t size) const final override
        {
            lib_assert(size > 0, "Bad size map");
            UNUSED(size);
            if (!m_is_accessable)
                throw GraphicsException(_t("OpenGL Buffer Error"), _td("opengl_buffer_memory_cannot_map", "Memory [label] Could not be mapped.").replace("label", m_label));
 
            lib_assert(offset + size <= m_size * type().total_size, "Bad size update");
            return m_temp_buffer.begin(cast<uint04>(offset));
        }

        void unmapMemory(size_t, size_t) const final override
        {
            //m_context->glBindBuffer(bindLocation(), bufferID());
            //m_context->glFlushMappedBufferRange(bindLocation(), m_mapped_start, m_mapped_size);
            //m_context->glUnmapBuffer(bindLocation());
        }

        void cleanup() final override
        {
            if (m_is_memory_owner && IsValid(m_buffer))
            {
                m_context->glDeleteBuffers(1, &m_buffer);
                m_buffer = Constant<uint04>::Invalid;
            }
            m_allocated_size = 0;
            m_size = 0;
        }

        void getFromVideoCard(bool) final override
        {
            if (!m_is_accessable)
            {
                m_is_accessable = true;
                m_temp_buffer.setSize(cast<uint04>(m_allocated_size * type().total_size));
            }
        };

        void sendToVideoCard(bool) final override
        {
            if (m_is_accessable)
            {
                if(IsInvalid(m_buffer))
                    createBuffer(GL_STATIC_DRAW, m_temp_buffer.begin());
                else
                    setBuffer(GL_STATIC_DRAW, m_temp_buffer.begin());
                m_temp_buffer.clear();
                if (m_internal_type != INSTANCE)//keep the instance around as it changes regularly
                    m_temp_buffer.ensureCapacity(0, true, true);
                m_is_accessable = false;
            }
        };

        GLuint getFormat(uint01) const
        {
            if (type().is_number)
            {
                switch (type().byte_size)
                {
                case 1:
                    if (type().is_unsigned) return GL_UNSIGNED_BYTE;
                    else                    return GL_BYTE;
                case 2:
                    if (type().is_float)    return GL_SHORT;
                    if (type().is_unsigned) return GL_UNSIGNED_SHORT;
                    else                    return GL_SHORT;
                case 4:
                    if (type().is_float)    return GL_FLOAT;
                    if (type().is_unsigned) return GL_UNSIGNED_INT;
                    else                    return GL_INT;
                #ifdef GL_DOUBLE 
                case 8:
                    if (type().is_float)    return GL_DOUBLE;
                    break;
                #endif
                case 16:
                    if (type().is_float)    return GL_FLOAT;
                    break;
                default:
                    break;
                }
            }
            else if (type().is_color)
            {
                return GL_UNSIGNED_BYTE;
            }
            lib_assert(false, "unknown vulkanbuffer format");
            return GL_INT;
        };

        uint04 typeStride() const
        {
            //if (type().is_color)
                //return 4;
            switch (type().byte_size)
            {
            case 1: return 1;
            case 2: return 2;
            case 4: return 4;
            case 8: return 8;
            case 16: return 4;
            default:
                lib_assert(false, "unknown vulkanbuffer format");
                break;
            }
            return 1;
        };

        GLint vectorSize() const
        {
            if (type().byte_size == 16)
                return 4;//we are a 4x4 matrix
            return cast<GLint>(getMax<uint02>(1U, type().vector_size));
        };

        GLuint getFormat() const
        {
            return getFormat(0);
        }

        void insertRows(uint04, uint04) final override
        {
            lib_assert(false, "Not yet implemented");
        };

        void setSize(uint04 buffer_size) final override
        {
            if (m_size == buffer_size)
                return;
            lib_assert(m_is_accessable, "Should only be called when accessable");
            m_temp_buffer.setSize(buffer_size * type().total_size);
            m_size = buffer_size;
            m_allocated_size = buffer_size;
        }

        void updateRegion(const TableColumn& reference_data, uint04 offset, uint04 size) final override
        {
            if (m_is_accessable)
            {
                void* data = mapMemory(cast<size_t>(offset) * type().total_size, size * type().total_size);
                if (reference_data.type() == type())
                {
                    memcpy((uint01*)data, (uint01*)reference_data.begin() + (cast<size_t>(offset) * type().total_size), size * type().total_size);
                }
                else
                {
                    lib_assert(false, "Not yet implimented");
                }
            }
            else
            {
                setSubBuffer(offset, size, (uint01*)reference_data.begin() + (cast<size_t>(offset) * type().total_size));
            }
        }

        void copyData(const TableColumn& reference_data, bool set_type) final override
        {
 
            if (set_type && m_type != reference_data.type())
            {
                cleanup();
                setType(reference_data.type());
            }
            setSize(reference_data.size());
            updateRegion(reference_data, 0, reference_data.size());
            m_modified_time = reference_data.getModifiedTime();
        }

        GLuint bufferID() const
        {
            lib_assert(IsValid(m_buffer), "Bad buffer");
            return m_buffer;
        }

        void bind()
        {
            m_context->glBindBuffer(bindLocation(), bufferID());
        }

        void bind(uint04 offset, uint04 size)
        {
            lib_assert(offset + size <= this->size(), "invalid bind location");
            m_context->glBindBufferRange(bindLocation(), 0, bufferID(), type().total_size * offset, type().total_size * size);
        }

        void setAttributeRange(GLint attribute, uint04 buffer_start, uint04 buffer_size, uint04 offset = 0, uint04 stride = Constant<uint04>::Invalid)
        {
            if (IsInvalid(stride))
                stride = vectorSize();
            size_t loc = offset * typeStride();
            GLsizei gl_stride = cast<GLsizei>(stride * typeStride());
            bind(buffer_start, buffer_size);
            setRawAttribute(attribute, vectorSize(), getFormat(), gl_stride, loc);
        }

        void setAttribute(GLint attribute, uint04 offset = 0, uint04 stride = Constant<uint04>::Invalid)
        {
            if (IsInvalid(stride))
                stride = vectorSize();
            size_t loc = offset * typeStride();
            GLsizei gl_stride = cast<GLsizei>(stride * typeStride());
            bind();
            setRawAttribute(attribute, vectorSize(), getFormat(), gl_stride, loc);
        }

        void setRawAttribute(GLint attribute, uint04 vector_size, GLuint format, GLsizei stride, size_t offset)
        {
            lib_assert(!m_is_accessable, "Buffer not setup");
            m_context->glEnableVertexAttribArray(attribute);
            switch (format)
            {
            case GL_FLOAT:
#ifdef GL_DOUBLE 
            case GL_DOUBLE:
#endif
                m_context->glVertexAttribPointer(attribute, vector_size, format, GL_FALSE, stride, (void*)offset);
                break;
            default:
            {
                /*
                #define GL_UNSIGNED_BYTE                  5121
                #define GL_SHORT                          5122
                #define GL_UNSIGNED_SHORT                 5123
                #define GL_INT                            5124
                #define GL_UINT                           5125
                */
                if (type().is_color)
                    m_context->glVertexAttribPointer(attribute, vector_size, format, GL_TRUE, stride, (void*)offset);
                else if(m_internal_type == Type::VERTEX && type().byte_size < 4)
                    m_context->glVertexAttribPointer(attribute, vector_size, format, GL_FALSE, stride, (void*)offset);
                else
                    m_context->glVertexAttribIPointer(attribute, vector_size, format, stride, (void*)offset);
            } break;
            }
            if (m_internal_type == Type::INSTANCE)
                m_context->glVertexAttribDivisor(attribute, 1);
            release();
        }
        GLuint bindLocation() const
        {
            switch (m_internal_type)
            {
            case Type::INDEX: return GL_ELEMENT_ARRAY_BUFFER; break;
            case Type::INSTANCE: return GL_ARRAY_BUFFER; break;
            case Type::VERTEX: return GL_ARRAY_BUFFER; break;
        #ifdef GL_UNIFORM_BUFFER
            case Type::UNIFORM: return GL_UNIFORM_BUFFER; break;
        #endif
            default: lib_assert(false, "unknown type"); break;
            }
            return GL_ARRAY_BUFFER;
        }

        void release()
        {
            m_context->glBindBuffer(bindLocation(), 0);
        }
    private:
        void createBuffer(GLuint usage, const void* data)
        {
            lib_assert(size() > 0, "Bad buffer size");
            lib_assert(IsInvalid(m_buffer), "Bad buffer generation");
            m_buffer = 0;
            m_context->glGenBuffers(1, &m_buffer);
            setBuffer(usage, data);
        }
        void setBuffer(GLuint usage, const void* data)
        {
            lib_assert(m_buffer != 0, "Bad buffer allocation");
            m_context->glBindBuffer(bindLocation(), m_buffer);
            m_context->glBufferData(bindLocation(), size() * type().total_size, data, usage);
        }
        void setSubBuffer(uint04 offset, uint04 size, const void* data)
        {
            lib_assert(m_buffer != 0, "Bad buffer allocation");
            m_context->glBindBuffer(bindLocation(), m_buffer);
            m_context->glBufferSubData(bindLocation(), offset * type().total_size, size * type().total_size, data);
        }
        GLuint m_buffer = Constant<uint04>::Invalid;        
        DynamicPointer<GLESGraphicsDevice> m_context;      
        Buffer<uint01> m_temp_buffer;                      
    };
}