pymomentum-cpu 0.1.93.post0__cp312-cp312-macosx_14_0_arm64.whl

include/axel/TriBvhEmbree.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <embree4/rtcore.h>
+#include <optional>
+
+#include "axel/BvhCommon.h"
+#include "axel/Ray.h"
+
+namespace axel {
+
+template <typename S>
+class TriBvhEmbree {
+ public:
+  TriBvhEmbree(const Eigen::MatrixX3<S>& positions, const Eigen::MatrixX3i& triangles);
+  ~TriBvhEmbree();
+
+  TriBvhEmbree(const TriBvhEmbree&) = delete;
+  TriBvhEmbree& operator=(const TriBvhEmbree&) = delete;
+
+  TriBvhEmbree(TriBvhEmbree&& other) noexcept;
+  TriBvhEmbree& operator=(TriBvhEmbree&& other) noexcept;
+
+  /**
+   * @brief Returns the closest hit with the given query ray.
+   * If the ray hits nothing, returns a std::nullopt.
+   */
+  std::optional<IntersectionResult<S>> closestHit(const Ray3<S>& ray) const;
+
+  /**
+   * @brief Checks whether the given ray intersects any of the primitives in the Bvh.
+   */
+  bool anyHit(const Ray3<S>& ray) const;
+
+  ClosestSurfacePointResult<S> closestSurfacePoint(const Eigen::Vector3<S>& query) const;
+
+  /**
+   * @brief Returns the total number of primitives in the tree. It should be equal to the number of
+   * triangles that Bvh was constructed with.
+   */
+  [[nodiscard]] size_t getPrimitiveCount() const;
+
+ private:
+  // TODO(nemanjab): Wrap this in a singleton to allow usage across multiple BVHs.
+  RTCDevice device_;
+  RTCScene scene_;
+  Eigen::MatrixX3<S> positions_;
+  Eigen::MatrixX3i triangles_;
+};
+
+} // namespace axel

include/axel/common/Constants.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace axel::detail {
+
+template <typename T>
+[[nodiscard]] constexpr T eps(T floatEps = 1e-6, T doubleEps = 1e-15) {
+  if constexpr (std::is_same_v<T, float>) {
+    return floatEps;
+  } else if constexpr (std::is_same_v<T, double>) {
+    return doubleEps;
+  } else {
+    // Using !sizeof(T) makes the static_assert condition type-dependent, ensuring
+    // it's evaluated only when the template is instantiated with a specific type.
+    static_assert(!sizeof(T), "Unsupported type");
+  }
+}
+
+} // namespace axel::detail

include/axel/common/Types.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace axel {
+
+using Index = int32_t;
+static_assert(sizeof(Index) == 4);
+inline constexpr Index kInvalidIndex = Index{-1};
+
+using Size = std::ptrdiff_t;
+
+} // namespace axel

include/axel/common/VectorizationTypes.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <drjit/packet.h>
+
+namespace axel {
+
+// DrJit's DefaultSize constant is based on single precision float (4 for SSE, 8 for AVX, 16 for
+// AVX512).
+// If we are dealing with a platform that doesn't support SIMD/isn't detected, we'll use the
+// fallback sizes that will compile down to scalar loops.
+
+template <typename ScalarType>
+struct NativeLaneWidth {
+  static constexpr size_t value = 0;
+};
+
+template <>
+struct NativeLaneWidth<float> {
+  static constexpr size_t value = drjit::DefaultSize <= 1 ? 4 : drjit::DefaultSize;
+};
+
+template <>
+struct NativeLaneWidth<int32_t> {
+  static constexpr size_t value = drjit::DefaultSize <= 1 ? 4 : drjit::DefaultSize;
+};
+
+template <>
+struct NativeLaneWidth<double> {
+  static constexpr size_t value = drjit::DefaultSize <= 1 ? 2 : drjit::DefaultSize / 2;
+};
+
+template <typename ScalarType>
+inline static constexpr size_t kNativeLaneWidth = NativeLaneWidth<ScalarType>::value;
+
+template <typename Scalar, size_t LaneWidth = kNativeLaneWidth<Scalar>>
+using WideScalar = drjit::Packet<Scalar, LaneWidth>;
+
+template <typename Scalar, size_t LaneWidth = kNativeLaneWidth<Scalar>>
+using WideVec3 = drjit::Array<WideScalar<Scalar, LaneWidth>, 3>; // Each element is a lane.
+
+// Memory layout of a boolean SIMD mask is ISA dependent.
+// We need to retrieve the correct type based on underlying native support.
+template <typename VectorType>
+using WideMask = drjit::mask_t<VectorType>;
+
+using WideScalarf = WideScalar<float>;
+using WideScalard = WideScalar<double>;
+using WideVec3f = WideVec3<float>;
+using WideVec3d = WideVec3<double>;
+
+} // namespace axel

