pymomentum-cpu 0.1.82.post0__cp313-cp313-macosx_14_0_arm64.whl

include/momentum/rasterizer/tensor.h

@@ -0,0 +1,140 @@
+/*
+ * 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 <mdspan/mdspan.hpp>
+#include <momentum/common/aligned.h>
+#include <momentum/rasterizer/fwd.h>
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <stdexcept>
+
+namespace momentum::rasterizer {
+
+using index_t = std::ptrdiff_t;
+
+// Simplified Tensor class local to Rasterizer
+// Uses std::vector with aligned allocator and provides conversion to std::mdspan
+template <typename T, size_t Rank>
+class Tensor {
+ private:
+  using extents_t = std::array<index_t, Rank>;
+  using allocator_t = momentum::AlignedAllocator<T, kSimdAlignment>;
+  using storage_t = std::vector<T, allocator_t>;
+
+  extents_t _extents = {};
+  storage_t _data;
+
+ public:
+  using element_type = T;
+  using value_type = std::remove_cv_t<T>;
+
+  Tensor() = default;
+
+  explicit Tensor(const extents_t& extents, const T& defaultValue = T{}) : _extents(extents) {
+    auto size = calculateSize(extents);
+    if (size > 0) {
+      _data.resize(size, defaultValue);
+    }
+  }
+
+  template <typename... SizeTypes>
+  explicit Tensor(SizeTypes... dims) : Tensor(extents_t{static_cast<index_t>(dims)...}) {}
+
+  // Copy constructor, move constructor, copy assignment, and move assignment
+  // are automatically generated and work correctly with std::vector
+
+  // Conversion to mdspan
+  explicit operator Kokkos::mdspan<T, Kokkos::dextents<index_t, Rank>>() {
+    return Kokkos::mdspan<T, Kokkos::dextents<index_t, Rank>>(
+        _data.data(), Kokkos::dextents<index_t, Rank>(_extents));
+  }
+
+  explicit operator Kokkos::mdspan<const T, Kokkos::dextents<index_t, Rank>>() const {
+    return Kokkos::mdspan<const T, Kokkos::dextents<index_t, Rank>>(
+        _data.data(), Kokkos::dextents<index_t, Rank>(_extents));
+  }
+
+  // View method for compatibility
+  Kokkos::mdspan<T, Kokkos::dextents<index_t, Rank>> view() {
+    return Kokkos::mdspan<T, Kokkos::dextents<index_t, Rank>>(
+        _data.data(), Kokkos::dextents<index_t, Rank>(_extents));
+  }
+
+  [[nodiscard]] Kokkos::mdspan<const T, Kokkos::dextents<index_t, Rank>> view() const {
+    return Kokkos::mdspan<const T, Kokkos::dextents<index_t, Rank>>(
+        _data.data(), Kokkos::dextents<index_t, Rank>(_extents));
+  }
+
+  [[nodiscard]] Kokkos::mdspan<const T, Kokkos::dextents<index_t, Rank>> const_view() const {
+    return Kokkos::mdspan<const T, Kokkos::dextents<index_t, Rank>>(
+        _data.data(), Kokkos::dextents<index_t, Rank>(_extents));
+  }
+
+  // Multi-dimensional indexing operator() inspired by ASpan
+  template <typename... Args>
+  std::enable_if_t<sizeof...(Args) == Rank, T&> operator()(Args... indices) {
+    static_assert(sizeof...(Args) == Rank, "Number of indices must match tensor rank");
+    return view()(indices...);
+  }
+
+  template <typename... Args>
+  std::enable_if_t<sizeof...(Args) == Rank, const T&> operator()(Args... indices) const {
+    static_assert(sizeof...(Args) == Rank, "Number of indices must match tensor rank");
+    return view()(indices...);
+  }
+
+  // Basic accessors
+  T* data() {
+    return _data.data();
+  }
+  [[nodiscard]] const T* data() const {
+    return _data.data();
+  }
+
+  [[nodiscard]] constexpr index_t extent(size_t dim) const {
+    return _extents[dim];
+  }
+  [[nodiscard]] constexpr extents_t extents() const {
+    return _extents;
+  }
+
+  [[nodiscard]] index_t size() const {
+    return static_cast<index_t>(_data.size());
+  }
+  [[nodiscard]] bool empty() const {
+    return _data.empty();
+  }
+
+  void resize(const extents_t& new_extents) {
+    auto new_size = calculateSize(new_extents);
+    _data.resize(new_size);
+    _extents = new_extents;
+  }
+
+  template <typename... SizeTypes>
+  void resize(SizeTypes... dims) {
+    resize(extents_t{static_cast<index_t>(dims)...});
+  }
+
+ private:
+  static index_t calculateSize(const extents_t& extents) {
+    index_t size = 1;
+    for (auto ext : extents) {
+      size *= ext;
+    }
+    return size;
+  }
+};
+
+using Tensor2f = Tensor<float, 2>;
+using Tensor3f = Tensor<float, 3>;
+using Tensor2i = Tensor<int, 2>;
+
+} // namespace momentum::rasterizer

include/momentum/rasterizer/utility.h

@@ -0,0 +1,268 @@
+/*
+ * 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/array.h>
+#include <drjit/fwd.h>
+#include <drjit/matrix.h>
+#include <mdspan/mdspan.hpp>
+#include <momentum/rasterizer/fwd.h>
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include <array>
+#include <memory>
+#include <sstream>
+#include <utility>
+
+// Forward declarations to avoid circular dependencies
+namespace momentum::rasterizer {
+
+using index_t = std::ptrdiff_t;
+
+// Actual implementations
+
+template <std::size_t R>
+std::string formatTensorSizes(const std::array<index_t, R>& extents) {
+  std::ostringstream oss;
+  oss << "[";
+  for (size_t i = 0; i < extents.size(); ++i) {
+    if (i != 0) {
+      oss << " x ";
+    }
+    oss << extents[i];
+  }
+  oss << "]";
+  return oss.str();
+}
+
+// Overload for mdspan extents using parameter pack
+template <class IndexType, size_t... Extents>
+std::string formatTensorSizes(const Kokkos::extents<IndexType, Extents...>& extents) {
+  std::ostringstream oss;
+  oss << "[";
+  for (size_t i = 0; i < extents.rank(); ++i) {
+    if (i != 0) {
+      oss << " x ";
+    }
+    oss << extents.extent(i);
+  }
+  oss << "]";
+  return oss.str();
+}
+
+// Validates that an mdspan buffer is suitable for rasterization operations.
+// This function checks:
+// 1. Data pointer is properly aligned for SIMD operations
+// 2. All dimensions except the first are contiguous (rows are packed tightly)
+// 3. The stride for the first dimension is a multiple of kSimdPacketSize
+template <typename T, typename Extents>
+bool isValidBuffer(const Kokkos::mdspan<T, Extents>& buffer) {
+  if (buffer.empty()) {
+    return true; // Empty buffers are always valid
+  }
+
+  constexpr auto rank = Kokkos::mdspan<T, Extents>::rank();
+
+  // Check alignment of data pointer
+  if (reinterpret_cast<uintptr_t>(buffer.data_handle()) % kSimdAlignment != 0) {
+    return false;
+  }
+
+  // For 1D buffers, just check that the stride is compatible with SIMD
+  if (rank == 1) {
+    return buffer.stride(0) % kSimdPacketSize == 0;
+  }
+
+  // For multi-dimensional buffers, check contiguity of all dimensions except the first
+  // Start from the rightmost dimension and work backwards
+  index_t expected_stride = 1;
+  for (size_t dim = rank; dim > 1; --dim) {
+    size_t i = dim - 1;
+    if (buffer.stride(i) != expected_stride) {
+      return false; // Not contiguous in this dimension
+    }
+    expected_stride *= buffer.extent(i);
+  }
+
+  // Check that the first dimension stride is a multiple of kSimdPacketSize
+  // This ensures proper SIMD alignment for accessing rows
+  return buffer.stride(0) % kSimdPacketSize == 0;
+}
+
+// Helper function to get the row stride for accessing buffer rows properly
+// This ensures we use the actual mdspan stride instead of assuming contiguity
+template <typename T, typename Extents>
+index_t getRowStride(const Kokkos::mdspan<T, Extents>& buffer) {
+  static_assert(
+      Kokkos::mdspan<T, Extents>::rank() >= 2, "getRowStride requires at least 2D buffer");
+  return buffer.stride(0);
+}
+
+// Checks if an mdspan has a standard row-major contiguous layout
+// This is useful for optimization decisions where contiguous access patterns can be used
+template <typename T, typename Extents>
+bool isContiguous(const Kokkos::mdspan<T, Extents>& buffer) {
+  if (buffer.empty()) {
+    return true; // Empty buffers are trivially contiguous
+  }
+
+  constexpr auto rank = Kokkos::mdspan<T, Extents>::rank();
+
+  // Check contiguity from the rightmost dimension working backwards
+  index_t expected_stride = 1;
+  for (size_t dim = rank; dim > 0; --dim) {
+    size_t i = dim - 1;
+    if (buffer.stride(i) != expected_stride) {
+      return false; // Not contiguous in this dimension
+    }
+    expected_stride *= buffer.extent(i);
+  }
+
+  return true;
+}
+
+inline Vector3f toEnokiVec(const Eigen::Vector3f& v) {
+  return {v.x(), v.y(), v.z()};
+}
+
+inline Matrix3f toEnokiMat(const Eigen::Matrix3f& m) {
+  return Matrix3f(m(0, 0), m(0, 1), m(0, 2), m(1, 0), m(1, 1), m(1, 2), m(2, 0), m(2, 1), m(2, 2));
+}
+
+inline auto extractSingleElement(const Matrix3dP& mat, int index) {
+  return Matrix3d{
+      mat(0, 0)[index],
+      mat(0, 1)[index],
+      mat(0, 2)[index],
+      mat(1, 0)[index],
+      mat(1, 1)[index],
+      mat(1, 2)[index],
+      mat(2, 0)[index],
+      mat(2, 1)[index],
+      mat(2, 2)[index]};
+}
+inline auto extractSingleElement(const Matrix3fP& mat, int index) {
+  return Matrix3f{
+      mat(0, 0)[index],
+      mat(0, 1)[index],
+      mat(0, 2)[index],
+      mat(1, 0)[index],
+      mat(1, 1)[index],
+      mat(1, 2)[index],
+      mat(2, 0)[index],
+      mat(2, 1)[index],
+      mat(2, 2)[index]};
+}
+
+inline auto extractSingleElement(const Vector3dP& vec, int index) {
+  return Vector3d{vec.x()[index], vec.y()[index], vec.z()[index]};
+}
+
+inline auto extractSingleElement(const Vector3fP& vec, int index) {
+  return Vector3f{vec.x()[index], vec.y()[index], vec.z()[index]};
+}
+
+inline auto extractSingleElement(const Vector2fP& vec, int index) {
+  return Vector2f(vec.x()[index], vec.y()[index]);
+}
+
+inline auto extractSingleElement(const FloatP& vec, int index) {
+  return vec[index];
+}
+
+class SimdCamera {
+ public:
+  // Camera that operates on drjit::Vector3fP.
+  SimdCamera(const Camera& camera, Eigen::Matrix4f modelMatrix, Eigen::Vector2f imageOffset)
+      : _modelMatrix(modelMatrix),
+        _imageOffset(std::move(imageOffset)),
+        _intrinsics(camera.intrinsicsModel()),
+        _modelToWorld_rotation(toEnokiMat(modelMatrix.topLeftCorner<3, 3>())),
+        _modelToWorld_translation(toEnokiVec(modelMatrix.block<3, 1>(0, 3))),
+        _modelToWorld_row3(toEnokiVec(modelMatrix.block<1, 3>(3, 0))),
+        _modelToWorld_33(modelMatrix(3, 3)),
+        _normalMatrix(toEnokiMat(
+            (camera.eyeFromWorld() * Eigen::Transform<float, 3, Eigen::Affine>(modelMatrix))
+                .linear()
+                .inverse()
+                .transpose())),
+        _worldToEye_translation(toEnokiVec(Eigen::Vector3f(camera.eyeFromWorld().translation()))),
+        _worldToEye_rotation(toEnokiMat(camera.eyeFromWorld().linear().matrix())),
+        _fx(camera.fx()),
+        _fy(camera.fy()),
+        _imageWidth(camera.imageWidth()),
+        _imageHeight(camera.imageHeight()) {}
+
+  [[nodiscard]] auto fx() const {
+    return _fx;
+  }
+
+  [[nodiscard]] auto fy() const {
+    return _fy;
+  }
+
+  [[nodiscard]] auto imageWidth() const {
+    return _imageWidth;
+  }
+
+  [[nodiscard]] auto imageHeight() const {
+    return _imageHeight;
+  }
+
+  [[nodiscard]] Vector3fP worldToEye(const Vector3fP& p_world) const {
+    // Because we support projection in the model-to-world matrix, we can't just combine it
+    // with the world-to-eye matrix, so we'll keep them separate.
+    // Model-to-world matrix looks like this:
+    //    [ mR   mT ]
+    //    [ m3x m33 ]
+    // Blockwise multiplication gives:
+    //    [ mR   mT ] [ v ] = [ mR * v + mT    ]
+    //    [ m3x m33 ] [ 1 ]   [ m3x^T * v + m33]
+    const Vector3fP p_world_unnormalized =
+        _modelToWorld_rotation * p_world + _modelToWorld_translation;
+    const FloatP p_world_w = drjit::dot(_modelToWorld_row3, p_world) + _modelToWorld_33;
+    const Vector3fP p_world_normalized = p_world_unnormalized / p_world_w;
+
+    return _worldToEye_rotation * p_world_normalized + _worldToEye_translation;
+  }
+
+  [[nodiscard]] Vector3fP worldToEyeNormal(const Vector3fP& n_world) const {
+    return drjit::normalize(_normalMatrix * n_world);
+  }
+
+  [[nodiscard]] auto eyeToWindow(const Vector3fP& p_eye) const {
+    return _intrinsics->project(p_eye);
+  }
+
+  [[nodiscard]] auto worldToWindow(const Vector3fP& p_world) const {
+    return eyeToWindow(worldToEye(p_world));
+  }
+
+ private:
+  const Eigen::Matrix4f _modelMatrix;
+  const Eigen::Vector2f _imageOffset;
+  std::shared_ptr<const IntrinsicsModelT<float>> _intrinsics;
+
+  const Matrix3f _modelToWorld_rotation;
+  const Vector3f _modelToWorld_translation;
+  const Vector3f _modelToWorld_row3;
+  const float _modelToWorld_33;
+
+  const Matrix3f _normalMatrix;
+
+  const Vector3f _worldToEye_translation;
+  const Matrix3f _worldToEye_rotation;
+
+  const float _fx;
+  const float _fy;
+
+  const int32_t _imageWidth;
+  const int32_t _imageHeight;
+};
+
+} // namespace momentum::rasterizer

include/momentum/simd/simd.h

@@ -0,0 +1,221 @@
+/*
+ * 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 <momentum/common/exception.h>
+#include <momentum/math/transform.h>
+
+#include <drjit/array.h>
+#include <drjit/array_router.h>
+#include <drjit/packet.h>
+#include <drjit/util.h>
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+
+#define DRJIT_VERSION_GE(major, minor, patch)                           \
+  ((DRJIT_VERSION_MAJOR > (major)) ||                                   \
+   (DRJIT_VERSION_MAJOR == (major) && DRJIT_VERSION_MINOR > (minor)) || \
+   (DRJIT_VERSION_MAJOR == (major) && DRJIT_VERSION_MINOR == (minor) && \
+    DRJIT_VERSION_PATCH >= (patch)))
+
+// Utilities for writing cross-platform SIMD code.
+// This currently uses the DrJit library for SIMD primitives.
+
+namespace momentum {
+
+inline constexpr size_t kAvxPacketSize = 8;
+inline constexpr size_t kAvxAlignment = kAvxPacketSize * sizeof(float);
+
+inline constexpr size_t kSimdPacketSize = drjit::DefaultSize;
+inline constexpr size_t kSimdAlignment = kSimdPacketSize * sizeof(float);
+
+template <typename T>
+using Packet = drjit::Packet<T, kSimdPacketSize>;
+
+using FloatP = Packet<float>;
+using DoubleP = Packet<double>;
+using IntP = Packet<int>;
+
+template <typename T, int Dim>
+using VectorP = drjit::Array<Packet<T>, Dim>;
+
+template <typename T>
+using Vector2P = VectorP<T, 2>;
+
+template <typename T>
+using Vector3P = VectorP<T, 3>;
+
+using Vector2fP = Vector2P<float>;
+using Vector3fP = Vector3P<float>;
+
+using Vector2dP = Vector2P<double>;
+using Vector3dP = Vector3P<double>;
+
+/// Computes the offset required for the matrix data to meet the alignment requirement.
+template <size_t Alignment>
+[[nodiscard]] size_t computeOffset(const Eigen::Ref<Eigen::MatrixXf>& mat) {
+  constexpr size_t sizeOfScalar = sizeof(typename Eigen::MatrixXf::Scalar);
+  const size_t addressOffset =
+      Alignment / sizeOfScalar - (((size_t)mat.data() % Alignment) / sizeOfScalar);
+
+  // If the current alignment already meets the requirement, no offset is needed.
+  if (addressOffset == Alignment / sizeOfScalar) {
+    return 0;
+  }
+
+  return addressOffset;
+}
+
+/// Checks if the data of the matrix is aligned correctly.
+template <size_t Alignment>
+void checkAlignment(const Eigen::Ref<Eigen::MatrixXf>& mat, size_t offset = 0) {
+  MT_THROW_IF(
+      (uintptr_t(mat.data() + offset)) % Alignment != 0,
+      "Matrix ({}x{}, ptr: {}) is not aligned ({}) correctly.",
+      mat.rows(),
+      mat.cols(),
+      uintptr_t(mat.data()),
+      Alignment);
+}
+
+/// Calculates dot product of Eigen::Vector3f and 3-vector of packets.
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3D vector of Eigen.
+/// @param[in] v2 A 3-vector of packets.
+template <typename Derived, typename S>
+FloatP dot(const Eigen::MatrixBase<Derived>& v1, const Vector3P<S>& v2) {
+  return drjit::fmadd(v1.x(), v2.x(), drjit::fmadd(v1.y(), v2.y(), v1.z() * v2.z()));
+}
+
+/// Calculates dot product of Vector3P and Eigen::Vector3f.
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3-vector of packets.
+/// @param[in] v2 A 3D vector of Eigen.
+template <typename Derived, typename S>
+FloatP dot(const Vector3P<S>& v1, const Eigen::MatrixBase<Derived>& v2) {
+  return drjit::fmadd(v1.x(), v2.x(), drjit::fmadd(v1.y(), v2.y(), v1.z() * v2.z()));
+}
+
+/// Calculates summation of Eigen::Vector3f and Vector3P
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3D vector of Eigen.
+/// @param[in] v2 A 3-vector of packets.
+template <typename S, typename Derived>
+Vector3P<S> operator+(const Eigen::MatrixBase<Derived>& v1, const Vector3P<S>& v2) {
+  return {v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z()};
+}
+
+/// Calculates summation of Vector3P and Eigen::Vector3f
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3-vector of packets.
+/// @param[in] v2 A 3D vector of Eigen.
+template <typename S, typename Derived>
+Vector3P<S> operator+(const Vector3P<S>& v1, const Eigen::MatrixBase<Derived>& v2) {
+  return {v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z()};
+}
+
+/// Calculates subtraction of Eigen::Vector3f and Vector3P
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3D vector of Eigen.
+/// @param[in] v2 A 3-vector of packets.
+template <typename S, typename Derived>
+Vector3P<S> operator-(const Eigen::MatrixBase<Derived>& v1, const Vector3P<S>& v2) {
+  return {v1.x() - v2.x(), v1.y() - v2.y(), v1.z() - v2.z()};
+}
+
+/// Calculates subtraction of Vector3P and Eigen::Vector3f
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3-vector of packets.
+/// @param[in] v2 A 3D vector of Eigen.
+template <typename S, typename Derived>
+Vector3P<S> operator-(const Vector3P<S>& v1, const Eigen::MatrixBase<Derived>& v2) {
+  return {v1.x() - v2.x(), v1.y() - v2.y(), v1.z() - v2.z()};
+}
+
+/// Calculates multiplication of quaternion and each 3x1 vector in packet
+///
+/// @param[in] q A quaternion.
+/// @param[in] vec A 3-vector of packets.
+template <typename S>
+Vector3P<S> operator*(const Eigen::Quaternion<S>& q, const Vector3P<S>& vec) {
+  return q * vec;
+}
+
+/// Calculates multiplication of 3x3 matrix and each 3x1 vector in packet
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Matrix3f.
+/// @param[in] xf A 3x3 matrix.
+/// @param[in] vec A 3-vector of packets.
+template <typename S, typename Derived>
+Vector3P<S> operator*(const Eigen::MatrixBase<Derived>& xf, const Vector3P<S>& vec) {
+  return Vector3P<S>{
+      momentum::dot(xf.row(0), vec), momentum::dot(xf.row(1), vec), momentum::dot(xf.row(2), vec)};
+}
+
+/// Calculates affine transformation on each 3x1 vector in packet
+///
+/// @param[in] xf An affine transformation matrix.
+/// @param[in] vec A 3-vector of packets.
+template <typename S>
+Vector3P<S> operator*(const Eigen::Transform<S, 3, Eigen::Affine>& xf, const Vector3P<S>& vec) {
+  return momentum::operator+(momentum::operator*(xf.linear(), vec), xf.translation());
+}
+
+/// Calculates transformation on each 3x1 vector in packet using momentum::Transform
+///
+/// @param[in] xf A momentum transform.
+/// @param[in] vec A 3-vector of packets.
+template <typename S>
+Vector3P<S> operator*(const TransformT<S>& xf, const Vector3P<S>& vec) {
+  return momentum::operator+(momentum::operator*(xf.toLinear(), vec), xf.translation);
+}
+
+/// Calculates cross product of Eigen::Vector3f and Vector3P
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3D vector of Eigen.
+/// @param[in] v2 A 3-vector of packets.
+template <typename S, typename Derived>
+Vector3P<S> cross(const Eigen::MatrixBase<Derived>& v1, const Vector3P<S>& v2) {
+  return {
+      drjit::fmsub(v1.y(), v2.z(), v1.z() * v2.y()),
+      drjit::fmsub(v1.z(), v2.x(), v1.x() * v2.z()),
+      drjit::fmsub(v1.x(), v2.y(), v1.y() * v2.x()),
+  };
+}
+
+/// Calculates cross product of Vector3P and Eigen::Vector3f
+///
+/// @tparam Derived A derived class of Eigen::MatrixBase, which should be compatible with
+/// Eigen::Vector3f.
+/// @param[in] v1 A 3-vector of packets.
+/// @param[in] v2 A 3D vector of Eigen.
+template <typename S, typename Derived>
+Vector3P<S> cross(const Vector3P<S>& v1, const Eigen::MatrixBase<Derived>& v2) {
+  return {
+      drjit::fmsub(v1.y(), v2.z(), v1.z() * v2.y()),
+      drjit::fmsub(v1.z(), v2.x(), v1.x() * v2.z()),
+      drjit::fmsub(v1.x(), v2.y(), v1.y() * v2.x()),
+  };
+}
+
+} // namespace momentum