Support index buffer

Author: floppyhammer

pathfinder/gpu/command_encoder.cpp

@@ -94,6 +94,22 @@ void CommandEncoder::draw(uint32_t first_vertex, uint32_t vertex_count) {
     commands_.push_back(cmd);
 }
 
+void CommandEncoder::draw_indexed(uint32_t index_count,
+                                  uint32_t instance_count,
+                                  uint32_t first_index,
+                                  uint32_t first_instance) {
+    Command cmd;
+    cmd.type = CommandType::DrawIndexed;
+
+    auto &args = cmd.args.draw_indexed;
+    args.index_count = index_count;
+    args.first_index = first_index;
+    args.instance_count = instance_count;
+    args.first_instance = first_instance;
+
+    commands_.push_back(cmd);
+}
+
 void CommandEncoder::draw_instanced(uint32_t vertex_count, uint32_t instance_count) {
     Command cmd{};
     cmd.type = CommandType::DrawInstanced;

pathfinder/gpu/command_encoder.h

@@ -28,6 +28,7 @@ enum class CommandType {
     BindVertexBuffers,
     BindDescriptorSet,
     Draw,
+    DrawIndexed,
     DrawInstanced,
     DrawIndirect,
     EndRenderPass,
@@ -80,6 +81,12 @@ struct Command {
             uint32_t first_vertex;
             uint32_t vertex_count;
         } draw;
+        struct {
+            uint32_t index_count;
+            uint32_t first_index;
+            uint32_t instance_count;
+            uint32_t first_instance;
+        } draw_indexed;
         struct {
             uint32_t vertex_count;
             uint32_t instance_count;
@@ -159,6 +166,9 @@ class CommandEncoder {
     /// Draw call.
     void draw(uint32_t first_vertex, uint32_t vertex_count);
 
+    /// We don't support vertex offset, as it's not supported by GLES 3.0.
+    void draw_indexed(uint32_t index_count, uint32_t instance_count, uint32_t first_index, uint32_t first_instance);
+
     void draw_instanced(uint32_t vertex_count, uint32_t instance_count);
 
     void draw_indirect(Buffer *buffer, uint32_t offset);

pathfinder/gpu/gl/buffer.cpp

@@ -26,8 +26,7 @@ BufferGl::BufferGl(const BufferDescriptor &desc) : Buffer(desc) {
             target = GL_ARRAY_BUFFER;
         } break;
         case BufferType::Index: {
-            Logger::error("Cannot handle index buffers yet!");
-            abort();
+            target = GL_ELEMENT_ARRAY_BUFFER;
         } break;
         case BufferType::Storage: {
 #ifdef PATHFINDER_ENABLE_COMPUTE
@@ -58,7 +57,7 @@ void BufferGl::upload_via_mapping(size_t data_size, size_t offset, const void *d
             gl_buffer_type = GL_UNIFORM_BUFFER;
         } break;
         case BufferType::Index: {
-            Logger::error("Cannot handle index buffers yet!");
+            gl_buffer_type = GL_ELEMENT_ARRAY_BUFFER;
         } break;
         case BufferType::Storage: {
 #ifdef PATHFINDER_ENABLE_COMPUTE

pathfinder/gpu/gl/command_encoder.cpp

@@ -218,6 +218,17 @@ bool CommandEncoderGl::finish() {
 
                 gl_check_error("Draw");
             } break;
+            case CommandType::DrawIndexed: {
+                auto &args = cmd.args.draw_indexed;
+
+                glDrawElementsInstanced(GL_TRIANGLES,
+                                        GLint(args.index_count),
+                                        GL_UNSIGNED_INT,
+                                        reinterpret_cast<void *>(args.first_index),
+                                        args.instance_count);
+
+                gl_check_error("DrawIndexed");
+            } break;
             case CommandType::DrawInstanced: {
                 auto &args = cmd.args.draw_instanced;
 

pathfinder/gpu/vk/command_encoder.cpp

@@ -317,6 +317,15 @@ bool CommandEncoderVk::finish() {
                 auto &args = cmd.args.draw;
                 vkCmdDraw(vk_command_buffer_, args.vertex_count, 1, 0, 0);
             } break;
+            case CommandType::DrawIndexed: {
+                auto &args = cmd.args.draw_indexed;
+                vkCmdDrawIndexed(vk_command_buffer_,
+                                 args.index_count,
+                                 args.instance_count,
+                                 args.first_index,
+                                 0, // No support for vertex offset
+                                 args.first_instance);
+            } break;
             case CommandType::DrawInstanced: {
                 auto &args = cmd.args.draw_instanced;
                 vkCmdDraw(vk_command_buffer_, args.vertex_count, args.instance_count, 0, 0);

pathfinder/gpu/vk/device.cpp

@@ -392,10 +392,17 @@ std::shared_ptr<Buffer> DeviceVk::create_buffer(const BufferDescriptor &desc, co
                              buffer_vk->vk_buffer_,
                              buffer_vk->vk_device_memory_);
         } break;
+        case BufferType::Index: {
+            create_vk_buffer(desc.size,
+                             VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+                             vk_memory_property,
+                             buffer_vk->vk_buffer_,
+                             buffer_vk->vk_device_memory_);
+        } break;
         case BufferType::Storage: {
             create_vk_buffer(desc.size,
                              VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                                 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+                                 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
                              vk_memory_property,
                              buffer_vk->vk_buffer_,
                              buffer_vk->vk_device_memory_);