mgs/kdtree
2
0
Fork 0
generated from karl/cpp-template
Code Issues Pull Requests Projects Releases Wiki Activity

Restructure intersect_ray_recurse

Browse Source 
The implementation should be finished aside from the actual ray-triangle-intersection.
This commit is contained in:
karl 2020-12-28 16:28:19 +01:00
parent 71841766f1
commit 44f0699ab6
1 changed files with 34 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
kdtree.h
View File

@ -65,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 = "";
@ -129,7 +129,7 @@ class KDTree {
build(right_of_median, depth + 1));
}
Point *intersect_ray_recurse(Ray ray, Node *node) {
Point *intersect_ray_recurse(Ray ray, Node *node, float max_distance) {
// Exit condition: There was no collision
if (node == nullptr) { return nullptr; }
@ -142,25 +142,31 @@ class KDTree {
<< node->point->coordinates[1] << ", " << node->point->coordinates[2] << ", "
<< std::endl;
// Intersect ray with the point's splitting plane
// 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
// Are they parallel? If so, recurse only to the nearer side
if (ray.direction[node->axis] == 0.0) {
return intersect_ray_recurse(ray, near);
} else {
// They are not parallel, so check where the intersection occurs
float t = (node->point->coordinates[node->axis] - ray.origin[node->axis]) /
ray.direction[node->axis];
// 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 (t >= 0.0) {
// t is positive, so we need to recurse to both children if the nearer one does not
// result in a collision
Point *first_attempt = intersect_ray_recurse(ray, near);
// 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; }
if (first_attempt != nullptr) {
return first_attempt;
} else {
// The first attempt did not work, so recurse to the other side too.
// 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],
@ -168,14 +174,11 @@ class KDTree {
// ... 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);
}
} else {
// We only have to check the nearer one, as the other side can't be reached by the
// ray
return intersect_ray_recurse(ray, near);
}
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) {