include/axel/math/BoundingBoxUtils.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <Eigen/Geometry>
+
+#include "axel/math/RayTriangleIntersection.h"
+
+namespace axel {
+
+template <class T>
+void getMinMaxBoundSegment(
+    const Eigen::Vector3<T>& p0,
+    const Eigen::Vector3<T>& p1,
+    Eigen::Vector3<T>& minBound,
+    Eigen::Vector3<T>& maxBound,
+    T epsilon) {
+  minBound.array() = p0.array().min(p1.array()) - epsilon;
+  maxBound.array() = p0.array().max(p1.array()) + epsilon;
+}
+
+template <class T>
+void getMinMaxBoundTriangle(
+    const Eigen::Vector3<T>& p0,
+    const Eigen::Vector3<T>& p1,
+    const Eigen::Vector3<T>& p2,
+    Eigen::Vector3<T>& minBound,
+    Eigen::Vector3<T>& maxBound,
+    T epsilon) {
+  minBound.array() = p0.array().min(p1.array().min(p2.array())) - epsilon;
+  maxBound.array() = p0.array().max(p1.array().max(p2.array())) + epsilon;
+}
+
+template <class T>
+void getAdaptiveMinMaxBoundTriangle(
+    const Eigen::Vector3<T>& p0,
+    const Eigen::Vector3<T>& p1,
+    const Eigen::Vector3<T>& p2,
+    Eigen::Vector3<T>& minBound,
+    Eigen::Vector3<T>& maxBound,
+    T multiplicativeFactor = 0.01) {
+  const Eigen::Array3<T> minArray = p0.array().min(p1.array().min(p2.array()));
+  const Eigen::Array3<T> maxArray = p0.array().max(p1.array().max(p2.array()));
+  const Eigen::Array3<T> epsilonArray = (maxArray - minArray) * multiplicativeFactor;
+  minBound.array() = minArray - epsilonArray;
+  maxBound.array() = maxArray + epsilonArray;
+}
+
+} // namespace axel

include/axel/math/ContinuousCollisionDetection.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <Eigen/Core>
+
+namespace axel {
+
+/**
+ * Performs continuous collision detection between two moving edges.
+ * First edge is defined by points (x1, x2) with velocities (v1, v2).
+ * Second edge is defined by points (x3, x4) with velocities (v3, v4).
+ * Returns true if the two edges have an interection within the given time delta `dt`.
+ * Additional check is performed when detectionFrequency > 1, which compares averaged
+ * trajectory distances multiple frames in the future (with time delta = dt * detectionFrequency).
+ */
+bool ccdEdgeEdge(
+    const Eigen::Vector3d& x1,
+    const Eigen::Vector3d& x2,
+    const Eigen::Vector3d& x3,
+    const Eigen::Vector3d& x4,
+    const Eigen::Vector3d& v1,
+    const Eigen::Vector3d& v2,
+    const Eigen::Vector3d& v3,
+    const Eigen::Vector3d& v4,
+    double distanceThreshold,
+    double dt);
+
+// Note: Vertex is represented by p4 with velocity v4, while the triangle is defined by
+// (x1, x2, x3) with velocities (v1, v2, v3).
+bool ccdVertexTriangle(
+    const Eigen::Vector3d& x1,
+    const Eigen::Vector3d& x2,
+    const Eigen::Vector3d& x3,
+    const Eigen::Vector3d& x4,
+    const Eigen::Vector3d& v1,
+    const Eigen::Vector3d& v2,
+    const Eigen::Vector3d& v3,
+    const Eigen::Vector3d& v4,
+    double distanceThreshold,
+    double dt);
+
+} // namespace axel

include/axel/math/CoplanarityCheck.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <Eigen/Core>
+#include <span>
+
+namespace axel {
+
+int solveP3(std::span<double, 3> x, double a, double b, double c);
+int solveP2(std::span<double, 2> x, double a, double b, double c);
+
+/* Find times when the four points with given velocities are coplanar in 3D space */
+int timesCoplanar(
+    std::span<double, 3> t,
+    const Eigen::Vector3d& x1,
+    const Eigen::Vector3d& x2,
+    const Eigen::Vector3d& x3,
+    const Eigen::Vector3d& x4,
+    const Eigen::Vector3d& v1,
+    const Eigen::Vector3d& v2,
+    const Eigen::Vector3d& v3,
+    const Eigen::Vector3d& v4);
+
+} // namespace axel

