Adding model loading and bvh generation

CMakeLists.txt

@@ -11,17 +11,6 @@ set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/external/vcpkg/scripts/buil
 
 project(RayTracer)
 
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/build)
-#Workaround for vs, because it places artifacts into an additional subfolder
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_CURRENT_SOURCE_DIR}/build)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_CURRENT_SOURCE_DIR}/build)
 
 find_package(assimp CONFIG REQUIRED)
 find_package(glfw3 CONFIG REQUIRED)
@@ -29,6 +18,7 @@ find_package(glm CONFIG REQUIRED)
 find_package(Ktx CONFIG REQUIRED)
 
 add_executable(RayTracer "")
+target_include_directories(RayTracer PUBLIC src/)
 target_link_libraries(RayTracer PUBLIC assimp::assimp)
 target_link_libraries(RayTracer PUBLIC glfw)
 target_link_libraries(RayTracer PUBLIC glm::glm)

src/CMakeLists.txt

@@ -4,3 +4,4 @@ target_sources(RayTracer
 
 add_subdirectory(scene/)
 add_subdirectory(window/)
+add_subdirectory(util/)

src/main.cpp

@@ -1,6 +1,11 @@
 #include "window/Window.h"
+#include "util/ModelLoader.h"
+#include "scene/BVH.h"
 
 int main() {
+    BVH bvh;
+    bvh.addModels(ModelLoader::loadModel("../../cube.fbx"));
+    bvh.generate();
 	Window w(1920, 1080);
 	while (true) {
 		w.update();

src/scene/AABB.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <glm/vec3.hpp>
+#include <utility>
+
+struct AABB
+{
+    glm::vec3 min = glm::vec3(std::numeric_limits<float>::max());
+    glm::vec3 max = glm::vec3(std::numeric_limits<float>::lowest());
+    float surfaceArea() const
+    {
+        glm::vec3 d = glm::vec3(max.x - min.x, max.y - min.y, max.z - min.z);
+        return 2.0f * (d.x * d.y + d.y * d.z + d.z * d.x);
+    }
+    void adjust(glm::vec3 pos)
+    {
+        min.x = std::min(min.x, pos.x);
+        min.y = std::min(min.y, pos.y);
+        min.z = std::min(min.z, pos.z);
+
+        max.x = std::max(max.x, pos.x);
+        max.y = std::max(max.y, pos.y);
+        max.z = std::max(max.z, pos.z);
+    }
+    static AABB combine(AABB lhs, AABB rhs)
+    {
+        AABB result;
+
+        result.min.x = std::min(lhs.min.x, rhs.min.x);
+        result.min.y = std::min(lhs.min.y, rhs.min.y);
+        result.min.z = std::min(lhs.min.z, rhs.min.z);
+
+        result.max.x = std::max(lhs.max.x, rhs.max.x);
+        result.max.y = std::max(lhs.max.y, rhs.max.y);
+        result.max.z = std::max(lhs.max.z, rhs.max.z);
+
+        return result;
+    }
+};

src/scene/BVH.cpp

@@ -1 +1,51 @@
 #include "BVH.h"
+#include <list>
+
+void BVH::addModel(PModel model) { models.push_back(std::move(model)); }
+
+void BVH::addModels(std::vector<PModel> _models)
+{
+    for (int i = 0; i < _models.size(); ++i)
+    {
+        models.push_back(std::move(_models[i]));
+    }
+}
+
+void BVH::generate()
+{
+    std::vector<PNode> pendingNodes;
+    while (!models.empty())
+    {
+        pendingNodes.push_back(std::make_unique<Node>(std::move(models.back())));
+        models.pop_back();
+    }
+    while (pendingNodes.size() > 1)
+    {
+        int lhs = pendingNodes.size();
+        int rhs = pendingNodes.size();
+        float minSurface = std::numeric_limits<float>::max();
+        for (int i = 0; i < pendingNodes.size(); ++i)
+        {
+            for (int j = 0; j < pendingNodes.size(); ++j)
+            {
+                if (i == j)
+                    continue;
+                AABB combined = AABB::combine(pendingNodes[i]->aabb, pendingNodes[j]->aabb);
+                float surface = combined.surfaceArea();
+                if (minSurface > surface)
+                {
+                    lhs = i;
+                    rhs = j;
+                    minSurface = surface;
+                }
+            }
+        }
+        PNode newNode = std::make_unique<Node>(AABB::combine(pendingNodes[lhs]->aabb, pendingNodes[rhs]->aabb));
+        newNode->left = std::move(pendingNodes[lhs]);
+        newNode->right = std::move(pendingNodes[rhs]);
+        pendingNodes.erase(pendingNodes.begin() + lhs);
+        pendingNodes.erase(pendingNodes.begin() + rhs);
+        pendingNodes.push_back(std::move(newNode));
+    }
+    hierarchy = std::move(pendingNodes[0]);
+}

src/scene/BVH.h

@@ -1,15 +1,26 @@
 #pragma once
-#include <glm/glm.hpp>
+#include "AABB.h"
+#include "util/Model.h"
 #include <vector>
 
-struct AABB {
-	glm::vec3 min;
-	glm::vec3 max;
-};
-
 class BVH
 {
-public:
+  public:
-private:
+    void addModel(PModel model);
-	std::vector<AABB> boundingBoxes;
+    void addModels(std::vector<PModel> models);
+    void generate();
+
+  private:
+    DECLARE_REF(Node)
+    struct Node
+    {
+        PNode left;
+        PNode right;
+        AABB aabb;
+        PModel model;
+        Node(AABB aabb) : aabb(aabb) {}
+        Node(PModel model) : aabb(model->boundingBox), model(std::move(model)) {}
+    };
+    PNode hierarchy;
+    std::vector<PModel> models;
 };

src/scene/CMakeLists.txt

@@ -1,4 +1,7 @@
 target_sources(RayTracer
 	PRIVATE
+		AABB.h
+		BVH.h
+		BVH.cpp
 		Scene.h
 		Scene.cpp)

src/util/CMakeLists.txt

@@ -4,4 +4,5 @@ target_sources(RayTracer
 		Model.cpp
 		ModelLoader.h
 		ModelLoader.cpp
+		Ray.h
 )

src/util/Model.h

@@ -1,11 +1,12 @@
 #pragma once
 #include "Minimal.h"
+#include "scene/AABB.h"
 #include <vector>
-#include <glm/glm.hpp>
 
 class Model
 {
 public:
+    AABB boundingBox;
 	std::vector<glm::vec3> positions;
 	std::vector<uint32_t> indices;
 };

src/util/ModelLoader.cpp

@@ -8,22 +8,28 @@
 std::vector<PModel> ModelLoader::loadModel(std::string_view filename)
 {
     Assimp::Importer importer;
-    const aiScene* scene = importer.ReadFile(filename, 0);
+    const aiScene* scene = importer.ReadFile(std::string(filename), aiProcess_Triangulate);
+    std::vector<PModel> result;
     for (int m = 0; m < scene->mNumMeshes; ++m)
     {
-        PModel result = std::make_unique<Model>();
+        PModel model = std::make_unique<Model>();
         const aiMesh* mesh = scene->mMeshes[m];
+        AABB aabb;
         for (int v = 0; v < mesh->mNumVertices; ++v)
         {
             auto aiVert = mesh->mVertices[v];
-            result->positions.add(glm::vec3(aiVert.x, aiVert.y, aiVert.z));
+            model->positions.push_back(glm::vec3(aiVert.x, aiVert.y, aiVert.z));
+            aabb.adjust(model->positions.back());
         }
         for (int i = 0; i < mesh->mNumFaces; ++i)
         {
             auto face = mesh->mFaces[i];
-            result->indices.add(face.mIndices[0]);
+            model->indices.push_back(face.mIndices[0]);
-            result->indices.add(face.mIndices[1]);
+            model->indices.push_back(face.mIndices[1]);
-            result->indices.add(face.mIndices[2]);
+            model->indices.push_back(face.mIndices[2]);
         }
+        model->boundingBox = aabb;
+        result.push_back(std::move(model));
     }
+    return result;
 }

src/util/ModelLoader.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "Model.h"
+#include <string_view>
 
 class ModelLoader
 {