diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/basicShapes.h | 19 | ||||
| -rw-r--r-- | lib/geometricPlane.cpp | 20 | ||||
| -rw-r--r-- | lib/geometricPlane.h | 37 | ||||
| -rw-r--r-- | lib/maths.h | 20 | ||||
| -rw-r--r-- | lib/ray.cpp | 35 | ||||
| -rw-r--r-- | lib/ray.h | 78 |
6 files changed, 135 insertions, 74 deletions
diff --git a/lib/basicShapes.h b/lib/basicShapes.h new file mode 100644 index 0000000..183863e --- /dev/null +++ b/lib/basicShapes.h @@ -0,0 +1,19 @@ +#pragma once +#include <array> +#include <glm/vec3.hpp> + +template<typename T, glm::qualifier Q = glm::defaultp> +constexpr std::array<glm::vec<3, T, Q>, 8> +cuboidCorners(T lx, T ux, T ly, T uy, T lz, T uz) +{ + return {{ + {lx, uy, lz}, // LFB + {ux, uy, lz}, // RFB + {lx, uy, uz}, // LFT + {ux, uy, uz}, // RFT + {lx, ly, lz}, // LBB + {ux, ly, lz}, // RBB + {lx, ly, uz}, // LBT + {ux, ly, uz}, // RBT + }}; +} diff --git a/lib/geometricPlane.cpp b/lib/geometricPlane.cpp index 567f98a..7aadf6a 100644 --- a/lib/geometricPlane.cpp +++ b/lib/geometricPlane.cpp @@ -1,14 +1,4 @@ #include "geometricPlane.h" -#include "ray.h" -#include <glm/geometric.hpp> -#include <glm/gtx/intersect.hpp> - -GeometricPlane::PlaneRelation -GeometricPlane::getRelation(Position3D p) const -{ - const auto d = glm::dot(normal, p - origin); - return d < 0.F ? PlaneRelation::Below : d > 0.F ? PlaneRelation::Above : PlaneRelation::On; -} bool GeometricPlane::isIntersect(PlaneRelation a, PlaneRelation b) @@ -16,13 +6,3 @@ GeometricPlane::isIntersect(PlaneRelation a, PlaneRelation b) return ((a == PlaneRelation::Above && b == PlaneRelation::Below) || (a == PlaneRelation::Below && b == PlaneRelation::Above)); } - -std::optional<GeometricPlane::DistAndPosition> -GeometricPlane::getRayIntersectPosition(const Ray & ray) const -{ - float dist {}; - if (!glm::intersectRayPlane(ray.start, ray.direction, origin, normal, dist)) { - return {}; - } - return DistAndPosition {dist, ray.start + (ray.direction * dist)}; -} diff --git a/lib/geometricPlane.h b/lib/geometricPlane.h index c74beff..3f95d3c 100644 --- a/lib/geometricPlane.h +++ b/lib/geometricPlane.h @@ -1,24 +1,43 @@ #pragma once #include "config/types.h" +#include "ray.h" +#include <glm/geometric.hpp> +#include <glm/gtx/intersect.hpp> #include <glm/vec3.hpp> #include <optional> -class Ray; - class GeometricPlane { public: + enum class PlaneRelation { Above, Below, On }; + + static bool isIntersect(PlaneRelation a, PlaneRelation b); +}; + +template<typename PositionType> class GeometricPlaneT : public GeometricPlane { +public: struct DistAndPosition { - float dist; - Position3D position; + PositionType::value_type dist; + PositionType position; }; - enum class PlaneRelation { Above, Below, On }; - Position3D origin; + PositionType origin; Normal3D normal; - [[nodiscard]] PlaneRelation getRelation(Position3D point) const; - [[nodiscard]] std::optional<DistAndPosition> getRayIntersectPosition(const Ray &) const; + [[nodiscard]] inline PlaneRelation + getRelation(PositionType point) const + { + const auto d = glm::dot(normal, point - origin); + return d < 0.F ? PlaneRelation::Below : d > 0.F ? PlaneRelation::Above : PlaneRelation::On; + } - static bool isIntersect(PlaneRelation a, PlaneRelation b); + [[nodiscard]] inline std::optional<DistAndPosition> + getRayIntersectPosition(const Ray<PositionType> & ray) const + { + float dist {}; + if (!glm::intersectRayPlane(ray.start, ray.direction, origin, normal, dist)) { + return {}; + } + return DistAndPosition {dist, ray.start + (ray.direction * dist)}; + } }; diff --git a/lib/maths.h b/lib/maths.h index c1bf61a..b5af9ca 100644 --- a/lib/maths.h +++ b/lib/maths.h @@ -68,9 +68,9 @@ sq(T v) return v * v; } -template<std::integral T, glm::qualifier Q> -inline constexpr glm::vec<3, T, Q> -crossInt(const glm::vec<3, T, Q> a, const glm::vec<3, T, Q> b) +template<glm::qualifier Q> +inline constexpr glm::vec<3, int64_t, Q> +crossProduct(const glm::vec<3, int64_t, Q> a, const glm::vec<3, int64_t, Q> b) { return { (a.y * b.z) - (a.z * b.y), @@ -79,6 +79,20 @@ crossInt(const glm::vec<3, T, Q> a, const glm::vec<3, T, Q> b) }; } +template<std::integral T, glm::qualifier Q> +inline constexpr glm::vec<3, T, Q> +crossProduct(const glm::vec<3, T, Q> a, const glm::vec<3, T, Q> b) +{ + return crossProduct<int64_t, Q>(a, b); +} + +template<std::floating_point T, glm::qualifier Q> +inline constexpr glm::vec<3, T, Q> +crossProduct(const glm::vec<3, T, Q> a, const glm::vec<3, T, Q> b) +{ + return glm::cross(a, b); +} + template<typename R = float, typename Ta, typename Tb> inline constexpr auto ratio(Ta a, Tb b) diff --git a/lib/ray.cpp b/lib/ray.cpp deleted file mode 100644 index 9fb3648..0000000 --- a/lib/ray.cpp +++ /dev/null @@ -1,35 +0,0 @@ -#include "ray.h" -#include <algorithm> - -Ray -Ray::fromPoints(Position3D start, Position3D p) -{ - return {start, glm::normalize(p - start)}; -} - -float -Ray::distanceToLine(const Position3D & p1, const Position3D & e1) const -{ - // https://en.wikipedia.org/wiki/Skew_lines - const auto diff = p1 - e1; - const auto d1 = glm::normalize(diff); - const auto &p2 = start, &d2 = direction; - const auto n = glm::cross(d1, d2); - const auto n2 = glm::cross(d2, n); - const auto c1 = p1 + (glm::dot((p2 - p1), n2) / glm::dot(d1, n2)) * d1; - const auto difflength = glm::length(diff); - if (glm::length(c1 - p1) > difflength || glm::length(c1 - e1) > difflength) { - return std::numeric_limits<float>::infinity(); - } - return glm::abs(glm::dot(n, p1 - p2)); -} - -bool -Ray::passesCloseToEdges(const std::span<const Position3D> positions, float distance) const -{ - return std::adjacent_find(positions.begin(), positions.end(), - [this, distance](const Position3D & a, const Position3D & b) { - return distanceToLine(a, b) <= distance; - }) - != positions.end(); -} @@ -1,20 +1,84 @@ #pragma once #include "config/types.h" +#include "maths.h" + +#include <algorithm> #include <glm/glm.hpp> +#include <glm/gtx/intersect.hpp> #include <span> -class Ray { +template<typename PositionType> class Ray { public: #ifndef __cpp_aggregate_paren_init - Ray(Position3D start, Direction3D direction) : start {start}, direction {direction} { } + Ray(PositionType start, Direction3D direction) : start {start}, direction {direction} { } #endif - static Ray fromPoints(Position3D, Position3D); - - Position3D start; + PositionType start; Direction3D direction; - [[nodiscard]] float distanceToLine(const Position3D & a, const Position3D & b) const; - [[nodiscard]] bool passesCloseToEdges(const std::span<const Position3D> positions, float distance) const; + [[nodiscard]] PositionType::value_type + distanceToLine(const PositionType & p1, const PositionType & e1) const + { + // https://en.wikipedia.org/wiki/Skew_lines + const RelativePosition3D diff = p1 - e1; + const auto d1 = glm::normalize(diff); + const auto n = crossProduct(d1, direction); + const auto n2 = crossProduct(direction, n); + const auto c1 = p1 + PositionType((glm::dot(RelativePosition3D(start - p1), n2) / glm::dot(d1, n2)) * d1); + const auto difflength = glm::length(diff); + if (glm::length(RelativePosition3D(c1 - p1)) > difflength + || glm::length(RelativePosition3D(c1 - e1)) > difflength) { + return std::numeric_limits<typename PositionType::value_type>::infinity(); + } + return static_cast<PositionType::value_type>(glm::abs(glm::dot(n, RelativePosition3D(p1 - start)))); + } + + [[nodiscard]] bool + passesCloseToEdges(const std::span<const PositionType> positions, const PositionType::value_type distance) const + { + return std::adjacent_find(positions.begin(), positions.end(), [this, distance](const auto & a, const auto & b) { + return distanceToLine(a, b) <= distance; + }) != positions.end(); + } + + bool + intersectTriangle(const PositionType t0, const PositionType t1, const PositionType t2, BaryPosition & bary, + RelativeDistance & distance) const + { + if constexpr (std::is_floating_point_v<typename PositionType::value_type>) { + return glm::intersectRayTriangle(start, direction, t0, t1, t2, bary, distance); + } + else { + const RelativePosition3D t0r = t0 - start, t1r = t1 - start, t2r = t2 - start; + return glm::intersectRayTriangle({}, direction, t0r, t1r, t2r, bary, distance); + } + } + + bool + intersectSphere(const PositionType centre, const PositionType::value_type size, PositionType & position, + Normal3D & normal) const + { + if constexpr (std::is_floating_point_v<typename PositionType::value_type>) { + return glm::intersectRaySphere(start, direction, centre, size, position, normal); + } + else { + const RelativePosition3D cr = centre - start; + RelativePosition3D positionF {}; + const auto r = glm::intersectRaySphere( + {}, direction, cr, static_cast<RelativeDistance>(size), positionF, normal); + position = GlobalPosition3D(positionF) + start; + return r; + } + } +}; + +class RayFactory { +public: + template<typename PositionType> + static Ray<PositionType> + fromPoints(PositionType start, PositionType p) + { + return {start, glm::normalize(p - start)}; + } }; |