include/axel/math/EdgeEdgeDistance.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <Eigen/Core>
+
+namespace axel {
+
+/*
+    Compute the distance between the closest points on two edges
+    Edge 1 : p1 - q1
+    Edge 2 : p2 - q2
+    Result: closest points will be
+    p1 + s(q1-p1) on edge 1
+    p2 + t(q2-p2) on edge 2
+*/
+bool distanceEdgeEdge(
+    const Eigen::Vector3d& p1,
+    const Eigen::Vector3d& q1,
+    const Eigen::Vector3d& p2,
+    const Eigen::Vector3d& q2,
+    double& s,
+    double& t,
+    double& distance);
+
+} // namespace axel

include/axel/math/MeshHoleFilling.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include <span>
+
+#include "axel/common/Types.h"
+
+namespace axel {
+
+/**
+ * Represents a hole boundary in the mesh.
+ */
+struct HoleBoundary {
+  /// Ordered list of vertex indices forming the hole boundary
+  std::vector<Index> vertices;
+
+  /// Edge pairs (vertex_i, vertex_i+1) forming the boundary
+  std::vector<std::pair<Index, Index>> edges;
+
+  /// Center point of the hole (computed from boundary vertices)
+  Eigen::Vector3f center;
+
+  /// Approximate radius of the hole
+  float radius{};
+};
+
+/**
+ * Result of hole filling operation.
+ */
+struct HoleFillingResult {
+  /// New vertices added during hole filling
+  std::vector<Eigen::Vector3f> newVertices;
+
+  /// New triangles added (indices refer to original + new vertices)
+  std::vector<Eigen::Vector3i> newTriangles;
+
+  /// Information about filled holes
+  std::vector<HoleBoundary> filledHoles;
+
+  /// Success flag
+  bool success = false;
+
+  /// Number of holes that were successfully filled
+  size_t holesFilledCount = 0;
+};
+
+/**
+ * Detect holes/boundaries in a triangle mesh.
+ *
+ * @param vertices Mesh vertices
+ * @param triangles Mesh triangles
+ * @return List of detected hole boundaries
+ */
+std::vector<HoleBoundary> detectMeshHoles(
+    std::span<const Eigen::Vector3f> vertices,
+    std::span<const Eigen::Vector3i> triangles);
+
+/**
+ * Fill holes in a triangle mesh using advancing front method.
+ *
+ * This function identifies holes in the mesh and fills them with new triangles
+ * to create a watertight surface suitable for SDF generation.
+ *
+ * @param vertices Original mesh vertices
+ * @param triangles Original mesh triangles
+ * @return Result containing new vertices and triangles, or failure info
+ */
+template <typename ScalarType>
+HoleFillingResult fillMeshHoles(
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles);
+
+/**
+ * Convenience function that fills holes and returns complete mesh.
+ *
+ * @param vertices Original mesh vertices
+ * @param triangles Original mesh triangles
+ * @return Pair of (all_vertices, all_triangles) with holes filled
+ */
+template <typename ScalarType>
+std::pair<std::vector<Eigen::Vector3<ScalarType>>, std::vector<Eigen::Vector3i>>
+fillMeshHolesComplete(
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles);
+
+/**
+ * Apply Laplacian smoothing to mesh vertices with optional masking.
+ *
+ * @param vertices Input mesh vertices
+ * @param faces Mesh faces (triangles or quads)
+ * @param vertex_mask Optional mask to specify which vertices to smooth (if empty, all vertices are
+ * smoothed)
+ * @param iterations Number of smoothing iterations
+ * @param step Smoothing step size (0-1)
+ * @return Smoothed vertices
+ */
+template <typename ScalarType, typename FaceType>
+std::vector<Eigen::Vector3<ScalarType>> smoothMeshLaplacian(
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const FaceType> faces,
+    const std::vector<bool>& vertex_mask = {},
+    Index iterations = 1,
+    ScalarType step = ScalarType{0.5});
+
+} // namespace axel

include/axel/math/PointTriangleProjection.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <Eigen/Core>
+
+#include "axel/common/VectorizationTypes.h"
+
+namespace axel {
+
+template <typename S>
+bool projectOnTriangle(
+    const Eigen::Vector3<S>& p,
+    const Eigen::Vector3<S>& a,
+    const Eigen::Vector3<S>& b,
+    const Eigen::Vector3<S>& c,
+    Eigen::Vector3<S>& q,
+    Eigen::Vector3<S>* barycentric = nullptr);
+
+template <typename S>
+WideMask<WideScalar<S>> projectOnTriangle(
+    const WideVec3<S>& p,
+    const WideVec3<S>& a,
+    const WideVec3<S>& b,
+    const WideVec3<S>& c,
+    WideVec3<S>& q,
+    WideVec3<S>* barycentric = nullptr);
+
+} // namespace axel

