OpenGLStorageBuffer.cpp

#include "OloEnginePCH.h"
#include "Platform/OpenGL/OpenGLStorageBuffer.h"
#include "Platform/OpenGL/OpenGLUtilities.h"
#include "OloEngine/Renderer/Commands/FrameResourceManager.h"
#include "OloEngine/Renderer/Debug/RendererMemoryTracker.h"
#include "OloEngine/Renderer/Debug/RendererProfiler.h"
#include "OloEngine/Renderer/Debug/GPUResourceInspector.h"

#include <glad/gl.h>

#include <cstring>

namespace OloEngine
{
    OpenGLStorageBuffer::OpenGLStorageBuffer(u32 size, u32 binding, StorageBufferUsage usage)
        : m_Size(size), m_Binding(binding), m_Usage(usage)
    {
        glCreateBuffers(1, &m_RendererID);
        m_RHIHandle.Sync(RHI::ResourceKind::Buffer, m_RendererID, RHI::Backend::OpenGL);
        glNamedBufferData(m_RendererID, size, nullptr, ToGLUsage());
        if (binding != StorageBuffer::kNoBinding)
            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, binding, m_RendererID);

        RendererProfiler::GetInstance().IncrementCounter(RendererProfiler::MetricType::BufferBinds, 1);

        OLO_TRACK_GPU_ALLOC(this, size, RendererMemoryTracker::ResourceType::StorageBuffer, "OpenGL Storage Buffer");
        GPUResourceInspector::GetInstance().RegisterBuffer(m_RendererID, GL_SHADER_STORAGE_BUFFER, "StorageBuffer");
    }

    OpenGLStorageBuffer::~OpenGLStorageBuffer()
    {
        // Resident until the deferred delete runs: counted as retiring (#1342).
        const u64 retireTicket = OLO_TRACK_RETIRE(this);
        GPUResourceInspector::GetInstance().UnregisterResource(m_RendererID);

        u32 id = m_RendererID;
        FrameResourceManager::Get().SubmitForDeletion([id, retireTicket]()
                                                      {
                                                          glDeleteBuffers(1, &id);
                                                          OLO_TRACK_RELEASE_RETIRED(retireTicket); });
    }

    void OpenGLStorageBuffer::Bind() const
    {
        if (m_Binding != StorageBuffer::kNoBinding)
            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, m_Binding, m_RendererID);
    }

    void OpenGLStorageBuffer::Unbind() const
    {
        if (m_Binding != StorageBuffer::kNoBinding)
            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, m_Binding, 0);
    }

    void OpenGLStorageBuffer::SetData(const void* data, u32 size, u32 offset)
    {
        OLO_CORE_ASSERT(offset + size <= m_Size, "StorageBuffer::SetData out of range!");
        glNamedBufferSubData(m_RendererID, static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size), data);
    }

    bool OpenGLStorageBuffer::GetData(void* outData, u32 size, u32 offset) const
    {
        OLO_CORE_ASSERT(offset + size <= m_Size, "StorageBuffer::GetData out of range!");
        if (outData == nullptr || static_cast<u64>(offset) + size > m_Size)
            return false;
        Utils::DrainGLErrors();
        glGetNamedBufferSubData(m_RendererID, static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size), outData);
        if (glGetError() != GL_NO_ERROR)
        {
            std::memset(outData, 0, size);
            return false;
        }
        return true;
    }

    void OpenGLStorageBuffer::ClearData()
    {
        glClearNamedBufferData(m_RendererID, GL_R8, GL_RED, GL_UNSIGNED_BYTE, nullptr);
    }

    void OpenGLStorageBuffer::ClearData(u32 offset, u32 size)
    {
        OLO_CORE_ASSERT(static_cast<u64>(offset) + size <= m_Size, "StorageBuffer::ClearData range out of bounds!");
        OLO_CORE_ASSERT((offset % 4u) == 0u && (size % 4u) == 0u, "StorageBuffer::ClearData range must be 4-byte aligned");
        if (size == 0u)
            return;
        glClearNamedBufferSubData(m_RendererID, GL_R8, offset, size, GL_RED, GL_UNSIGNED_BYTE, nullptr);
    }

    void OpenGLStorageBuffer::Resize(u32 newSize)
    {
        OLO_PROFILE_FUNCTION();

        // The old buffer and the new one coexist until the deferred delete runs: the old
        // one is counted as retiring, so a resize shows its real transient peak (#1342).
        const u64 retireTicket = OLO_TRACK_RETIRE(this);
        GPUResourceInspector::GetInstance().UnregisterResource(m_RendererID);

        u32 oldId = m_RendererID;
        FrameResourceManager::Get().SubmitForDeletion([oldId, retireTicket]()
                                                      {
                                                          glDeleteBuffers(1, &oldId);
                                                          OLO_TRACK_RELEASE_RETIRED(retireTicket); });

        m_Size = newSize;

        glCreateBuffers(1, &m_RendererID);
        m_RHIHandle.Sync(RHI::ResourceKind::Buffer, m_RendererID, RHI::Backend::OpenGL);
        glNamedBufferData(m_RendererID, newSize, nullptr, ToGLUsage());
        if (m_Binding != StorageBuffer::kNoBinding)
            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, m_Binding, m_RendererID);

        RendererProfiler::GetInstance().IncrementCounter(RendererProfiler::MetricType::BufferBinds, 1);
        OLO_TRACK_GPU_ALLOC(this, newSize, RendererMemoryTracker::ResourceType::StorageBuffer, "OpenGL Storage Buffer");
        GPUResourceInspector::GetInstance().RegisterBuffer(m_RendererID, GL_SHADER_STORAGE_BUFFER, "StorageBuffer");
    }

    GLenum OpenGLStorageBuffer::ToGLUsage() const
    {
        switch (m_Usage)
        {
            case StorageBufferUsage::DynamicDraw:
            // DynamicDrawExactUpload is a DynamicDraw buffer plus a VULKAN-side
            // decision about how much of it to snapshot per frame (see
            // VulkanStorageBuffer.cpp). GL has no equivalent knob, so the hint
            // is identical — but it has to be SAID, because InstanceBuffer
            // constructs with this usage and therefore every mesh draw reaches
            // here. Falling into `default` asserted on the first draw of any
            // GL frame in Debug; Release returned GL_DYNAMIC_DRAW and was fine,
            // and no CI config builds Debug, so it stayed invisible.
            case StorageBufferUsage::DynamicDrawExactUpload:
                return GL_DYNAMIC_DRAW;
            case StorageBufferUsage::DynamicCopy:
                return GL_DYNAMIC_COPY;
            // Rewritten in full every frame and read by the frame's draws: the
            // textbook STREAM hint. The Vulkan-side meaning (a recorded transfer
            // rather than a snapshot) has no GL equivalent to ask for —
            // glNamedBufferSubData is already command-ordered.
            case StorageBufferUsage::StreamCommandOrdered:
                return GL_STREAM_DRAW;
        }

        // No `default` above, deliberately: a fourth usage is now a -Wswitch
        // compile error here rather than a Debug-only assert at first draw.
        // This line is reached only by a value cast in from outside the enum.
        OLO_CORE_ASSERT(false, "Unknown StorageBufferUsage!");
        return GL_DYNAMIC_DRAW;
    }
} // namespace OloEngine