reorganizing mesh data

src/scene/BVH.cpp

@@ -22,7 +22,23 @@ void BVH::generate()
   std::vector<PNode> pendingNodes;
   while (!models.empty())
   {
-    pendingNodes.push_back(std::make_unique<Node>(std::move(models.back())));
+    auto& model = models.back();
+    ModelReference ref = {
+        .positionOffset = (uint32_t)positionPool.size(),
+        .indicesOffset = (uint32_t)indicesPool.size(),
+        .numIndices = (uint32_t)model->indices.size(),
+    };
+    for (uint32_t i = 0; i < model->positions.size(); ++i)
+    {
+      positionPool.push_back(model->positions[i]);
+    }
+    for (uint32_t i = 0; i < model->indices.size(); ++i)
+    {
+      indicesPool.push_back(model->indices[i]);
+      edgesPool.push_back(model->edges[i]);
+      faceNormalsPool.push_back(model->faceNormals[i]);
+    }
+    pendingNodes.push_back(std::make_unique<Node>(model->boundingBox, ref));
     models.pop_back();
   }
   while (pendingNodes.size() > 1)
@@ -82,9 +98,9 @@ std::vector<IntersectionInfo> BVH::generateIntersections(const PNode& currentNod
   {
     return {};
   }
-  if (currentNode->model != nullptr)
+  if (currentNode->model.numIndices > 0)
   {
-    auto result = currentNode->model->intersect(ray);
+    auto result = intersectModel(currentNode->model, ray);
     if (result.has_value())
     {
       return {*result};
@@ -103,3 +119,51 @@ std::vector<IntersectionInfo> BVH::generateIntersections(const PNode& currentNod
   }
   return leftResults;
 }
+
+std::optional<IntersectionInfo> BVH::intersectModel(ModelReference reference, const Ray ray) const
+{
+  std::optional<IntersectionInfo> intersection = {};
+  float distance = 0;
+
+  for (size_t posIndex = 0, edgeIndex = 0, normalIndex = 0; posIndex < reference.numIndices; posIndex++, edgeIndex += 2, normalIndex++)
+  {
+    const auto p0 = positionPool[reference.positionOffset + indicesPool[reference.indicesOffset + posIndex].x];
+    const auto p1 = positionPool[reference.positionOffset + indicesPool[reference.indicesOffset + posIndex].y];
+    const auto p2 = positionPool[reference.positionOffset + indicesPool[reference.indicesOffset + posIndex].z];
+
+    const auto e0 = edgesPool[reference.indicesOffset + edgeIndex];
+    const auto e1 = edgesPool[reference.indicesOffset + edgeIndex + 1];
+
+    const auto n = faceNormalsPool[reference.indicesOffset + normalIndex];
+
+    const auto s = ray.origin - p0;
+    const auto s1 = glm::cross(ray.direction, e1);
+    const auto s2 = glm::cross(s, e0);
+
+    const float fraction = 1.0f / glm::dot(s1, e0);
+    const auto resultVector = glm::vec3(glm::dot(s2, e1), glm::dot(s1, s), glm::dot(s2, ray.direction)) * fraction;
+
+    const float b3 = 1.0f - resultVector.y - resultVector.z;
+
+    if (b3 < 0 || b3 > 1)
+      continue;
+    if (resultVector.y < 0 || resultVector.y > 1)
+      continue;
+    if (resultVector.z < 0 || resultVector.z > 1)
+      continue;
+
+    if (resultVector.x < 1e-6)
+      continue;
+
+    if (!intersection.has_value() || resultVector.x < distance)
+    {
+      intersection = IntersectionInfo{.position = ray.origin + ray.direction * resultVector.x,
+                                      .normal = n,
+                                      .albedo = glm::vec3(0.7f, 0.7f, 0.7f),
+                                      .emissive = glm::vec3(0.0f, 0.0f, 0.0f)};
+      distance = resultVector.x;
+    }
+  }
+
+  return intersection;
+}

src/scene/BVH.h

@@ -6,6 +6,13 @@
 #include <optional>
 #include <vector>
 
+struct ModelReference
+{
+  uint32_t positionOffset;
+  uint32_t indicesOffset;
+  uint32_t numIndices;
+};
+
 class BVH
 {
 public:
@@ -16,18 +23,24 @@ public:
   std::optional<IntersectionInfo> traceRay(Ray ray) const;
 
 private:
+  std::vector<glm::vec3> positionPool;
+  std::vector<glm::uvec3> indicesPool;
+  std::vector<glm::vec3> edgesPool;
+  std::vector<glm::vec3> faceNormalsPool;
+
   DECLARE_REF(Node)
   struct Node
   {
     PNode left;
     PNode right;
     AABB aabb;
-    PModel model;
+    ModelReference model;
     Node(AABB aabb) : aabb(aabb) {}
-    Node(PModel model) : aabb(model->boundingBox), model(std::move(model)) {}
+    Node(AABB aabb, ModelReference model) : aabb(aabb), model(model) {}
   };
   PNode hierarchy;
   std::vector<PModel> models;
 
   std::vector<IntersectionInfo> generateIntersections(const PNode& currentNode, Ray ray) const;
+  std::optional<IntersectionInfo> intersectModel(ModelReference reference, Ray ray) const;
 };

src/util/Model.cpp

@@ -9,64 +9,13 @@ void Model::transform(glm::mat4 matrix)
 
   boundingBox.transform(matrix);
 
-  for (int i = 0; i < indices.size(); i+=3)
+  for (int i = 0; i < indices.size(); i++)
   {
-    auto e0 = positions[indices[i + 1]] - positions[indices[i + 0]];
+    auto e0 = positions[indices[i].y] - positions[indices[i].x];
-    auto e1 = positions[indices[i + 2]] - positions[indices[i + 0]];
+    auto e1 = positions[indices[i].z] - positions[indices[i].x];
     edges.push_back(e0);
     edges.push_back(e1);
 
     faceNormals.push_back(glm::cross(e0, e1));
   }
 }
-
-std::optional<IntersectionInfo> Model::intersect(const Ray ray) const
-{
-  std::optional<IntersectionInfo> intersection = {};
-  float distance = 0;
-
-  for(size_t posIndex=0, edgeIndex=0, normalIndex=0;  posIndex <indices.size(); posIndex+=3, edgeIndex+=2, normalIndex++)
-  {
-    const auto p0 = positions[indices[posIndex]];
-    const auto p1 = positions[indices[posIndex+1]];
-    const auto p2 = positions[indices[posIndex+2]];
-
-    const auto e0 = edges[edgeIndex];
-    const auto e1 = edges[edgeIndex+1];
-
-    const auto n = faceNormals[normalIndex];
-
-    const auto s = ray.origin - p0;
-    const auto s1 = glm::cross(ray.direction, e1);
-    const auto s2 = glm::cross(s, e0);
-
-    const float fraction = 1.0f / glm::dot(s1, e0);
-    const auto resultVector = glm::vec3(glm::dot(s2, e1), glm::dot(s1, s), glm::dot(s2, ray.direction)) * fraction;
-
-    const float b3 = 1.0f - resultVector.y - resultVector.z;
-
-    if(b3 < 0 || b3 > 1)
-      continue;
-    if(resultVector.y < 0 || resultVector.y > 1)
-      continue;
-    if(resultVector.z < 0 || resultVector.z > 1)
-      continue;
-
-    if(resultVector.x < 1e-6)
-      continue;
-
-    if(!intersection.has_value() || resultVector.x < distance)
-    {
-      intersection = IntersectionInfo {
-        .position = ray.origin + ray.direction * resultVector.x,
-        .normal = n,
-        .albedo = glm::vec3(0.7f, 0.7f, 0.7f),
-        .emissive = glm::vec3(0.0f, 0.0f, 0.0f)
-      };
-      distance = resultVector.x;
-    }
-  }
-
-  return intersection;
-}
-

src/util/Model.h

@@ -21,10 +21,9 @@ class Model
 public:
   AABB boundingBox;
   std::vector<glm::vec3> positions;
-  std::vector<uint32_t> indices;
+  std::vector<glm::uvec3> indices;
   std::vector<glm::vec3> edges;
   std::vector<glm::vec3> faceNormals;
   void transform(glm::mat4 matrix);
-  std::optional<IntersectionInfo> intersect(Ray ray) const;
 };
 DECLARE_REF(Model)

src/util/ModelLoader.cpp

@@ -24,10 +24,7 @@ std::vector<PModel> ModelLoader::loadModel(std::string_view filename)
     for (int i = 0; i < mesh->mNumFaces; ++i)
     {
       auto face = mesh->mFaces[i];
-            model->indices.push_back(face.mIndices[0]);
+      model->indices.push_back(glm::uvec3(face.mIndices[0], face.mIndices[1], face.mIndices[2]));
-            model->indices.push_back(face.mIndices[1]);
-            model->indices.push_back(face.mIndices[2]);
-
     }
     model->boundingBox = aabb;
     result.push_back(std::move(model));