summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/basicShapes.h19
-rw-r--r--lib/geometricPlane.cpp20
-rw-r--r--lib/geometricPlane.h37
-rw-r--r--lib/maths.h20
-rw-r--r--lib/ray.cpp35
-rw-r--r--lib/ray.h78
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();
-}
diff --git a/lib/ray.h b/lib/ray.h
index bc70c74..e1f43c3 100644
--- a/lib/ray.h
+++ b/lib/ray.h
@@ -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)};
+ }
};