Fix bvh generation

4 files changed, 22 insertions, 23 deletions

diff --git a/src/bvh.cpp b/src/bvh.cpp
index a22cd5e..aaa6a42 100644
--- a/src/bvh.cpp
+++ b/src/bvh.cpp
@@ -83,32 +83,30 @@ bvh::bvh(std::vector<triangle>& triangles, std::vector<packed_bvh_node>& packed_
             node.next_id = temp_nodes[old_node.next_id].df_id;
         }
     }
-
-    // exporter();
 }
 
 //-------------------------
 // BVH exporter for graphviz
 //-------------------------
 void bvh::exporter() {
-    std::cout << "digraph bvh {" << std::endl;
+    std::cout << "digraph bvh {\n";
 
     traverse_depth_first(temp_nodes, 0);
 
     // traverse_depth_first_ordered(-1, 0);
 
-    std::cout << "}" << std::endl;
+    std::cout << "}\n";
 }
 
 bool bvh::traverse_depth_first(std::vector<temp_node>& nodes, int32_t id) {
-    if (id <= 0) {
-        std::cout << ";" << std::endl;
+    if (id < 0) {
         return false;
     }
 
-    std::cout << " -> " << id;
     if (traverse_depth_first(nodes, nodes[id].left_id)) {
-        std::cout << "\t " << id;
+        std::cout << id << " -> " << nodes[id].left_id << ";\n";
+        std::cout << id << " -> " << nodes[id].left_id + 1 << ";\n";
+
         traverse_depth_first(nodes, nodes[id].left_id + 1);
     }
 
diff --git a/src/main.cpp b/src/main.cpp
index 576b709..58882d3 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -408,7 +408,7 @@ int main() {
         raytracing_pass->set_ouput_texture(output_texture);
         raytracing_pass->set_constant(60, accumulation_texture);
 
-        update_ui(main_scene, delta_time);
+        // update_ui(main_scene, delta_time);
 
         if (can_render) {
             render(main_scene, renderer);
diff --git a/src/mesh.cpp b/src/mesh.cpp
index bfc5caf..191aaf7 100644
--- a/src/mesh.cpp
+++ b/src/mesh.cpp
@@ -3,11 +3,10 @@
 static std::vector<Mesh> meshes {};
 
 void Mesh::add_submesh(const submesh& submesh) {
-    auto position_components = attribute_components(ATTRIBUTE_TYPE::POSITION);
     submeshes.emplace_back(
         submesh_info {
-            (uint32_t)attributes[ATTRIBUTE_TYPE::POSITION].size() / position_components,
-            (uint32_t)indices.size(),
+            (uint32_t)vertex_count,
+            (uint32_t)index_count,
             submesh.index_count / 3,
             0
         }
diff --git a/src/scene.cpp b/src/scene.cpp
index 2f4aa97..9b9f82e 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -87,12 +87,14 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
         if (node.mesh != nullptr) {

             const auto* mesh = node.mesh;

             const auto& mesh_positions = mesh->get_attribute(ATTRIBUTE_TYPE::POSITION);

+            const auto& mesh_normals = mesh->get_attribute(ATTRIBUTE_TYPE::NORMAL);

+            const auto& mesh_uvs_0 = mesh->get_attribute(ATTRIBUTE_TYPE::UV_0);

             const auto& mesh_indices = mesh->get_indices();

 

             indices.resize(indices.size()      + mesh_indices.size());

             positions.resize(vertices_offset   + mesh_positions.size());

-            normals.resize(vertices_offset     + (size_t)mesh->vertices_count() * Mesh::attribute_components(ATTRIBUTE_TYPE::NORMAL));

-            uvs.resize(vertices_offset         + (size_t)mesh->vertices_count() * Mesh::attribute_components(ATTRIBUTE_TYPE::UV_0));

+            normals.resize(vertices_offset     + mesh_normals.size());

+            uvs.resize(vertices_offset         + mesh_uvs_0.size());

 

             std::memcpy(

                positions.data() + vertices_offset * Mesh::attribute_components(ATTRIBUTE_TYPE::POSITION),

@@ -102,14 +104,14 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
 

             std::memcpy(

                normals.data() + vertices_offset * Mesh::attribute_components(ATTRIBUTE_TYPE::NORMAL),

-               mesh->get_attribute(ATTRIBUTE_TYPE::NORMAL).data(),

-               (size_t)mesh->vertices_count() * Mesh::attribute_components(ATTRIBUTE_TYPE::NORMAL) * sizeof(float)

+               mesh_normals.data(),

+               mesh_normals.size() * sizeof(float)

             );

 

             std::memcpy(

                 uvs.data() + vertices_offset * Mesh::attribute_components(ATTRIBUTE_TYPE::UV_0),

-                mesh->get_attribute(ATTRIBUTE_TYPE::UV_0).data(),

-                (size_t)mesh->vertices_count() * Mesh::attribute_components(ATTRIBUTE_TYPE::UV_0) * sizeof(float)

+                mesh_uvs_0.data(),

+                mesh_uvs_0.size() * sizeof(float)

             );

 

             // Add offset to indices in order to have absolute indices

@@ -118,9 +120,9 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
 

                 for (size_t element_index { 0U }; element_index < submesh.element_count; element_index++) {

                     auto global_index = submesh.index_offset + element_index * 3;

-                    size_t i1 = mesh_indices[global_index];

-                    size_t i2 = mesh_indices[global_index + 1];

-                    size_t i3 = mesh_indices[global_index + 2];

+                    size_t i1 = submesh.vertex_offset + mesh_indices[global_index];

+                    size_t i2 = submesh.vertex_offset + mesh_indices[global_index + 1];

+                    size_t i3 = submesh.vertex_offset + mesh_indices[global_index + 2];

 

                     triangles.emplace_back(

                         vec3 { mesh_positions[i1 * 3], mesh_positions[i1 * 3 + 1], mesh_positions[i1 * 3 + 2] },

@@ -174,6 +176,6 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
     bvh_buffer = vkrenderer::create_buffer(packed_nodes.size() * sizeof(packed_nodes[0]));

     bvh_buffer->write(packed_nodes.data(), 0, packed_nodes.size() * sizeof(packed_nodes[0]));

 

-    materials_buffer = vkrenderer::create_buffer(materials.size() * sizeof(materials[0]));

-    materials_buffer->write(materials.data(), 0, materials.size() * sizeof(materials[0]));

+    // materials_buffer = vkrenderer::create_buffer(materials.size() * sizeof(materials[0]));

+    // materials_buffer->write(materials.data(), 0, materials.size() * sizeof(materials[0]));

 }