From 1e39b5d05dab0f7718509a4a6970519c2acbc037 Mon Sep 17 00:00:00 2001 From: A-lex-Ra Date: Sun, 10 Dec 2023 20:06:18 +0600 Subject: [PATCH] rays fixed --- .gitignore | 1 + src/maths/rays.cpp | 351 ++++++++++++++++++------------------------ src/maths/rays.h | 60 +++++--- src/voxels/Chunks.cpp | 5 +- 4 files changed, 187 insertions(+), 230 deletions(-) diff --git a/.gitignore b/.gitignore index 55057c5a2..cee55439b 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ Debug/voxel_engine /build /screenshots +/out /world /worlds/**/* diff --git a/src/maths/rays.cpp b/src/maths/rays.cpp index 450fdf753..3f9c5cc83 100644 --- a/src/maths/rays.cpp +++ b/src/maths/rays.cpp @@ -34,33 +34,28 @@ RayRelation Rays::rayIntersectAAFace( const rayvec3& rayDir, const rayvec3& faceMin, const rayvec2& faceOppositeCorner, //y and z global coords of opposite corner - rayvec3& intersectPoint_ret + glm::ivec3& normal_ret, + scalar_t& distance_ret //sinonym of rayCoef ){ if (fabs(glm::dot(rayDir, X_AXIS)) < 1.0E-8){ //precision return RayRelation::Parallel; } - glm::float64 rayCoef = (faceMin.x - rayOrigin.x) / (rayDir.x); - intersectPoint_ret = {faceMin.x, - rayCoef*rayDir.y + rayOrigin.y, + scalar_t rayCoef = (faceMin.x - rayOrigin.x) / (rayDir.x);// equivalent to distance if raydir normalized + if (rayCoef < 0) return RayRelation::None; + rayvec3 intersectPoint = {faceMin.x, + rayCoef*rayDir.y + rayOrigin.y, rayCoef*rayDir.z + rayOrigin.z}; - - if (rayDir.x > 0){ - if (intersectPoint_ret.y >= faceMin.y - && intersectPoint_ret.y <= faceOppositeCorner[0] - && intersectPoint_ret.z >= faceMin.z - && intersectPoint_ret.z <= faceOppositeCorner[1]){ - return RayRelation::Intersect; - } - } - else{ - if (intersectPoint_ret.y <= faceMin.y - && intersectPoint_ret.y >= faceOppositeCorner[0] - && intersectPoint_ret.z <= faceMin.z - && intersectPoint_ret.z >= faceOppositeCorner[1]){ - return RayRelation::Intersect; - } - } + + if (intersectPoint.y >= faceMin.y + && intersectPoint.y <= faceOppositeCorner[0] + && intersectPoint.z >= faceMin.z + && intersectPoint.z <= faceOppositeCorner[1]){ + distance_ret = rayCoef; // believe that raydir normalized + if (rayDir.x > 0) normal_ret = -X_AXIS; + else normal_ret = X_AXIS; + return RayRelation::Intersect; + } return RayRelation::None; } @@ -70,33 +65,28 @@ RayRelation Rays::rayIntersectAAFace( const rayvec3& rayDir, const rayvec3& faceMin, const rayvec2& faceOppositeCorner, //x and z global coords of opposite corner - rayvec3& intersectPoint_ret + glm::ivec3& normal_ret, + scalar_t& distance_ret ){ if (fabs(glm::dot(rayDir, Y_AXIS)) < 1.0E-8){ //precision return RayRelation::Parallel; } - glm::float64 rayCoef = (faceMin.y - rayOrigin.y) / (rayDir.y); - intersectPoint_ret = {rayCoef*rayDir.x + rayOrigin.x, + scalar_t rayCoef = (faceMin.y - rayOrigin.y) / (rayDir.y);// equivalent to distance if raydir normalized + if (rayCoef < 0) return RayRelation::None; + rayvec3 intersectPoint = { rayCoef *rayDir.x + rayOrigin.x, faceMin.y, rayCoef*rayDir.z + rayOrigin.z}; - - if (rayDir.y > 0){ - if (intersectPoint_ret.x >= faceMin.x //Face-hit check - && intersectPoint_ret.x <= faceOppositeCorner[0] - && intersectPoint_ret.z >= faceMin.z - && intersectPoint_ret.z <= faceOppositeCorner[1] ){ - return RayRelation::Intersect; - } - } - else{ - if (intersectPoint_ret.x <= faceMin.x //Face-hit check for negative dir. - && intersectPoint_ret.x >= faceOppositeCorner[0] - && intersectPoint_ret.z <= faceMin.z - && intersectPoint_ret.z >= faceOppositeCorner[1]){ - return RayRelation::Intersect; - } - } + + if (intersectPoint.x >= faceMin.x //Face-hit check + && intersectPoint.x <= faceOppositeCorner[0] + && intersectPoint.z >= faceMin.z + && intersectPoint.z <= faceOppositeCorner[1] ){ + distance_ret = rayCoef; // believe that raydir normalized + if (rayDir.y > 0) normal_ret = -Y_AXIS; + else normal_ret = Y_AXIS; + return RayRelation::Intersect; + } return RayRelation::None; } @@ -106,162 +96,105 @@ RayRelation Rays::rayIntersectAAFace( const rayvec3& rayDir, const rayvec3& faceMin, const rayvec2& faceOppositeCorner, //x and y global coords of opposite corner - rayvec3& intersectPoint_ret + glm::ivec3& normal_ret, + scalar_t& distance_ret ){ if (fabs(glm::dot(rayDir, Z_AXIS)) < 1.0E-8){ //precision return RayRelation::Parallel; } - glm::float64 rayCoef = (faceMin.z - rayOrigin.z) / (rayDir.z); - intersectPoint_ret = {rayCoef*rayDir.x + rayOrigin.x, + scalar_t rayCoef = (faceMin.z - rayOrigin.z) / (rayDir.z); // equivalent to distance if raydir normalized + if (rayCoef < 0) return RayRelation::None; + rayvec3 intersectPoint = { rayCoef *rayDir.x + rayOrigin.x, rayCoef*rayDir.y + rayOrigin.y, faceMin.z}; - - if (rayDir.z > 0){ - if (intersectPoint_ret.x >= faceMin.x //Face-hit check - && intersectPoint_ret.x <= faceOppositeCorner[0] - && intersectPoint_ret.y >= faceMin.y - && intersectPoint_ret.y <= faceOppositeCorner[1] ){ - return RayRelation::Intersect; - } - } - else{ - if (intersectPoint_ret.x <= faceMin.x //Face-hit check - && intersectPoint_ret.x >= faceOppositeCorner[0] - && intersectPoint_ret.y <= faceMin.y - && intersectPoint_ret.y >= faceOppositeCorner[1] ){ - return RayRelation::Intersect; - } + + if (intersectPoint.x >= faceMin.x //Face-hit check + && intersectPoint.x <= faceOppositeCorner[0] + && intersectPoint.y >= faceMin.y + && intersectPoint.y <= faceOppositeCorner[1] ){ + distance_ret = rayCoef; // believe that raydir normalized + if (rayDir.z > 0) normal_ret = -Z_AXIS; + else normal_ret = Z_AXIS; + return RayRelation::Intersect; } return RayRelation::None; } -double Rays::updateNormal( - double newDistApprox, - const glm::ivec3& newNormal, - double currentDistApprox, - glm::ivec3& normal_ret - ){ - if (newDistApprox < currentDistApprox){ - currentDistApprox = newDistApprox; - normal_ret = newNormal; - } - return currentDistApprox; - } - template <> RayRelation Rays::isRayIntersectsAAFace( - const rayvec3& rayOrigin, - const rayvec3& rayDir, - const rayvec3& faceMin, - const rayvec2& faceOppositeCorner, - glm::ivec3& normal_ret, - double& currentDistApprox + const rayvec3& rayOrigin, + const rayvec3& rayDir, + const rayvec3& faceMin, + const rayvec2& faceOppositeCorner ){ - if (fabs(glm::dot(rayDir, X_AXIS)) < 1.0E-8){ //precision of "parallelity" + if (fabs(glm::dot(rayDir, X_AXIS)) < 1.0E-8) { //precision of "parallelity" return RayRelation::Parallel; } - glm::float64 rayCoef = (faceMin.x - rayOrigin.x); - rayvec3 intersectPointMult = {faceMin.x * rayDir.x, - rayCoef*rayDir.y + rayOrigin.y * rayDir.x, - rayCoef*rayDir.z + rayOrigin.z * rayDir.x}; - - if (rayDir.x > 0){ - if (intersectPointMult.y >= faceMin.y * rayDir.x //Face-hit check - && intersectPointMult.y <= faceOppositeCorner[0] * rayDir.x - && intersectPointMult.z >= faceMin.z * rayDir.x - && intersectPointMult.z <= faceOppositeCorner[1] * rayDir.x){ - currentDistApprox = updateNormal(fabs(rayCoef * rayDir.y * rayDir.z), -X_AXIS, currentDistApprox, normal_ret); - return RayRelation::Intersect; - } - } - else{ - if (intersectPointMult.y <= faceMin.y * rayDir.x //Face-hit check for negative dir. - && intersectPointMult.y >= faceOppositeCorner[0] * rayDir.x - && intersectPointMult.z <= faceMin.z * rayDir.x - && intersectPointMult.z >= faceOppositeCorner[1] * rayDir.x){ - currentDistApprox = updateNormal(fabs(rayCoef * rayDir.y * rayDir.z), X_AXIS, currentDistApprox, normal_ret); - return RayRelation::Intersect; - } + scalar_t rayCoef = (faceMin.x - rayOrigin.x) / (rayDir.x); + if (rayCoef < 0) return RayRelation::None; + rayvec3 intersectPoint = { faceMin.x, + rayCoef * rayDir.y + rayOrigin.y, + rayCoef * rayDir.z + rayOrigin.z }; + + if (intersectPoint.y >= faceMin.y + && intersectPoint.y <= faceOppositeCorner[0] + && intersectPoint.z >= faceMin.z + && intersectPoint.z <= faceOppositeCorner[1]) { + return RayRelation::Intersect; } return RayRelation::None; } template <> RayRelation Rays::isRayIntersectsAAFace( - const rayvec3& rayOrigin, - const rayvec3& rayDir, - const rayvec3& faceMin, - const rayvec2& faceOppositeCorner, - glm::ivec3& normal_ret, - double& currentDistApprox - ){ - if (fabs(glm::dot(rayDir, Y_AXIS)) < 1.0E-8){ //precision of "parallelity" + const rayvec3& rayOrigin, + const rayvec3& rayDir, + const rayvec3& faceMin, + const rayvec2& faceOppositeCorner + ) { + if (fabs(glm::dot(rayDir, Y_AXIS)) < 1.0E-8) { //precision of "parallelity" return RayRelation::Parallel; } - glm::float64 rayCoef = (faceMin.y - rayOrigin.y); - rayvec3 intersectPointMult = {rayCoef*rayDir.x + rayOrigin.x * rayDir.y, - faceMin.y * rayDir.y, - rayCoef*rayDir.z + rayOrigin.z * rayDir.y}; - - if (rayDir.y > 0){ - if (intersectPointMult.x >= faceMin.x * rayDir.y //Face-hit check - && intersectPointMult.x <= faceOppositeCorner[0] * rayDir.y - && intersectPointMult.z >= faceMin.z * rayDir.y - && intersectPointMult.z <= faceOppositeCorner[1] * rayDir.y){ - currentDistApprox = updateNormal(fabs(rayCoef * rayDir.x * rayDir.z), -Y_AXIS, currentDistApprox, normal_ret); - return RayRelation::Intersect; - } - } - else{ - if (intersectPointMult.x <= faceMin.x * rayDir.y //Face-hit check for negative dir. - && intersectPointMult.x >= faceOppositeCorner[0] * rayDir.y - && intersectPointMult.z <= faceMin.z * rayDir.y - && intersectPointMult.z >= faceOppositeCorner[1] * rayDir.y){ - currentDistApprox = updateNormal(fabs(rayCoef * rayDir.x * rayDir.z), Y_AXIS, currentDistApprox, normal_ret); - return RayRelation::Intersect; - } + scalar_t rayCoef = (faceMin.y - rayOrigin.y) / (rayDir.y); + if (rayCoef < 0) return RayRelation::None; + rayvec3 intersectPoint = { rayCoef * rayDir.x + rayOrigin.x, + faceMin.y, + rayCoef * rayDir.z + rayOrigin.z }; + + if (intersectPoint.x >= faceMin.x //Face-hit check + && intersectPoint.x <= faceOppositeCorner[0] + && intersectPoint.z >= faceMin.z + && intersectPoint.z <= faceOppositeCorner[1]) { + return RayRelation::Intersect; } return RayRelation::None; } template <> RayRelation Rays::isRayIntersectsAAFace( - const rayvec3& rayOrigin, - const rayvec3& rayDir, - const rayvec3& faceMin, - const rayvec2& faceOppositeCorner, - glm::ivec3& normal_ret, - double& currentDistApprox - ){ - if (fabs(glm::dot(rayDir, Z_AXIS)) < 1.0E-8){ //precision of "parallelity" + const rayvec3& rayOrigin, + const rayvec3& rayDir, + const rayvec3& faceMin, + const rayvec2& faceOppositeCorner + ) { + if (fabs(glm::dot(rayDir, Z_AXIS)) < 1.0E-8) { //precision of "parallelity" return RayRelation::Parallel; } - glm::float64 rayCoef = (faceMin.z - rayOrigin.z); - rayvec3 intersectPointMult = {rayCoef*rayDir.x + rayOrigin.x * rayDir.z, - rayCoef*rayDir.y + rayOrigin.y * rayDir.z, - faceMin.z * rayDir.z}; - - if (rayDir.z > 0){ - if (intersectPointMult.x >= faceMin.x * rayDir.z //Face-hit check - && intersectPointMult.x <= faceOppositeCorner[0] * rayDir.z - && intersectPointMult.y >= faceMin.y * rayDir.z - && intersectPointMult.y <= faceOppositeCorner[1] * rayDir.z){ - currentDistApprox = updateNormal(fabs(rayCoef * rayDir.x * rayDir.y), -Z_AXIS, currentDistApprox, normal_ret); - return RayRelation::Intersect; - } - } - else{ - if (intersectPointMult.x <= faceMin.x * rayDir.z //Face-hit check - && intersectPointMult.x >= faceOppositeCorner[0] * rayDir.z - && intersectPointMult.y <= faceMin.y * rayDir.z - && intersectPointMult.y >= faceOppositeCorner[1] * rayDir.z){ - currentDistApprox = updateNormal(fabs(rayCoef * rayDir.x * rayDir.y), Z_AXIS, currentDistApprox, normal_ret); - return RayRelation::Intersect; - } + scalar_t rayCoef = (faceMin.z - rayOrigin.z) / (rayDir.z); + if (rayCoef < 0) return RayRelation::None; + rayvec3 intersectPoint = { rayCoef * rayDir.x + rayOrigin.x, + rayCoef * rayDir.y + rayOrigin.y, + faceMin.z }; + + if (intersectPoint.x >= faceMin.x //Face-hit check + && intersectPoint.x <= faceOppositeCorner[0] + && intersectPoint.y >= faceMin.y + && intersectPoint.y <= faceOppositeCorner[1]) { + return RayRelation::Intersect; } return RayRelation::None; } @@ -272,23 +205,22 @@ RayRelation Rays::rayIntersectAABB( const rayvec3& boxPos, const AABB& box, float maxDist, - rayvec3& pointIn_ret, - rayvec3& pointOut_ret, - glm::ivec3& normal_ret){ + glm::ivec3& normal_ret, + scalar_t& distance_ret){ if constexpr (IS_RAYS_BOX_CACHE_ON){ if (raysBoxCache_.find(boxPos) != raysBoxCache_.end()){ const AABBFaces& boxFaces = raysBoxCache_[boxPos]; - return rayIntersectAABBFaces(rayOrigin, rayDir, boxFaces, maxDist, pointIn_ret, pointOut_ret, normal_ret); + return rayIntersectAABBFaces(rayOrigin, rayDir, boxFaces, maxDist, normal_ret, distance_ret); } else { const AABBFaces& boxFaces = AABBFaces(boxPos, box); raysBoxCache_[boxPos] = boxFaces; - return rayIntersectAABBFaces(rayOrigin, rayDir, boxFaces, maxDist, pointIn_ret, pointOut_ret, normal_ret); + return rayIntersectAABBFaces(rayOrigin, rayDir, boxFaces, maxDist, normal_ret, distance_ret); } } else { const AABBFaces& boxFaces = AABBFaces(boxPos, box); - return rayIntersectAABBFaces(rayOrigin, rayDir, boxFaces, maxDist, pointIn_ret, pointOut_ret, normal_ret); + return rayIntersectAABBFaces(rayOrigin, rayDir, boxFaces, maxDist, normal_ret, distance_ret); } } @@ -298,54 +230,63 @@ RayRelation Rays::rayIntersectAABBFaces( const rayvec3& rayDir, const AABBFaces& boxFaces, float maxDist, - rayvec3& pointIn_ret, - rayvec3& pointOut_ret, - glm::ivec3& normal_ret){//TODO: points returning - RayRelation rel; - double faceDistApprox = maxDist; - unsigned char intersectedCount = 0; //this code is very uncomfortable, DONT LEARN IT! - rel = isRayIntersectsAAFace( - rayOrigin, rayDir, boxFaces.faces[0].first, boxFaces.faces[0].second, normal_ret, faceDistApprox - ); - if (rel > RayRelation::None){ - ++intersectedCount; + glm::ivec3& normal_ret, + scalar_t& distance_ret){//TODO: points returning + + scalar_t faceDist; + distance_ret = maxDist; + glm::ivec3 bufNormal; + //unsigned char intersectedCount = 0; //this code is very uncomfortable, DONT LEARN IT! + bool isIntersect = false; + + if (rayIntersectAAFace( + rayOrigin, rayDir, boxFaces.faces[0].first, boxFaces.faces[0].second, bufNormal, faceDist + ) > RayRelation::None && faceDist < distance_ret){ + isIntersect = true; + normal_ret = bufNormal; + distance_ret = faceDist; } - rel = isRayIntersectsAAFace( - rayOrigin, rayDir, boxFaces.faces[1].first, boxFaces.faces[1].second, normal_ret, faceDistApprox - ); - if (rel > RayRelation::None){ - ++intersectedCount; + if (rayIntersectAAFace( + rayOrigin, rayDir, boxFaces.faces[1].first, boxFaces.faces[1].second, bufNormal, faceDist + ) > RayRelation::None && faceDist < distance_ret) { + isIntersect = true; + normal_ret = bufNormal; + distance_ret = faceDist; } - rel = isRayIntersectsAAFace( - rayOrigin, rayDir, boxFaces.faces[2].first, boxFaces.faces[2].second, normal_ret, faceDistApprox - ); - if (rel > RayRelation::None){ - ++intersectedCount; + if (rayIntersectAAFace( + rayOrigin, rayDir, boxFaces.faces[2].first, boxFaces.faces[2].second, bufNormal, faceDist + ) > RayRelation::None && faceDist < distance_ret) { + isIntersect = true; + normal_ret = bufNormal; + distance_ret = faceDist; } - rel = isRayIntersectsAAFace( - rayOrigin, rayDir, boxFaces.faces[3].first, boxFaces.faces[3].second, normal_ret, faceDistApprox - ); - if (rel > RayRelation::None){ - ++intersectedCount; + if (rayIntersectAAFace( + rayOrigin, rayDir, boxFaces.faces[3].first, boxFaces.faces[3].second, bufNormal, faceDist + ) > RayRelation::None && faceDist < distance_ret) { + isIntersect = true; + normal_ret = bufNormal; + distance_ret = faceDist; } - rel = isRayIntersectsAAFace( - rayOrigin, rayDir, boxFaces.faces[4].first, boxFaces.faces[4].second, normal_ret, faceDistApprox - ); - if (rel > RayRelation::None){ - ++intersectedCount; + if (rayIntersectAAFace( + rayOrigin, rayDir, boxFaces.faces[4].first, boxFaces.faces[4].second, bufNormal, faceDist + ) > RayRelation::None && faceDist < distance_ret) { + isIntersect = true; + normal_ret = bufNormal; + distance_ret = faceDist; } - rel = isRayIntersectsAAFace( - rayOrigin, rayDir, boxFaces.faces[5].first, boxFaces.faces[5].second, normal_ret, faceDistApprox - ); - if (rel > RayRelation::None){ - ++intersectedCount; + if (rayIntersectAAFace( + rayOrigin, rayDir, boxFaces.faces[5].first, boxFaces.faces[5].second, bufNormal, faceDist + ) > RayRelation::None && faceDist < distance_ret) { + isIntersect = true; + normal_ret = bufNormal; + distance_ret = faceDist; } - if (intersectedCount > 0) return RayRelation::Intersect; + if (isIntersect) return RayRelation::Intersect; return RayRelation::None; } \ No newline at end of file diff --git a/src/maths/rays.h b/src/maths/rays.h index 769259f20..7956dec89 100644 --- a/src/maths/rays.h +++ b/src/maths/rays.h @@ -10,6 +10,7 @@ typedef glm::highp_dvec3 rayvec3; typedef glm::highp_dvec2 rayvec2; +typedef double scalar_t; enum class RayRelation{ Embed=2, Intersect=1, Parallel=0, None=0 @@ -37,43 +38,58 @@ class AABBFaces{ template<> struct std::hash{ std::size_t operator()(const rayvec3& r) const noexcept{ - return std::hash{}(r.x) ^ (std::hash{}(r.y) << 1) ^ (std::hash{}(r.z) << 2); + return std::hash{}(r.x) ^ (std::hash{}(r.y) << 1) ^ (std::hash{}(r.z) << 2); } }; class Rays{ protected: - static const bool IS_RAYS_BOX_CACHE_ON = false; + static const bool IS_RAYS_BOX_CACHE_ON = true; static std::unordered_map raysBoxCache_; //[boxPos]: faces array public: +//optimized, NOT returns intersectPoint coordinates and normal vector template -static RayRelation rayIntersectAAFace( +static RayRelation isRayIntersectsAAFace( + const rayvec3& rayOrigin, + const rayvec3& rayDir, + const rayvec3& faceMin, + const rayvec2& faceOppositeCorner + ); + +//returns only normal +template +static RayRelation rayIntersectAAFace( const rayvec3& rayOrigin, const rayvec3& rayDir, const rayvec3& faceMin, const rayvec2& faceOppositeCorner, - rayvec3& intersectPoint_ret - ); - -static double updateNormal( - double newDistApprox, - const glm::ivec3& newNormal, - double currentDistApprox, glm::ivec3& normal_ret - ); +); -//optimized, not returns intersectPoint coordinates +//returns normal and distance template -static RayRelation isRayIntersectsAAFace( - const rayvec3& rayOrigin, +static RayRelation rayIntersectAAFace( + const rayvec3& rayOrigin, const rayvec3& rayDir, const rayvec3& faceMin, const rayvec2& faceOppositeCorner, glm::ivec3& normal_ret, - double& currentDistApprox - ); + scalar_t& distance_ret + ); + +// returns normal, distance and intersection point +template +static RayRelation rayIntersectAAFace( + const rayvec3& rayOrigin, + const rayvec3& rayDir, + const rayvec3& faceMin, + const rayvec2& faceOppositeCorner, + glm::ivec3& normal_ret, + scalar_t& distance_ret, + rayvec3& intersectPoint_ret +); static RayRelation rayIntersectAABB( const rayvec3& rayOrigin, @@ -81,18 +97,16 @@ static RayRelation rayIntersectAABB( const rayvec3& boxPos, const AABB& box, float maxDist, - rayvec3& pointIn_ret, - rayvec3& pointOut_ret, - glm::ivec3& normal_ret); + glm::ivec3& normal_ret, + scalar_t& distance_ret); -static RayRelation rayIntersectAABBFaces( +static RayRelation rayIntersectAABBFaces( // calculates only normal and distance const rayvec3& rayOrigin, const rayvec3& rayDir, const AABBFaces& boxFaces, float maxDist, - rayvec3& pointIn_ret, - rayvec3& pointOut_ret, - glm::ivec3& normal_ret); + glm::ivec3& normal_ret, + scalar_t& distance_ret); }; #endif // SRC_VOXNATHS_H_ diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp index ad4a6f09f..13b4631fb 100644 --- a/src/voxels/Chunks.cpp +++ b/src/voxels/Chunks.cpp @@ -234,8 +234,9 @@ voxel* Chunks::rayCast(vec3 start, const AABB& box = def->rotatable ? def->rt.hitboxes[voxel->rotation()] : def->hitbox; - rayvec3 in, out; // <- now not used, but for future... - if (Rays::rayIntersectAABB(start, dir, iend, box, maxDist, in, out, norm) > RayRelation::None){ + scalar_t distance; + if (Rays::rayIntersectAABB(start, dir, iend, box, maxDist, norm, distance) > RayRelation::None){ + end = start + (dir * vec3(distance)); return voxel; }