Restructure intersect_ray_recurse

The implementation should be finished aside from the actual ray-triangle-intersection.

kdtree.h

@@ -1,5 +1,6 @@
 #include <algorithm>
 #include <glm/glm.hpp>
+#include <iostream>
 #include <string>
 #include <vector>
 
@@ -32,6 +33,19 @@ struct Point {
     Point(float coordinates[3], Triangle *triangle)
         : coordinates(coordinates), triangle(triangle) {}
 
+    Point operator+(const Point &other) const {
+        return Point(new float[3]{coordinates[0] + other.coordinates[0],
+                                  coordinates[1] + other.coordinates[1],
+                                  coordinates[2] + other.coordinates[2]},
+                     nullptr);
+    }
+
+    Point operator*(float scalar) const {
+        return Point(
+            new float[3]{coordinates[0] * scalar, coordinates[1] * scalar, coordinates[2] * scalar},
+            nullptr);
+    }
+
     float *coordinates;
 
     Triangle *triangle;
@@ -51,7 +65,7 @@ class KDTree {
 
     ~KDTree() = default; // TODO: Delete all allocated Nodes
 
-    Point *intersect_ray(Ray ray) { return intersect_ray_recurse(ray, root); }
+    Point *intersect_ray(Ray ray) { return intersect_ray_recurse(ray, root, 1000.0); }
 
     std::string to_string() {
         std::string str = "";
@@ -115,12 +129,56 @@ class KDTree {
                         build(right_of_median, depth + 1));
     }
 
-    Point *intersect_ray_recurse(Ray ray, Node *node) {
-        // Intersect ray with the point's splitting plane
-        // If there is an intersection: Recurse to both children (but the nearer one first)
-        // Otherwise: Recurse only to the nearer one
+    Point *intersect_ray_recurse(Ray ray, Node *node, float max_distance) {
+        // Exit condition: There was no collision
+        if (node == nullptr) { return nullptr; }
 
-        return node->point; // TODO
+        // Is the left or right child node closer to this point?
+        Node *near = ray.origin[node->axis] > node->point->coordinates[node->axis] ? node->right
+                                                                                   : node->left;
+        Node *far = near == node->right ? node->left : node->right;
+
+        std::cout << "Checking " << node->point->coordinates[0] << ", "
+                  << node->point->coordinates[1] << ", " << node->point->coordinates[2] << ", "
+                  << std::endl;
+
+        // Check for collisions in this order (stopping if an intersection is found):
+        // 1. In the nearer section
+        // 2. With the point in this current node
+        // 3. In the further section
+
+        // If the axes are not parallel, our max_distance decreases, since we've already covered
+        // some area. `t` represents the distance from this node to the splitting plane.
+        float t = ray.direction[node->axis] != 0.0
+                      ? (node->point->coordinates[node->axis] - ray.origin[node->axis]) /
+                            ray.direction[node->axis]
+                      : max_distance;
+        Point *near_result = intersect_ray_recurse(ray, near, t);
+
+        // If the nearer segment had a collision, we're done! We're only interested in the closest
+        // collision.
+        if (near_result != nullptr) { return near_result; }
+
+        // No collision in the nearer side, so check for a collision directly here
+        Point *collision_here = nullptr;
+        // TODO: Ray-triangle-intersection here
+
+        // No collision here either. Does it make sense to also check the far node?
+        // Only if the axes are not parallel and if that area is not behind us
+        if (ray.direction[node->axis] != 0.0 && t >= 0.0) {
+            // It does make sense to check the far node.
+            // For this, calculate a new ray origin ...
+            float new_origin[3]{ray.origin[0] + t * ray.direction[0],
+                                ray.origin[1] + t * ray.direction[1],
+                                ray.origin[2] + t * ray.direction[2]};
+
+            // ... and continue towards that direction, but with the new origin (we can
+            // leave behind what we already checked)
+            return intersect_ray_recurse(Ray(new_origin, ray.direction), far, max_distance - t);
+        }
+
+        // If nothing worked, return a nullptr
+        return nullptr;
     }
 
     void to_string_recurse(std::string &str, Node *node, int depth) {

main.cpp

@@ -8,11 +8,14 @@ int main() {
     std::vector<Point *> points{new Point(new float[3]{0.0, 0.0, 0.0}, nullptr),
                                 new Point(new float[3]{0.0, 1.0, 0.0}, nullptr),
                                 new Point(new float[3]{0.0, 2.0, 3.0}, nullptr),
-                                new Point(new float[3]{1.0, 0.0, 4.0}, nullptr)};
+                                new Point(new float[3]{1.0, 0.0, 4.0}, nullptr),
+                                new Point(new float[3]{1.0, -1.0, 8.0}, nullptr)};
 
     KDTree tree = KDTree(points);
 
     std::cout << tree.to_string();
 
+    tree.intersect_ray(Ray(new float[3]{0.0, 0.0, 5.0}, new float[3]{0.0, 0.0, -1.0}));
+
     return 0;
 }