Share retained mesh dispatch bridge

src/legacy_gl_mesh_dispatch.h

@@ -0,0 +1,182 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+#include "log.h"
+#include "renderer_gl/opengl_capabilities.h"
+
+namespace pp::legacy::gl_mesh {
+
+inline void gen_opengl_buffers(std::uint32_t count, std::uint32_t* ids) noexcept
+{
+    glGenBuffers(static_cast<GLsizei>(count), reinterpret_cast<GLuint*>(ids));
+}
+
+inline void delete_opengl_buffers(std::uint32_t count, const std::uint32_t* ids) noexcept
+{
+    glDeleteBuffers(static_cast<GLsizei>(count), reinterpret_cast<const GLuint*>(ids));
+}
+
+inline void bind_opengl_buffer(std::uint32_t target, std::uint32_t buffer) noexcept
+{
+    glBindBuffer(static_cast<GLenum>(target), static_cast<GLuint>(buffer));
+}
+
+inline void set_opengl_buffer_data(
+    std::uint32_t target,
+    std::intptr_t byte_count,
+    const void* data,
+    std::uint32_t usage) noexcept
+{
+    glBufferData(
+        static_cast<GLenum>(target),
+        static_cast<GLsizeiptr>(byte_count),
+        data,
+        static_cast<GLenum>(usage));
+}
+
+inline void gen_opengl_vertex_arrays(std::uint32_t count, std::uint32_t* ids) noexcept
+{
+    glGenVertexArrays(static_cast<GLsizei>(count), reinterpret_cast<GLuint*>(ids));
+}
+
+inline void delete_opengl_vertex_arrays(std::uint32_t count, const std::uint32_t* ids) noexcept
+{
+    glDeleteVertexArrays(static_cast<GLsizei>(count), reinterpret_cast<const GLuint*>(ids));
+}
+
+inline void bind_opengl_vertex_array(std::uint32_t vertex_array) noexcept
+{
+    glBindVertexArray(static_cast<GLuint>(vertex_array));
+}
+
+inline void enable_opengl_vertex_attrib_array(std::uint32_t index) noexcept
+{
+    glEnableVertexAttribArray(static_cast<GLuint>(index));
+}
+
+inline void set_opengl_vertex_attrib_pointer(
+    std::uint32_t index,
+    std::int32_t component_count,
+    std::uint32_t component_type,
+    std::uint8_t normalized,
+    std::int32_t stride,
+    const void* offset) noexcept
+{
+    glVertexAttribPointer(
+        static_cast<GLuint>(index),
+        static_cast<GLint>(component_count),
+        static_cast<GLenum>(component_type),
+        static_cast<GLboolean>(normalized),
+        static_cast<GLsizei>(stride),
+        offset);
+}
+
+inline void draw_opengl_elements(
+    std::uint32_t mode,
+    std::int32_t count,
+    std::uint32_t index_type,
+    const void* index_offset) noexcept
+{
+    glDrawElements(
+        static_cast<GLenum>(mode),
+        static_cast<GLsizei>(count),
+        static_cast<GLenum>(index_type),
+        index_offset);
+}
+
+inline void draw_opengl_arrays(std::uint32_t mode, std::int32_t first, std::int32_t count) noexcept
+{
+    glDrawArrays(static_cast<GLenum>(mode), static_cast<GLint>(first), static_cast<GLsizei>(count));
+}
+
+inline pp::renderer::gl::OpenGlMeshCreateDispatch mesh_create_dispatch() noexcept
+{
+    return pp::renderer::gl::OpenGlMeshCreateDispatch {
+        .gen_buffers = gen_opengl_buffers,
+        .bind_buffer = bind_opengl_buffer,
+        .buffer_data = set_opengl_buffer_data,
+        .gen_vertex_arrays = gen_opengl_vertex_arrays,
+        .bind_vertex_array = bind_opengl_vertex_array,
+        .enable_vertex_attrib_array = enable_opengl_vertex_attrib_array,
+        .vertex_attrib_pointer = set_opengl_vertex_attrib_pointer,
+    };
+}
+
+inline pp::renderer::gl::OpenGlBufferUploadDispatch buffer_upload_dispatch() noexcept
+{
+    return pp::renderer::gl::OpenGlBufferUploadDispatch {
+        .bind_buffer = bind_opengl_buffer,
+        .buffer_data = set_opengl_buffer_data,
+    };
+}
+
+inline pp::renderer::gl::OpenGlMeshDrawDispatch mesh_draw_dispatch() noexcept
+{
+    return pp::renderer::gl::OpenGlMeshDrawDispatch {
+        .bind_vertex_array = bind_opengl_vertex_array,
+        .draw_elements = draw_opengl_elements,
+        .draw_arrays = draw_opengl_arrays,
+    };
+}
+
+inline pp::renderer::gl::OpenGlMeshDeleteDispatch mesh_delete_dispatch() noexcept
+{
+    return pp::renderer::gl::OpenGlMeshDeleteDispatch {
+        .delete_buffers = delete_opengl_buffers,
+        .delete_vertex_arrays = delete_opengl_vertex_arrays,
+    };
+}
+
+inline pp::renderer::gl::OpenGlMeshObjects create_mesh_objects(
+    pp::renderer::gl::OpenGlMeshUpload upload,
+    const char* context)
+{
+    const auto mesh = pp::renderer::gl::create_opengl_mesh_objects(upload, mesh_create_dispatch());
+    if (!mesh.ok()) {
+        LOG("%s failed because: %s", context, mesh.status().message);
+        return {};
+    }
+    return mesh.value();
+}
+
+inline bool upload_buffer_data(pp::renderer::gl::OpenGlBufferUpload upload, const char* context)
+{
+    const auto status = pp::renderer::gl::upload_opengl_buffer_data(upload, buffer_upload_dispatch());
+    if (!status.ok()) {
+        LOG("%s failed because: %s", context, status.message);
+        return false;
+    }
+    return true;
+}
+
+inline bool draw_mesh(pp::renderer::gl::OpenGlMeshDraw draw, const char* context)
+{
+    const auto status = pp::renderer::gl::draw_opengl_mesh(draw, mesh_draw_dispatch());
+    if (!status.ok()) {
+        LOG("%s failed because: %s", context, status.message);
+        return false;
+    }
+    return true;
+}
+
+inline bool delete_mesh_objects(
+    std::array<std::uint32_t, 2> buffers,
+    std::array<std::uint32_t, 2> vertex_arrays,
+    const char* context)
+{
+    const auto status = pp::renderer::gl::delete_opengl_mesh_objects(
+        pp::renderer::gl::OpenGlMeshDelete {
+            .buffers = buffers,
+            .vertex_arrays = vertex_arrays,
+        },
+        mesh_delete_dispatch());
+    if (!status.ok()) {
+        LOG("%s failed because: %s", context, status.message);
+        return false;
+    }
+    return true;
+}
+
+} // namespace pp::legacy::gl_mesh