include/axel/math/PointTriangleProjectionDefinitions.h

@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <Eigen/Geometry>
+
+#include "axel/common/VectorizationTypes.h"
+
+// The definitions here are split in this way to still explicitly instantiate
+// common template types to reduce compilation and binary size in axel, while still
+// allowing an external user to include this file and provide an explicit specialization
+// for a new type.
+namespace axel {
+
+template <class S>
+bool projectOnTriangle(
+    const Eigen::Vector3<S>& p,
+    const Eigen::Vector3<S>& a,
+    const Eigen::Vector3<S>& b,
+    const Eigen::Vector3<S>& c,
+    Eigen::Vector3<S>& q,
+    Eigen::Vector3<S>* barycentric) {
+  // See book 'Real-Time Collision Detection' Ericson Section 5.1.5
+  // Check if P in vertex region outside A
+  const Eigen::Vector3<S> ab = b - a;
+  const Eigen::Vector3<S> ac = c - a;
+  const Eigen::Vector3<S> ap = p - a;
+  const S d1 = ab.dot(ap);
+  const S d2 = ac.dot(ap);
+  constexpr S kZero(0.0);
+  if (d1 <= kZero && d2 <= kZero) {
+    // barycentric coordinates (1.0, 0.0, 0.0)
+    q = a;
+    if (barycentric) {
+      *barycentric = Eigen::Vector3<S>::UnitX();
+    }
+    return false;
+  }
+
+  // Check if P in vertex region outside B
+  const Eigen::Vector3<S> bp = p - b;
+  const S d3 = ab.dot(bp);
+  const S d4 = ac.dot(bp);
+  if (d3 >= kZero && d4 <= d3) {
+    // barycentric coordinate (0.0, 1.0, 0.0)
+    q = b;
+    if (barycentric) {
+      *barycentric = Eigen::Vector3<S>::UnitY();
+    }
+    return false;
+  }
+
+  // Check if P in edge region of AB, if so return projection of P onto AB
+  const S vc = d1 * d4 - d3 * d2;
+  if (vc <= kZero && d1 >= kZero && d3 <= kZero) {
+    // barycentric coordinate (1.0-v, v, 0.0)
+    const S v = d1 / (d1 - d3);
+    q = a + v * ab;
+    if (barycentric) {
+      *barycentric = Eigen::Vector3<S>(S(1) - v, v, S(0));
+    }
+    return false;
+  }
+
+  // Check if P in vertex region outside C
+  const Eigen::Vector3<S> cp = p - c;
+  const S d5 = ab.dot(cp);
+  const S d6 = ac.dot(cp);
+  if (d6 >= kZero && d5 <= d6) {
+    // barycentric coordinate (0.0, 0.0, 1.0)
+    q = c;
+    if (barycentric) {
+      *barycentric = Eigen::Vector3<S>::UnitZ();
+    }
+    return false;
+  }
+
+  // Check if P in edge region of AC, if so return projection of P onto AC
+  const S vb = d5 * d2 - d1 * d6;
+  if (vb <= kZero && d2 >= kZero && d6 <= kZero) {
+    // barycentric coordinate (1.0-w, 0.0, w)
+    const S w = d2 / (d2 - d6);
+    q = a + w * ac;
+    if (barycentric) {
+      *barycentric = Eigen::Vector3<S>(S(1) - w, S(0), w);
+    }
+    return false;
+  }
+
+  // Check if P in edge region of BC, if so return projection of P onto BC
+  const S va = d3 * d6 - d5 * d4;
+  if (va <= kZero && (d4 - d3) >= kZero && (d5 - d6) >= kZero) {
+    // barycentric coordinate (0.0, 1.0-w, w)
+    const S w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+    q = b + w * (c - b);
+    if (barycentric) {
+      *barycentric = Eigen::Vector3<S>(S(0), S(1) - w, w);
+    }
+    return false;
+  }
+
+  // P inside face region.
+  // Compute Q through its barycentric coordinates (u, v, w)
+  const S denom = S(1.0) / (va + vb + vc);
+  const S v = vb * denom;
+  const S w = vc * denom;
+  q = a + ab * v + ac * w;
+  if (barycentric) {
+    *barycentric = Eigen::Vector3<S>(S(1) - v - w, v, w);
+  }
+  return true;
+}
+
+template <typename S>
+WideMask<WideScalar<S>> projectOnTriangle(
+    const WideVec3<S>& p,
+    const WideVec3<S>& a,
+    const WideVec3<S>& b,
+    const WideVec3<S>& c,
+    WideVec3<S>& q,
+    WideVec3<S>* barycentric) {
+  // Check if P in vertex region outside A
+  const auto ab = b - a;
+  const auto ac = c - a;
+  const auto ap = p - a;
+  const auto d1 = drjit::dot(ab, ap);
+  const auto d2 = drjit::dot(ac, ap);
+  auto isOutside = d1 <= 0.0 && d2 <= 0.0;
+  q = drjit::select(isOutside, a, q);
+  if (barycentric) {
+    // barycentric coordinates (1.0, 0.0, 0.0)
+    *barycentric = drjit::select(isOutside, WideVec3<S>(S(1), S(0), S(0)), *barycentric);
+  }
+
+  // Check if P in vertex region outside B
+  const auto bp = p - b;
+  const auto d3 = drjit::dot(ab, bp);
+  const auto d4 = drjit::dot(ac, bp);
+  const auto isOutside2 = d3 >= 0.0 && d4 <= d3;
+  isOutside = isOutside || isOutside2;
+  q = drjit::select(isOutside2, b, q);
+  if (barycentric) {
+    // barycentric coordinates (0.0, 1.0, 0.0)
+    *barycentric = drjit::select(isOutside2, WideVec3<S>(S(0), S(1), S(0)), *barycentric);
+  }
+
+  // Check if P in edge region of AB, if so return projection of P onto AB
+  const auto vc = d1 * d4 - d3 * d2;
+  const auto isOutside3 = vc <= 0.0 && d1 >= 0.0 && d3 <= 0.0;
+  isOutside = isOutside || isOutside3;
+  const auto tAB = d1 / (d1 - d3);
+  q = drjit::select(isOutside3, a + tAB * ab, q);
+  if (barycentric) {
+    // barycentric coordinate (1.0-v, v, 0.0)
+    *barycentric = drjit::select(isOutside3, WideVec3<S>(S(1) - tAB, tAB, S(0)), *barycentric);
+  }
+
+  // Check if P in vertex region outside C
+  const auto cp = p - c;
+  const auto d5 = drjit::dot(ab, cp);
+  const auto d6 = drjit::dot(ac, cp);
+  const auto isOutside4 = d6 >= 0.0 && d5 <= d6;
+  isOutside = isOutside || isOutside4;
+  q = drjit::select(isOutside4, c, q);
+  if (barycentric) {
+    // barycentric coordinate (0.0, 0.0, 1.0)
+    *barycentric = drjit::select(isOutside4, WideVec3<S>(S(0), S(0), S(1)), *barycentric);
+  }
+
+  // Check if P in edge region of AC, if so return projection of P onto AC
+  const auto vb = d5 * d2 - d1 * d6;
+  const auto isOutside5 = vb <= 0.0 && d2 >= 0.0 && d6 <= 0.0;
+  isOutside = isOutside || isOutside5;
+  const auto tAC = d2 / (d2 - d6);
+  q = drjit::select(isOutside5, a + tAC * ac, q);
+  if (barycentric) {
+    // barycentric coordinate (1.0-w, 0.0, w)
+    *barycentric = drjit::select(isOutside5, WideVec3<S>(S(1) - tAC, S(0), tAC), *barycentric);
+  }
+
+  // Check if P in edge region of BC, if so return projection of P onto BC
+  const auto va = d3 * d6 - d5 * d4;
+  const auto isOutside6 = va <= 0.0 && (d4 - d3) >= 0.0 && (d5 - d6) >= 0.0;
+  isOutside = isOutside || isOutside6;
+  const auto tBC = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+  q = drjit::select(isOutside6, b + tBC * (c - b), q);
+  if (barycentric) {
+    // barycentric coordinate (0.0, 1.0-w, w)
+    *barycentric = drjit::select(isOutside6, WideVec3<S>(S(0), S(1) - tBC, tBC), *barycentric);
+  }
+
+  // P inside face region.
+  // Compute Q through its barycentric coordinates (u, v, w)
+  const auto denom = 1.0 / (va + vb + vc);
+  const auto v = vb * denom;
+  const auto w = vc * denom;
+  q = drjit::select(isOutside, q, a + ab * v + ac * w);
+  if (barycentric) {
+    *barycentric = drjit::select(isOutside, *barycentric, WideVec3<S>(S(1) - v - w, v, w));
+  }
+  return !isOutside;
+}
+
+} // namespace axel