Add triangle/ray and gltf/ray intersect function with tests

CHANGES.md

@@ -4,10 +4,13 @@
 
 ##### Breaking Changes :mega:
 
+- `ForEachPrimitiveInSceneCallback` now passes `meshId` and `primitiveId` to the caller. Existing callbacks will need to add these new parameters
 - `AccessorWriter` constructor now takes `std::byte*` instead of `uint8_t*`.
 
 ##### Additions :tada:
 
+- Added `rayTriangle` intersection function that returns the intersection point between a ray and a triangle.
+- Added `intersectRayGltfModel` intersection function that returns the first intersection point between a ray and a glTF model.
 - Added `convertAccessorComponentTypeToPropertyComponentType`, which converts integer glTF accessor component types to their best-fitting `PropertyComponentType`.
 
 ### v0.37.0 - 2024-07-01

Cesium3DTilesContent/include/Cesium3DTilesContent/I3dmToGltfConverter.h

@@ -5,7 +5,6 @@
 #include <CesiumGltf/Model.h>
 #include <CesiumGltfReader/GltfReader.h>
 
-#include <glm/mat4x4.hpp>
 #include <gsl/span>
 
 #include <optional>

Cesium3DTilesContent/include/Cesium3DTilesContent/TileTransform.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <glm/mat4x4.hpp>
+#include <glm/fwd.hpp>
 
 #include <optional>
 

Cesium3DTilesContent/src/TileTransform.cpp

@@ -1,6 +1,8 @@
 #include <Cesium3DTiles/Tile.h>
 #include <Cesium3DTilesContent/TileTransform.h>
 
