Refactor gltf loading and triangles attributes

5 files changed, 113 insertions, 138 deletions

diff --git a/src/gltf.cpp b/src/gltf.cpp
index bfd7522..61c68ac 100644
--- a/src/gltf.cpp
+++ b/src/gltf.cpp
@@ -8,8 +8,6 @@
 

 #include "utils.hpp"

 

-const vec3 scale (0.00800000037997961);

-

 node gltf::load(std::filesystem::path &path, std::string &filename, vkrenderer &renderer) {

     std::fstream f(path / filename);

     json gltf_json;

@@ -73,7 +71,10 @@ std::vector<mesh> gltf::load_meshes(json &gltf_json, std::vector<std::vector<uin
         auto &mesh = meshes[mesh_index];

 

         for (auto& primitive: primitives) {

-            mesh.parts.emplace_back(load_primitive(gltf_json, primitive, buffers_content, materials));

+            auto &&part = load_primitive(gltf_json, primitive, buffers_content, materials);

+            mesh.vertices_count += part.vertices_count;

+            mesh.triangles_count += part.triangles_count;

+            mesh.parts.emplace_back(std::move(part));

         }

     }

 

@@ -204,7 +205,6 @@ mesh_part gltf::load_primitive(json &gltf_json, json &primitive, std::vector<std
         uint16_t* indices_start = (uint16_t*)(indices_buffer.data() + indices_offset);

 

         part.indices.resize(indices_length / sizeof(uint16_t));

-

         std::memcpy(part.indices.data(), indices_start, indices_length);

     }

 

@@ -220,12 +220,8 @@ mesh_part gltf::load_primitive(json &gltf_json, json &primitive, std::vector<std
         auto &positions_buffer = buffers_content[positions_buffer_index];

         float* positions_start = (float*)(positions_buffer.data() + positions_offset);

 

-        size_t positions_count = positions_length / (sizeof(float) * 3);

-        part.positions.resize(positions_count);

-

-        for (size_t i = 0; i < positions_count; i++) {

-            part.positions[i] = vec3(positions_start[i * 3], positions_start[i * 3 + 1], positions_start[i * 3 + 2]) * scale;

-        }

+        part.positions.resize(positions_length /  sizeof(float));

+        std::memcpy(part.positions.data(), positions_start, positions_length);

     }

 

     {

@@ -240,12 +236,8 @@ mesh_part gltf::load_primitive(json &gltf_json, json &primitive, std::vector<std
         auto &normals_buffer = buffers_content[normals_buffer_index];

         float* normals_start = (float*)(normals_buffer.data() + normals_offset);

 

-        size_t normals_count = normals_length / (sizeof(float) * 3);

-        part.normals.resize(normals_count);

-

-        for (size_t i = 0; i < normals_count; i++) {

-            part.normals[i] = vec3(normals_start[i * 3], normals_start[i * 3 + 1], normals_start[i * 3 + 2]);

-        }

+        part.normals.resize(normals_length /  sizeof(float));

+        std::memcpy(part.normals.data(), normals_start, normals_length);

     }

 

     {

@@ -260,15 +252,13 @@ mesh_part gltf::load_primitive(json &gltf_json, json &primitive, std::vector<std
         auto &uvs_buffer = buffers_content[uvs_buffer_index];

         float* uvs_start = (float*)(uvs_buffer.data() + uvs_offset);

 

-        size_t uvs_count = uvs_length / (sizeof(float) * 2);

-        part.uvs.resize(uvs_count);

-

-        for (size_t i = 0; i < uvs_count; i++) {

-            part.uvs[i] = vec3(uvs_start[i * 2], uvs_start[i * 2 + 1], 0.0);

-        }

+        part.uvs.resize(uvs_length /  sizeof(float));

+        std::memcpy(part.uvs.data(), uvs_start, uvs_length);

     }

 

     part.mat = materials[primitive["material"].get<uint32_t>()];

+    part.vertices_count = part.positions.size() / 3;

+    part.triangles_count = part.indices.size() / 3;

 

     return std::move(part);

 }

diff --git a/src/main.cpp b/src/main.cpp
index 287b0eb..06c351c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -63,17 +63,14 @@ int main() {
 
     vkrenderer renderer { wnd };
     auto main_scene = scene(cam, width, height, renderer);
-    // vkrenderer renderer { wnd, sizeof(main_scene.meta), sizeof(main_scene.spheres[0]) * main_scene.spheres.size(), sizeof(main_scene.packed_nodes[0]) * main_scene.packed_nodes.size() };
 
-    renderer.create_scene_buffer(sizeof(main_scene.meta));
-    renderer.create_geometry_buffer(sizeof(main_scene.triangles[0]) * main_scene.triangles.size());
-    renderer.create_bvh_buffer(sizeof(main_scene.packed_nodes[0]) * main_scene.packed_nodes.size());
-
-    // Upload scene content
-    std::memcpy(renderer.scene_buffer_ptr(), &main_scene.meta, sizeof(main_scene.meta));
-    renderer.update_geometry_buffer(main_scene.triangles.data());
-    // renderer.update_geometry_buffer(main_scene.spheres.data());
-    renderer.update_bvh_buffer(main_scene.packed_nodes.data());
+    renderer.scene_buffer_addr = main_scene.scene_buffer.device_address;
+    renderer.indices_buffer_addr = main_scene.indices_buffer.device_address;
+    renderer.positions_buffer_addr = main_scene.positions_buffer.device_address;
+    renderer.normals_buffer_addr = main_scene.normals_buffer.device_address;
+    renderer.uvs_buffer_addr = main_scene.uvs_buffer.device_address;
+    renderer.materials_buffer_addr = main_scene.materials_buffer.device_address;
+    renderer.bvh_buffer_addr = main_scene.bvh_buffer.device_address;
 
     auto can_render = true;
 
@@ -101,8 +98,8 @@ int main() {
                     width = event.width;
                     height = event.height;
 
-                    ((scene*) renderer.scene_buffer_ptr())->meta.width = width;
-                    ((scene*) renderer.scene_buffer_ptr())->meta.height = height;
+                    ((scene*) main_scene.scene_buffer_ptr())->meta.width = width;
+                    ((scene*) main_scene.scene_buffer_ptr())->meta.height = height;
 
                     io.DisplaySize.x = (float)width;
                     io.DisplaySize.y = (float)height;
@@ -112,8 +109,8 @@ int main() {
                     } else {
                         can_render = true;
                         renderer.recreate_swapchain();
-                        ((scene*) renderer.scene_buffer_ptr())->meta.cam.set_aspect_ratio((float)event.width / (float)event.height);
-                        ((scene*) renderer.scene_buffer_ptr())->meta.sample_index = 0;
+                        ((scene*) main_scene.scene_buffer_ptr())->meta.cam.set_aspect_ratio((float)event.width / (float)event.height);
+                        ((scene*) main_scene.scene_buffer_ptr())->meta.sample_index = 0;
                     }
 
                     reset_accumulation = true;
@@ -121,7 +118,7 @@ int main() {
                     break;
                 }
                 case EVENT_TYPES::KEY_PRESS: {
-                    auto move_speed = 0.01f * delta_time;
+                    auto move_speed = 1.f * delta_time;
                     if (wnd.keyboard[KEYS::LSHIFT] || wnd.keyboard[KEYS::RSHIFT]) {
                         move_speed *= 10.f;
                     }
@@ -130,44 +127,44 @@ int main() {
 
                     switch (event.key) {
                         case KEYS::W: {
-                            move_vec = ((scene*) renderer.scene_buffer_ptr())->meta.cam.forward * move_speed;
+                            move_vec = ((scene*) main_scene.scene_buffer_ptr())->meta.cam.forward * move_speed;
                             break;
                         }
                         case KEYS::S: {
-                            move_vec = -((scene*) renderer.scene_buffer_ptr())->meta.cam.forward * move_speed;
+                            move_vec = -((scene*) main_scene.scene_buffer_ptr())->meta.cam.forward * move_speed;
                             break;
                         }
                         case KEYS::D: {
-                            move_vec = ((scene*) renderer.scene_buffer_ptr())->meta.cam.right * move_speed;
+                            move_vec = ((scene*) main_scene.scene_buffer_ptr())->meta.cam.right * move_speed;
                             break;
                         }
                         case KEYS::A: {
-                            move_vec = -((scene*) renderer.scene_buffer_ptr())->meta.cam.right * move_speed;
+                            move_vec = -((scene*) main_scene.scene_buffer_ptr())->meta.cam.right * move_speed;
                             break;
                         }
                         case KEYS::E: {
-                            ((scene*) renderer.scene_buffer_ptr())->meta.cam.rotate_y(0.001f * delta_time);
+                            ((scene*) main_scene.scene_buffer_ptr())->meta.cam.rotate_y(0.001f * delta_time);
                             reset_accumulation = true;
                             break;
                         }
                         case KEYS::Q: {
-                            ((scene*) renderer.scene_buffer_ptr())->meta.cam.rotate_y(-0.001f * delta_time);
+                            ((scene*) main_scene.scene_buffer_ptr())->meta.cam.rotate_y(-0.001f * delta_time);
                             reset_accumulation = true;
                             break;
                         }
                         case KEYS::SPACE: {
-                            move_vec = ((scene*) renderer.scene_buffer_ptr())->meta.cam.up * move_speed;
+                            move_vec = ((scene*) main_scene.scene_buffer_ptr())->meta.cam.up * move_speed;
                             break;
                         }
                         case KEYS::LCTRL: {
-                            move_vec = -((scene*) renderer.scene_buffer_ptr())->meta.cam.up * move_speed;
+                            move_vec = -((scene*) main_scene.scene_buffer_ptr())->meta.cam.up * move_speed;
                             break;
                         }
                         default:
                             break;
                     }
 
-                    ((scene*) renderer.scene_buffer_ptr())->meta.cam.move(move_vec);
+                    ((scene*) main_scene.scene_buffer_ptr())->meta.cam.move(move_vec);
 
                     if (!move_vec.near_zero()) {
                         reset_accumulation = true;
@@ -216,19 +213,19 @@ int main() {
 
         ImGui::Text("frame per second %u\n", static_cast<uint32_t>(1000.f / delta_time));
         ImGui::Text("frame time %f ms\n", delta_time);
-        ImGui::Text("frame count %u\n", ((scene*) renderer.scene_buffer_ptr())->meta.sample_index);
+        ImGui::Text("frame count %u\n", ((scene*) main_scene.scene_buffer_ptr())->meta.sample_index);
 
-        if (ImGui::Checkbox("depth of field", (bool*)&((scene*) renderer.scene_buffer_ptr())->meta.enable_dof)) {
+        if (ImGui::Checkbox("depth of field", (bool*)&((scene*) main_scene.scene_buffer_ptr())->meta.enable_dof)) {
             reset_accumulation = true;
         }
 
-        ImGui::SliderInt("max bounces", (int32_t*)&((scene*) renderer.scene_buffer_ptr())->meta.max_bounce, 1, 250);
-        ImGui::SliderInt("min bounces", (int32_t*)&((scene*) renderer.scene_buffer_ptr())->meta.min_bounce, 1, ((scene*) renderer.scene_buffer_ptr())->meta.max_bounce);
-        if (ImGui::SliderInt("downscale factor", (int32_t*)&((scene*) renderer.scene_buffer_ptr())->meta.downscale_factor, 1, 32)) {
+        ImGui::SliderInt("max bounces", (int32_t*)&((scene*) main_scene.scene_buffer_ptr())->meta.max_bounce, 1, 250);
+        ImGui::SliderInt("min bounces", (int32_t*)&((scene*) main_scene.scene_buffer_ptr())->meta.min_bounce, 1, ((scene*) main_scene.scene_buffer_ptr())->meta.max_bounce);
+        if (ImGui::SliderInt("downscale factor", (int32_t*)&((scene*) main_scene.scene_buffer_ptr())->meta.downscale_factor, 1, 32)) {
             reset_accumulation = true;
         }
 
-        if (ImGui::Checkbox("debug bvh", (bool*)&((scene*) renderer.scene_buffer_ptr())->meta.debug_bvh)) {
+        if (ImGui::Checkbox("debug bvh", (bool*)&((scene*) main_scene.scene_buffer_ptr())->meta.debug_bvh)) {
             reset_accumulation = true;
         }
 
@@ -246,14 +243,14 @@ int main() {
             renderer.begin_frame();
 
             if (reset_accumulation) {
-                ((scene*) renderer.scene_buffer_ptr())->meta.sample_index = 0;
+                ((scene*) main_scene.scene_buffer_ptr())->meta.sample_index = 0;
                 renderer.reset_accumulation();
             }
 
-            float scale = (float)((scene*) renderer.scene_buffer_ptr())->meta.downscale_factor;
+            float scale = (float)((scene*) main_scene.scene_buffer_ptr())->meta.downscale_factor;
             renderer.compute(width / scale, height / scale);
 
-            ((scene*) renderer.scene_buffer_ptr())->meta.sample_index++;
+            ((scene*) main_scene.scene_buffer_ptr())->meta.sample_index++;
 
             renderer.ui();
 
diff --git a/src/scene.cpp b/src/scene.cpp
index d162b3a..9caed7b 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -66,6 +66,9 @@ scene::scene(camera cam, uint32_t width, uint32_t height, vkrenderer &renderer)
     // auto sponza_filename = std::string("Sponza.gltf");

     // auto root_node = gltf::load(sponza_path, sponza_filename, renderer);

 

+    std::vector<triangle> triangles;

+    auto triangles_offset = 0;

+    auto vertices_offset = 0;

     std::queue<node> nodes_to_load {};

     nodes_to_load.push(root_node);

 

@@ -74,18 +77,37 @@ scene::scene(camera cam, uint32_t width, uint32_t height, vkrenderer &renderer)
 

         if (node.mesh) {

             auto &mesh = node.mesh.value();

+

+            indices.resize(indices.size()       + mesh.triangles_count * 3);

+            positions.resize(positions.size()   + mesh.vertices_count * 3);

+            normals.resize(normals.size()       + mesh.vertices_count * 3);

+            uvs.resize(uvs.size()               + mesh.vertices_count * 2);

+

+

             for (auto& mesh_part: mesh.parts) {

+                std::memcpy(positions.data()    + vertices_offset * 3, mesh_part.positions.data(), mesh_part.positions.size() * sizeof(float));

+                std::memcpy(normals.data()      + vertices_offset * 3, mesh_part.normals.data(),   mesh_part.normals.size() * sizeof(float));

+                std::memcpy(uvs.data()          + vertices_offset * 2, mesh_part.uvs.data(),       mesh_part.uvs.size() * sizeof(float));

+

                 for (size_t i = 0; i < mesh_part.indices.size(); i += 3) {

                     auto i1 = mesh_part.indices[i];

                     auto i2 = mesh_part.indices[i + 1];

                     auto i3 = mesh_part.indices[i + 2];

 

-                    auto v1 = vertex { .position = mesh_part.positions[i1], .normal = mesh_part.normals[i1], .uv = mesh_part.uvs[i1] };

-                    auto v2 = vertex { .position = mesh_part.positions[i2], .normal = mesh_part.normals[i2], .uv = mesh_part.uvs[i2] };

-                    auto v3 = vertex { .position = mesh_part.positions[i3], .normal = mesh_part.normals[i3], .uv = mesh_part.uvs[i3] };

+                    auto p1 = vec3(mesh_part.positions[i1 * 3], mesh_part.positions[i1 * 3 + 1], mesh_part.positions[i1 * 3 + 2]);

+                    auto p2 = vec3(mesh_part.positions[i2 * 3], mesh_part.positions[i2 * 3 + 1], mesh_part.positions[i2 * 3 + 2]);

+                    auto p3 = vec3(mesh_part.positions[i3 * 3], mesh_part.positions[i3 * 3 + 1], mesh_part.positions[i3 * 3 + 2]);

 

-                    triangles.emplace_back(v1, v2, v3, mesh_part.mat);

+                    indices[triangles_offset * 3 + i]        = (i1 + vertices_offset) | (0xff000000 & (materials.size() << 8));

+                    indices[triangles_offset * 3 + i + 1]    = (i2 + vertices_offset) | (0xff000000 & (materials.size() << 16));

+                    indices[triangles_offset * 3 + i + 2]    = (i3 + vertices_offset) | (0xff000000 & (materials.size() << 24));

+

+                    triangles.emplace_back(p1, p2, p3);

+                    materials.push_back(mesh_part.mat);

                 }

+

+                triangles_offset += mesh_part.triangles_count;

+                vertices_offset += mesh_part.vertices_count;

             }

         }

 

@@ -100,4 +122,25 @@ scene::scene(camera cam, uint32_t width, uint32_t height, vkrenderer &renderer)
 

     bvh builder(triangles, packed_nodes);

     // bvh builder(spheres, packed_nodes);

+

+    scene_buffer = renderer.api.create_buffer(sizeof(meta), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);

+    std::memcpy(scene_buffer.alloc_info.pMappedData, &meta, sizeof(meta));

+

+    indices_buffer = renderer.api.create_buffer(indices.size() * sizeof(indices[0]), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);

+    std::memcpy(indices_buffer.alloc_info.pMappedData, indices.data(), indices.size() * sizeof(indices[0]));

+

+    positions_buffer = renderer.api.create_buffer(positions.size() * sizeof(positions[0]), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);

+    std::memcpy(positions_buffer.alloc_info.pMappedData, positions.data(), positions.size() * sizeof(positions[0]));

+

+    normals_buffer = renderer.api.create_buffer(normals.size() * sizeof(normals[0]), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);

+    std::memcpy(normals_buffer.alloc_info.pMappedData, normals.data(), normals.size() * sizeof(normals[0]));

+

+    uvs_buffer = renderer.api.create_buffer(uvs.size() * sizeof(uvs[0]), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);

+    std::memcpy(uvs_buffer.alloc_info.pMappedData, uvs.data(), uvs.size() * sizeof(uvs[0]));

+

+    bvh_buffer = renderer.api.create_buffer(packed_nodes.size() * sizeof(packed_nodes[0]), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);

+    std::memcpy(bvh_buffer.alloc_info.pMappedData, packed_nodes.data(), packed_nodes.size() * sizeof(packed_nodes[0]));

+

+    materials_buffer = renderer.api.create_buffer(materials.size() * sizeof(materials[0]), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);

+    std::memcpy(materials_buffer.alloc_info.pMappedData, materials.data(), materials.size() * sizeof(materials[0]));

 }

diff --git a/src/vk-api.cpp b/src/vk-api.cpp
index efcd073..3391246 100644
--- a/src/vk-api.cpp
+++ b/src/vk-api.cpp
@@ -98,17 +98,17 @@ vkapi::vkapi() {
         {
             .stageFlags                        = VK_SHADER_STAGE_COMPUTE_BIT,
             .offset                            = 0,
-            .size                              = 32,
+            .size                              = 64,
         },
         {
             .stageFlags                        = VK_SHADER_STAGE_VERTEX_BIT,
-            .offset                            = 32,
-            .size                              = 24,
+            .offset                            = 64,
+            .size                              = 32,
         },
         {
             .stageFlags                        = VK_SHADER_STAGE_FRAGMENT_BIT,
-            .offset                            = 56,
-            .size                              = 8,
+            .offset                            = 96,
+            .size                              = 32,
         },
     };
 
@@ -159,13 +159,13 @@ Buffer vkapi::create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, V
 
     VKRESULT(vmaCreateBuffer(context.allocator, &buffer_info, &alloc_create_info, &buffer.handle, &buffer.alloc, &buffer.alloc_info))
 
-    buffer.size = data_size;
-
     VkBufferDeviceAddressInfo buffer_device_address_info = {};
     buffer_device_address_info.sType    = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
     buffer_device_address_info.pNext    = VK_NULL_HANDLE;
     buffer_device_address_info.buffer   = buffer.handle;
 
+    buffer.size = data_size;
+
     buffer.device_address = vkGetBufferDeviceAddress(context.device, &buffer_device_address_info);
 
     return std::move(buffer);
diff --git a/src/vk-renderer.cpp b/src/vk-renderer.cpp
index 4ac1cd0..ba5f017 100644
--- a/src/vk-renderer.cpp
+++ b/src/vk-renderer.cpp
@@ -143,9 +143,6 @@ vkrenderer::vkrenderer(window& wnd) {
 vkrenderer::~vkrenderer() {
     VKRESULT(vkWaitForFences(api.context.device, submission_fences.size(), submission_fences.data(), VK_TRUE, UINT64_MAX))
 
-    api.destroy_buffer(scene_buffer);
-    api.destroy_buffer(geometry_buffer);
-    api.destroy_buffer(bvh_buffer);
     api.destroy_buffer(staging_buffer);
     api.destroy_fences(submission_fences);
     api.destroy_semaphores(execution_semaphores);
@@ -267,12 +264,12 @@ void vkrenderer::ui() {
         -1.f - draw_data->DisplayPos.x * (2.f / draw_data->DisplaySize.x),
         -1.f - draw_data->DisplayPos.y * (2.f / draw_data->DisplaySize.y),
     };
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 32, 8, (void*)&ui_vertex_buffers[virtual_frame_index].device_address);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 40, 8, (void*)&scale);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 48, 8, (void*)&translate);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 64, 8, (void*)&ui_vertex_buffers[virtual_frame_index].device_address);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 72, 8, (void*)&scale);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 80, 8, (void*)&translate);
 
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 56, 4, (void*)&ui_texture.bindless_sampled_index);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 60, 4, (void*)&ui_texture_sampler.bindless_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 96, 4, (void*)&ui_texture.bindless_sampled_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 100, 4, (void*)&ui_texture_sampler.bindless_index);
 
     off_t vertex_buffer_offset = 0;
     off_t index_buffer_offset = 0;
@@ -304,19 +301,23 @@ void vkrenderer::ui() {
 void vkrenderer::compute(uint32_t width, uint32_t height) {
     auto cmd_buf = command_buffers[virtual_frame_index];
 
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, (void*)&scene_buffer.device_address);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 8, 8, (void*)&geometry_buffer.device_address);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 16, 8, (void*)&bvh_buffer.device_address);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 24, 4, (void*)&accumulation_images[0].bindless_storage_index);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 28, 4, (void*)&accumulation_images[1].bindless_storage_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, (void*)&scene_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 8, 8, (void*)&bvh_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 16, 8, (void*)&indices_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 24, 8, (void*)&positions_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 32, 8, (void*)&normals_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 40, 8, (void*)&uvs_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 48, 8, (void*)&materials_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 56, 4, (void*)&accumulation_images[0].bindless_storage_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 60, 4, (void*)&accumulation_images[1].bindless_storage_index);
     api.run_compute_pipeline(cmd_buf, compute_pipeline, (width / 8) + 1, (height / 8) + 1, 1);
 
 
     api.image_barrier(cmd_buf, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, swapchain.images[swapchain_image_index]);
 
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, (void*)&scene_buffer.device_address);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 8, 4, (void*)&swapchain.images[swapchain_image_index].bindless_storage_index);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 12, 4, (void*)&accumulation_images[0].bindless_storage_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, (void*)&scene_buffer_addr);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 56, 4, (void*)&swapchain.images[swapchain_image_index].bindless_storage_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 60, 4, (void*)&accumulation_images[0].bindless_storage_index);
 
     api.run_compute_pipeline(cmd_buf, tonemapping_pipeline, (width / 8) + 1, (height / 8) + 1, 1);
 }
