|
|
- /*
- * Copyright (C) 2020 Christopher J. Howard
- *
- * This file is part of Antkeeper source code.
- *
- * Antkeeper source code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Antkeeper source code is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Antkeeper source code. If not, see <http://www.gnu.org/licenses/>.
- */
-
- #include "geometry/mesh-accelerator.hpp"
- #include "geometry/mesh-functions.hpp"
- #include "geometry/morton.hpp"
- #include <bitset>
-
- mesh_accelerator::mesh_accelerator()
- {}
-
- void mesh_accelerator::build(const mesh& mesh)
- {
- // Clear octree and face map
- octree.clear();
- face_map.clear();
-
- // Calculate mesh dimensions
- aabb<float> bounds = calculate_bounds(mesh);
- float3 mesh_dimensions = bounds.max_point - bounds.min_point;
- center_offset = mesh_dimensions * 0.5f - (bounds.min_point + bounds.max_point) * 0.5f;
-
- // Calculate node dimensions at each octree depth
- for (auto i = 0; i <= octree32::max_depth; ++i)
- {
- node_dimensions[i] = mesh_dimensions * static_cast<float>((1.0f / std::pow(2, i)));
- }
-
- // Add faces to octree
- for (mesh::face* face: mesh.get_faces())
- {
- // Calculate face bounds
- float3 min_point = reinterpret_cast<const float3&>(face->edge->vertex->position);
- float3 max_point = min_point;
- mesh::edge* edge = face->edge;
- do
- {
- const auto& position = edge->vertex->position;
- for (int i = 0; i < 3; ++i)
- {
- min_point[i] = std::min<float>(min_point[i], position[i]);
- max_point[i] = std::max<float>(max_point[i], position[i]);
- }
-
- edge = edge->next;
- }
- while (edge != face->edge);
-
- // 1. Find max depth node of aabb min
- // 2. Find max depth node of aabb max
- // 3. Find common ancestor of the two nodes--that's the containing node.
- octree32::node_type min_node = find_node(min_point);
- octree32::node_type max_node = find_node(max_point);
- octree32::node_type containing_node = octree32::common_ancestor(min_node, max_node);
-
- // Insert containing node into octree
- octree.insert(containing_node);
-
- // Add face to face map
- face_map[containing_node].push_back(face);
- }
- }
-
- std::optional<mesh_accelerator::ray_query_result> mesh_accelerator::query_nearest(const ray<float>& ray) const
- {
- ray_query_result result;
- result.t = std::numeric_limits<float>::infinity();
- result.face = nullptr;
-
- query_nearest_recursive(result.t, result.face, octree.root, ray);
-
- if (result.face)
- return std::optional{result};
- return std::nullopt;
- }
-
- void mesh_accelerator::query_nearest_recursive(float& nearest_t, ::mesh::face*& nearest_face, octree32::node_type node, const ray<float>& ray) const
- {
- // Get node bounds
- const aabb<float> node_bounds = get_node_bounds(node);
-
- // Test for intersection with node bounds
- auto aabb_intersection = ray_aabb_intersection(ray, node_bounds);
-
- // If ray passed through this node
- if (std::get<0>(aabb_intersection))
- {
- // Test all triangles in the node
- if (auto it = face_map.find(node); it != face_map.end())
- {
- const std::list<mesh::face*>& faces = it->second;
-
- for (mesh::face* face: faces)
- {
- // Get triangle coordinates
- const float3& a = reinterpret_cast<const float3&>(face->edge->vertex->position);
- const float3& b = reinterpret_cast<const float3&>(face->edge->next->vertex->position);
- const float3& c = reinterpret_cast<const float3&>(face->edge->previous->vertex->position);
-
- // Test for intersection with triangle
- auto triangle_intersection = ray_triangle_intersection(ray, a, b, c);
- if (std::get<0>(triangle_intersection))
- {
- float t = std::get<1>(triangle_intersection);
- if (t < nearest_t)
- {
- nearest_t = t;
- nearest_face = face;
- }
- }
- }
- }
-
- // Test all child nodes
- if (!octree.is_leaf(node))
- {
- for (int i = 0; i < 8; ++i)
- query_nearest_recursive(nearest_t, nearest_face, octree.child(node, i), ray);
- }
- }
- }
-
- aabb<float> mesh_accelerator::get_node_bounds(octree32::node_type node) const
- {
- // Decode Morton location of node
- auto [x, y, z] = morton::decode_3d(octree32::location(node));
- float3 node_location = float3{static_cast<float>(x), static_cast<float>(y), static_cast<float>(z)};
-
- // Get node dimensions at node depth
- const float3& dimensions = node_dimensions[octree32::depth(node)];
-
- // Calculate AABB
- float3 min_point = (node_location * dimensions) - center_offset;
- return aabb<float>{min_point, min_point + dimensions};
- }
-
- octree32::node_type mesh_accelerator::find_node(const float3& point) const
- {
- // Transform point to octree space
- float3 transformed_point = (point + center_offset);
-
- // Account for floating-point tolerance
- const float epsilon = 0.00001f;
- transformed_point.x = std::max<float>(0.0f, std::min<float>(node_dimensions[0].x - epsilon, transformed_point.x));
- transformed_point.y = std::max<float>(0.0f, std::min<float>(node_dimensions[0].y - epsilon, transformed_point.y));
- transformed_point.z = std::max<float>(0.0f, std::min<float>(node_dimensions[0].z - epsilon, transformed_point.z));
-
- // Transform point to max-depth node space
- transformed_point = transformed_point / node_dimensions[octree32::max_depth];
-
- // Encode transformed point as a Morton location code
- std::uint32_t location = morton::encode_3d(
- static_cast<std::uint32_t>(transformed_point.x),
- static_cast<std::uint32_t>(transformed_point.y),
- static_cast<std::uint32_t>(transformed_point.z));
-
- /// Return max depth node at the determined location
- return octree32::node(octree32::max_depth, location);
- }
-
|