+#include <glm/mat4x4.hpp>
+
 namespace Cesium3DTilesContent {
 
 std::optional<glm::dmat4>

Cesium3DTilesContent/test/TestTileTransform.cpp

@@ -3,6 +3,7 @@
 #include <CesiumUtility/Math.h>
 
 #include <catch2/catch.hpp>
+#include <glm/mat4x4.hpp>
 
 using namespace CesiumUtility;
 

Cesium3DTilesReader/test/TestTilesetReader.cpp

@@ -1,6 +1,7 @@
 #include <Cesium3DTiles/Extension3dTilesBoundingVolumeS2.h>
 #include <Cesium3DTilesReader/TilesetReader.h>
 #include <CesiumJsonReader/JsonReader.h>
+#include <CesiumNativeTests/readFile.h>
 
 #include <catch2/catch.hpp>
 #include <glm/vec3.hpp>
@@ -11,21 +12,6 @@
 #include <fstream>
 #include <string>
 
-namespace {
-std::vector<std::byte> readFile(const std::filesystem::path& fileName) {
-  std::ifstream file(fileName, std::ios::binary | std::ios::ate);
-  REQUIRE(file);
-
-  std::streamsize size = file.tellg();
-  file.seekg(0, std::ios::beg);
-
-  std::vector<std::byte> buffer(static_cast<size_t>(size));
-  file.read(reinterpret_cast<char*>(buffer.data()), size);
-
-  return buffer;
-}
-} // namespace
-
 TEST_CASE("Reads tileset JSON") {
   using namespace std::string_literals;
 

Cesium3DTilesSelection/include/Cesium3DTilesSelection/IPrepareRendererResources.h

@@ -6,7 +6,6 @@
 #include <CesiumAsync/Future.h>
 #include <CesiumRasterOverlays/IPrepareRasterOverlayRendererResources.h>
 
-#include <glm/mat4x4.hpp>
 #include <glm/vec2.hpp>
 #include <gsl/span>
 

Cesium3DTilesSelection/include/Cesium3DTilesSelection/Tile.h

@@ -11,7 +11,6 @@
 #include <CesiumUtility/DoublyLinkedList.h>
 
 #include <glm/common.hpp>
-#include <glm/mat4x4.hpp>
 #include <gsl/span>
 
 #include <atomic>

Cesium3DTilesSelection/test/TestTilesetSelectionAlgorithm.cpp

@@ -9,6 +9,7 @@
 #include <CesiumNativeTests/SimpleAssetRequest.h>
 #include <CesiumNativeTests/SimpleAssetResponse.h>
 #include <CesiumNativeTests/SimpleTaskProcessor.h>
+#include <CesiumNativeTests/readFile.h>
 #include <CesiumUtility/Math.h>
 
 #include <catch2/catch.hpp>
@@ -25,19 +26,6 @@ using namespace CesiumGeospatial;
 using namespace CesiumUtility;
 using namespace CesiumNativeTests;
 
-static std::vector<std::byte> readFile(const std::filesystem::path& fileName) {
-  std::ifstream file(fileName, std::ios::binary | std::ios::ate);
-  REQUIRE(file);
-
-  std::streamsize size = file.tellg();
-  file.seekg(0, std::ios::beg);
-
-  std::vector<std::byte> buffer(static_cast<size_t>(size));
-  file.read(reinterpret_cast<char*>(buffer.data()), size);
-
-  return buffer;
-}
-
 static bool doesTileMeetSSE(
     const ViewState& viewState,
     const Tile& tile,

CesiumGeometry/include/CesiumGeometry/IntersectionTests.h

@@ -10,6 +10,9 @@
 namespace CesiumGeometry {
 class Ray;
 class Plane;
+struct AxisAlignedBox;
+class OrientedBoundingBox;
+class BoundingSphere;
 
 /**
  * @brief Functions for computing the intersection between geometries such as
@@ -99,6 +102,126 @@ class CESIUMGEOMETRY_API IntersectionTests final {
       const glm::dvec3& triangleVertB,
       const glm::dvec3& triangleVertC,
       glm::dvec3& barycentricCoordinates) noexcept;
+
+  /**
+   * @brief Tests if a ray hits a triangle and returns the hit point.
+   *
+   * @param ray The ray.
+   * @param p0 The first vertex of the triangle.
+   * @param p1 The second vertex of the triangle.
+   * @param p2 The third vertex of the triangle.
+   * @param cullBackFaces Ignore triangles that face away from ray. Front faces
+   * use CCW winding order.
+   * @return The point of intersection, or `std::nullopt` if there is no
+   * intersection.
+   */
+  static std::optional<glm::dvec3> rayTriangle(
+      const Ray& ray,
+      const glm::dvec3& p0,
+      const glm::dvec3& p1,
+      const glm::dvec3& p2,
+      bool cullBackFaces = false);
+
+  /**
+   * @brief Tests if an infinite ray hits a triangle and returns the parametric
+   * hit position.
+   *
+   * The return parameter is positive if the intersection point is in front of
+   * the ray origin, negative if it is behind it, or zero if the two points
+   * coincide.
+   *
+   * @param ray The ray.
+   * @param p0 The first vertex of the triangle.
+   * @param p1 The second vertex of the triangle.
+   * @param p2 The third vertex of the triangle.
+   * @param cullBackFaces Ignore triangles that face away from ray. Front faces
+   * use CCW winding order.
+   * @return optional hit parametric value, if one is detected.
+   */
+  static std::optional<double> rayTriangleParametric(
+      const Ray& ray,
+      const glm::dvec3& p0,
+      const glm::dvec3& p1,
+      const glm::dvec3& p2,
+      bool cullBackFaces = false);
+
+  /**
+   * @brief Computes the intersection of a ray and an axis aligned bounding box.
+   *
+   * @param ray The ray.
+   * @param aabb The axis aligned bounding box.
+   * @return The point of intersection, or `std::nullopt` if there is no
+   * intersection.
+   */
+  static std::optional<glm::dvec3>
+  rayAABB(const Ray& ray, const AxisAlignedBox& aabb);
+
+  /**
+   * @brief Computes the intersection of an infinite ray and an axis aligned
+   * bounding box and returns the parametric hit position.
+   *
+   * The return value is positive if the intersection point is in front of the
+   * ray origin, negative if it is behind it, or zero if the two points
+   * coincide.
+   *
+   * @param ray The ray.
+   * @param aabb The axis aligned bounding box.
+   * @return optional hit parametric value, if one is detected.
+   */
+  static std::optional<double>
+  rayAABBParametric(const Ray& ray, const AxisAlignedBox& aabb);
+
+  /**
+   * @brief Computes the intersection of a ray and an oriented bounding box.
+   *
+   * @param ray The ray.
+   * @param obb The oriented bounding box.
+   * @return The point of intersection, or `std::nullopt` if there is no
+   * intersection.
+   */
+  static std::optional<glm::dvec3>
+  rayOBB(const Ray& ray, const OrientedBoundingBox& obb);
+
+  /**
+   * @brief Computes the intersection of an infinite ray and an oriented
+   * bounding box and returns the parametric hit position.
+   *
+   * The return parameter is positive if the intersection point is in front of
+   * the ray origin, negative if it is behind it, or zero if the two points
+   * coincide.
+   *
+   * @param ray The ray.
+   * @param obb The oriented bounding box.
+   * @return optional hit parametric value, if one is detected.
+   */
+  static std::optional<double>
+  rayOBBParametric(const Ray& ray, const OrientedBoundingBox& obb);
+
+  /**
+   * @brief Computes the intersection of a ray and a bounding sphere.
+   *
+   * @param ray The ray.
+   * @param sphere The bounding sphere.
+   * @return The point of intersection, or `std::nullopt` if there is no
+   * intersection.
+   */
+  static std::optional<glm::dvec3>
+  raySphere(const Ray& ray, const BoundingSphere& sphere);
+
+  /**
+   * @brief Computes the intersection of an infinite ray and a bounding sphere
+   * and returns the parametric hit position.
+   *
+   * The return parameter is positive if the intersection point is in front of
+   * the ray origin, negative if it is behind it, or zero if the two points
+   * coincide.
+   *
+   * @param ray The ray.
+   * @param sphere The bounding sphere.
+   * @return optional hit parametric value, if one is detected.
+   */
+  static std::optional<double>
+  raySphereParametric(const Ray& ray, const BoundingSphere& sphere);
 };
 
 } // namespace CesiumGeometry

CesiumGeometry/include/CesiumGeometry/Ray.h

@@ -2,6 +2,7 @@
 
 #include "Library.h"
 
+#include <glm/fwd.hpp>
 #include <glm/vec3.hpp>
 
 namespace CesiumGeometry {
@@ -32,6 +33,24 @@ class CESIUMGEOMETRY_API Ray final {
    */
   const glm::dvec3& getDirection() const noexcept { return this->_direction; }
 
+  /**
+   * @brief Calculates a point on the ray that corresponds to the given
+   * distance from origin. Can be positive, negative, or 0.
+   *
+   * @param distance Desired distance from origin
+   * @return The point along the ray.
+   */
+  glm::dvec3 pointFromDistance(double distance) const noexcept;
+
+  /**
+   * @brief Transforms the ray using a given 4x4 transformation matrix.
+   *
+   * @param transformation The 4x4 transformation matrix used to transform the
+   * ray.
+   * @return The transformed ray.
+   */
+  Ray transform(const glm::dmat4x4& transformation) const noexcept;
+
   /**
    * @brief Constructs a new ray with its direction opposite this one.
    */

CesiumGeometry/include/CesiumGeometry/Transforms.h

@@ -3,7 +3,6 @@
 #include "Library.h"
 
 #include <glm/fwd.hpp>
-#include <glm/mat4x4.hpp>
 
 namespace CesiumGeometry {