@@ -405,62 +406,6 @@ void vkrenderer::handle_swapchain_result(VkResult function_result) {
     }
 }
 
-
-void vkrenderer::create_scene_buffer(size_t size) {
-    scene_buffer = api.create_buffer(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
-}
-
-void vkrenderer::create_geometry_buffer(size_t size) {
-    geometry_buffer = api.create_buffer(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY);
-}
-
-void vkrenderer::create_bvh_buffer(size_t size) {
-    bvh_buffer = api.create_buffer(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY);
-}
-
-// TODO: Integrate into the API so that we no longer have to wait for the fence
-void vkrenderer::update_geometry_buffer(void* data) {
-    VKRESULT(vkWaitForFences(api.context.device, 1, &submission_fences[virtual_frame_index], VK_TRUE, UINT64_MAX))
-    VKRESULT(vkResetFences(api.context.device, 1, &submission_fences[virtual_frame_index]))
-
-    auto cmd_buf = command_buffers[virtual_frame_index];
-    api.start_record(cmd_buf);
-
-    auto staging_buffer = api.create_buffer(geometry_buffer.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
-    std::memcpy(staging_buffer.alloc_info.pMappedData, data, staging_buffer.size);
-
-    api.copy_buffer(cmd_buf, staging_buffer, geometry_buffer, staging_buffer.size);
-
-    api.end_record(cmd_buf);
-
-    api.submit(cmd_buf, VK_NULL_HANDLE, VK_NULL_HANDLE, submission_fences[virtual_frame_index]);
-
-    VKRESULT(vkWaitForFences(api.context.device, 1, &submission_fences[virtual_frame_index], VK_TRUE, UINT64_MAX))
-
-    api.destroy_buffer(staging_buffer);
-}
-
-void vkrenderer::update_bvh_buffer(void* data) {
-    VKRESULT(vkWaitForFences(api.context.device, 1, &submission_fences[virtual_frame_index], VK_TRUE, UINT64_MAX))
-    VKRESULT(vkResetFences(api.context.device, 1, &submission_fences[virtual_frame_index]))
-
-    auto cmd_buf = command_buffers[virtual_frame_index];
-    api.start_record(cmd_buf);
-
-    auto staging_buffer = api.create_buffer(bvh_buffer.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
-    std::memcpy(staging_buffer.alloc_info.pMappedData, data, staging_buffer.size);
-
-    api.copy_buffer(cmd_buf, staging_buffer, bvh_buffer, staging_buffer.size);
-
-    api.end_record(cmd_buf);
-
-    api.submit(cmd_buf, VK_NULL_HANDLE, VK_NULL_HANDLE, submission_fences[virtual_frame_index]);
-
-    VKRESULT(vkWaitForFences(api.context.device, 1, &submission_fences[virtual_frame_index], VK_TRUE, UINT64_MAX))
-
-    api.destroy_buffer(staging_buffer);
-}
-
 void vkrenderer::update_image(image img, void* data, size_t size) {
     if (staging_buffer.size < size) {
         api.destroy_buffer(staging_buffer);