[render] IndexBuffer class, used for triangle indices

Author: alemuntoni

vclib/render/include/vclib/bgfx/buffers.h

@@ -23,6 +23,7 @@
 #ifndef VCL_BGFX_BUFFERS_H
 #define VCL_BGFX_BUFFERS_H
 
+#include "buffers/index_buffer.h"
 #include "buffers/vertex_buffer.h"
 
 #endif // VCL_BGFX_BUFFERS_H

vclib/render/include/vclib/bgfx/buffers/index_buffer.h

@@ -0,0 +1,116 @@
+/*****************************************************************************
+ * VCLib                                                                     *
+ * Visual Computing Library                                                  *
+ *                                                                           *
+ * Copyright(C) 2021-2025                                                    *
+ * Visual Computing Lab                                                      *
+ * ISTI - Italian National Research Council                                  *
+ *                                                                           *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This program is free software; you can redistribute it and/or modify      *
+ * it under the terms of the Mozilla Public License Version 2.0 as published *
+ * by the Mozilla Foundation; either version 2 of the License, or            *
+ * (at your option) any later version.                                       *
+ *                                                                           *
+ * This program is distributed in the hope that it will be useful,           *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
+ * Mozilla Public License Version 2.0                                        *
+ * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
+ ****************************************************************************/
+
+#ifndef VCL_BGFX_BUFFERS_INDEX_BUFFER_H
+#define VCL_BGFX_BUFFERS_INDEX_BUFFER_H
+
+#include <vclib/types.h>
+
+#include <bgfx/bgfx.h>
+
+#include <utility>
+
+namespace vcl {
+
+class IndexBuffer
+{
+    bgfx::IndexBufferHandle mIndexBufferHandle = BGFX_INVALID_HANDLE;
+
+public:
+    IndexBuffer() = default;
+
+    IndexBuffer(const IndexBuffer& other) = delete;
+
+    IndexBuffer(IndexBuffer&& other) noexcept
+    {
+        mIndexBufferHandle = other.mIndexBufferHandle;
+        other.mIndexBufferHandle = BGFX_INVALID_HANDLE;
+    }
+
+    ~IndexBuffer()
+    {
+        if (bgfx::isValid(mIndexBufferHandle))
+            bgfx::destroy(mIndexBufferHandle);
+    }
+
+    IndexBuffer& operator=(const IndexBuffer& other) = delete;
+
+    IndexBuffer& operator=(IndexBuffer&& other) noexcept
+    {
+        mIndexBufferHandle = other.mIndexBufferHandle;
+        other.mIndexBufferHandle = BGFX_INVALID_HANDLE;
+        return *this;
+    }
+
+    void swap(IndexBuffer& other)
+    {
+        using std::swap;
+        swap(mIndexBufferHandle, other.mIndexBufferHandle);
+    }
+
+    friend void swap(IndexBuffer& a, IndexBuffer& b) { a.swap(b); }
+
+    void set(
+        const void*   bufferIndices,
+        const uint    bufferSize,
+        PrimitiveType type,
+        uint64_t      flags = BGFX_BUFFER_NONE)
+    {
+        flags |= flagsForType(type);
+        set(bgfx::makeRef(bufferIndices, bufferSize * sizeOf(type)), flags);
+    }
+
+    void set(const bgfx::Memory* indices, uint64_t flags = BGFX_BUFFER_NONE)
+    {
+        mIndexBufferHandle = bgfx::createIndexBuffer(indices, flags);
+    }
+
+    void bind() const
+    {
+        bgfx::setIndexBuffer(mIndexBufferHandle);
+    }
+
+    void bindForCompute(
+        uint8_t            stage,
+        bgfx::Access::Enum access = bgfx::Access::Read)
+    {
+        bgfx::setBuffer(stage, mIndexBufferHandle, access);
+    }
+
+private:
+    static uint64_t flagsForType(PrimitiveType type)
+    {
+        switch (type) {
+        case PrimitiveType::INT:
+        case PrimitiveType::UINT: return BGFX_BUFFER_INDEX32;
+        case PrimitiveType::FLOAT:
+            return BGFX_BUFFER_COMPUTE_FORMAT_32X1 |
+                   BGFX_BUFFER_COMPUTE_TYPE_FLOAT;
+        case PrimitiveType::DOUBLE: assert(0); // not supported
+        default: return BGFX_BUFFER_NONE;
+        }
+    }
+};
+
+} // namespace vcl
+
+#endif // VCL_BGFX_BUFFERS_INDEX_BUFFER_H

vclib/render/include/vclib/bgfx/drawable/mesh/mesh_render_buffers.h

@@ -43,7 +43,7 @@ class MeshRenderBuffers : public vcl::MeshRenderData<MeshType>
     VertexBuffer mVertexUVBuffer;
     VertexBuffer mVertexWedgeUVBuffer;
 
-    bgfx::IndexBufferHandle mTriangleIndexBH  = BGFX_INVALID_HANDLE;
+    IndexBuffer mTriangleIndexBuffer;
     bgfx::IndexBufferHandle mTriangleNormalBH = BGFX_INVALID_HANDLE;
     bgfx::IndexBufferHandle mTriangleColorBH  = BGFX_INVALID_HANDLE;
 
@@ -91,7 +91,7 @@ class MeshRenderBuffers : public vcl::MeshRenderData<MeshType>
         swap(mVertexColorsBuffer, other.mVertexColorsBuffer);
         swap(mVertexUVBuffer, other.mVertexUVBuffer);
         swap(mVertexWedgeUVBuffer, other.mVertexWedgeUVBuffer);
-        swap(mTriangleIndexBH, other.mTriangleIndexBH);
+        swap(mTriangleIndexBuffer, other.mTriangleIndexBuffer);
         swap(mTriangleNormalBH, other.mTriangleNormalBH);
         swap(mTriangleColorBH, other.mTriangleColorBH);
         swap(mTriangleTextureIndexBH, other.mTriangleTextureIndexBH);
@@ -130,7 +130,7 @@ class MeshRenderBuffers : public vcl::MeshRenderData<MeshType>
     void bindIndexBuffers(uint indexBufferToBind = Base::TRIANGLES) const
     {
         if (indexBufferToBind == Base::TRIANGLES) {
-            bgfx::setIndexBuffer(mTriangleIndexBH);
+            mTriangleIndexBuffer.bind();
 
             if (bgfx::isValid(mTriangleColorBH)) { // triangle colors
                 bgfx::setBuffer(
@@ -226,11 +226,10 @@ class MeshRenderBuffers : public vcl::MeshRenderData<MeshType>
 
         // triangle index buffer
         if (Base::triangleBufferData()) {
-            mTriangleIndexBH = bgfx::createIndexBuffer(
-                bgfx::makeRef(
-                    Base::triangleBufferData(),
-                    Base::triangleBufferSize() * sizeof(uint32_t)),
-                BGFX_BUFFER_INDEX32);
+            mTriangleIndexBuffer.set(
+                Base::triangleBufferData(),
+                Base::triangleBufferSize(),
+                PrimitiveType::UINT);
         }
 
         // triangle normal buffer
@@ -330,9 +329,6 @@ class MeshRenderBuffers : public vcl::MeshRenderData<MeshType>
 
     void destroyBGFXBuffers()
     {
-        if (bgfx::isValid(mTriangleIndexBH))
-            bgfx::destroy(mTriangleIndexBH);
-
         if (bgfx::isValid(mTriangleNormalBH))
             bgfx::destroy(mTriangleNormalBH);