GLBuffer.h

Go to the documentation of this file.

#pragma once
#include "GLESInterface/Headers/GLESGraphicsDevice.h"
#include "GLESInterface/Headers/GLESShader.h"
#include "NDEVRGraphics/Headers/GraphicsBuffer.h"
#include "NDEVRGraphics/Headers/GraphicsException.h"
#include "Base/Headers/Translator.h"
#include <QOpenGLFunctions>
namespace NDEVR
{
    class OpenGLBuffer : public GraphicsBuffer
    {
    public:
        OpenGLBuffer(const String& 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>::NaN;
        }
        ~OpenGLBuffer()
        {
            cleanup();
        }
 
        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() 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 && !isNaN(m_buffer))
            {
                m_context->glDeleteBuffers(1, &m_buffer);
                m_buffer = Constant<uint04>::NaN;
            }
            m_allocated_size = 0;
            m_size = 0;
        }
        void getFromVideoCard(bool) final override 
        {
            if (!m_is_accessable)
            {
                uint04 old_size = size();
                cleanup();
                m_allocated_size = old_size;
                m_temp_buffer.setSize(old_size);
                m_size = old_size;
                m_is_accessable = true;
            }
        };
        void sendToVideoCard(bool) final override
        {
            if (m_is_accessable)
            {
                uint04 alloc_size = size();
                m_buffer = createBuffer(alloc_size, alloc_size, type().total_size, GL_STATIC_DRAW, m_temp_buffer.begin());
                m_temp_buffer.clear();
                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_INT;
            }
            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().is_color)
                return 1;
            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
        {
            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
        {
            lib_assert(offset == 0, "Bad offset?");
            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");
            }
        }
        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.modifiedTime();
        }
        GLuint bufferID() const
        {
            lib_assert(!isNaN(m_buffer), "Bad buffer");
            return m_buffer;
        }
        void bind()
        {
            m_context->glBindBuffer(bindLocation(), bufferID());
        }
 
        void setUniformAttribute(const GLESShader& shader, const char* location)
        {
            lib_assert(!m_is_accessable, "Buffer not setup");
            bind();
            GLint idx = m_context->glGetUniformBlockIndex(shader.id(), location);
            m_context->glUniformBlockBinding(shader.id(), idx, 0);
            m_context->glBindBufferRange(bindLocation(), 0, bufferID(), 0, type().total_size);
        }
        void setAttribute(GLint attribute, uint04 offset = 0, uint04 stride = Constant<uint04>::NaN)
        {
            if (isNaN(stride))
                stride = vectorSize();
            size_t loc = offset * typeStride();
            GLsizei gl_stride = cast<GLsizei>(stride * typeStride());
            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");
            bind();
            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:
                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:
        GLuint createBuffer(uint04& allocation_size, uint04 buffer_size, uint04 object_size, GLuint usage, const void* data)
        {
            lib_assert(buffer_size > 0, "Bad buffer size");
            lib_assert(isNaN(m_buffer), "Bad buffer generation");
            GLuint buffer = 0;
            m_context->glGenBuffers(1, &buffer);
            lib_assert(buffer != 0, "Bad buffer allocation");
            m_context->glBindBuffer(bindLocation(), buffer);
            allocation_size = buffer_size;
            m_context->glBufferData(bindLocation(), buffer_size * object_size, data, usage);
            return buffer;
        }
        GLuint m_buffer = Constant<uint04>::NaN;
        DynamicPointer<GLESGraphicsDevice> m_context;
        Buffer<uint01> m_temp_buffer;
        // Other member variables as needed...
    };
}