pymomentum-cpu 0.1.80.post1__cp313-cp313-manylinux_2_39_x86_64.whl → 0.1.83.post0__cp313-cp313-manylinux_2_39_x86_64.whl

include/axel/DualContouring.h

@@ -13,7 +13,7 @@
 
 #include <Eigen/Core>
 #include <Eigen/Dense>
-#include <gsl/span>
+#include <span>
 
 #include "axel/BoundingBox.h"
 #include "axel/SignedDistanceField.h"

include/axel/MeshToSdf.h

@@ -12,7 +12,7 @@
 #include <vector>
 
 #include <Eigen/Core>
-#include <gsl/span>
+#include <span>
 
 #include "axel/BoundingBox.h"
 #include "axel/SignedDistanceField.h"
@@ -53,8 +53,8 @@ struct MeshToSdfConfig {
  */
 template <typename ScalarType>
 SignedDistanceField<ScalarType> meshToSdf(
-    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
-    gsl::span<const Eigen::Vector3i> triangles,
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles,
     const BoundingBox<ScalarType>& bounds,
     const Eigen::Vector3<Index>& resolution,
     const MeshToSdfConfig<ScalarType>& config = {});
@@ -71,8 +71,8 @@ SignedDistanceField<ScalarType> meshToSdf(
  */
 template <typename ScalarType>
 SignedDistanceField<ScalarType> meshToSdf(
-    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
-    gsl::span<const Eigen::Vector3i> triangles,
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles,
     const Eigen::Vector3<Index>& resolution,
     ScalarType padding = ScalarType{0.1},
     const MeshToSdfConfig<ScalarType>& config = {});
@@ -88,8 +88,8 @@ namespace detail {
  */
 template <typename ScalarType>
 void initializeNarrowBand(
-    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
-    gsl::span<const Eigen::Vector3i> triangles,
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles,
     SignedDistanceField<ScalarType>& sdf,
     ScalarType bandWidth);
 
@@ -105,14 +105,14 @@ void fastMarchingPropagate(SignedDistanceField<ScalarType>& sdf);
 template <typename ScalarType>
 void applySignsToDistanceField(
     SignedDistanceField<ScalarType>& sdf,
-    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
-    gsl::span<const Eigen::Vector3i> triangles);
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles);
 
 /**
  * Compute mesh bounding box from vertex spans.
  */
 template <typename ScalarType>
-BoundingBox<ScalarType> computeMeshBounds(gsl::span<const Eigen::Vector3<ScalarType>> vertices);
+BoundingBox<ScalarType> computeMeshBounds(std::span<const Eigen::Vector3<ScalarType>> vertices);
 
 } // namespace detail
 

include/axel/SimdKdTree.h

@@ -12,7 +12,7 @@
 
 #include <Eigen/Core>
 #include <Eigen/Geometry>
-#include <gsl/span>
+#include <span>
 
 #ifdef AXEL_ENABLE_AVX
 #include <immintrin.h>
@@ -60,9 +60,9 @@ class SimdKdTreef {
 
   /// Constructs k-d tree from points, normals, and colors.
   explicit SimdKdTreef(
-      gsl::span<const Vec> points = gsl::span<Vec>{},
-      gsl::span<const Vec> normals = gsl::span<Vec>{},
-      gsl::span<const Col> colors = gsl::span<Col>{});
+      std::span<const Vec> points = std::span<Vec>{},
+      std::span<const Vec> normals = std::span<Vec>{},
+      std::span<const Col> colors = std::span<Col>{});
 
   /// Destructor.
   virtual ~SimdKdTreef();
@@ -147,8 +147,8 @@ class SimdKdTreef {
   /// Returns the index of that new node.
   SizeType split(
       std::vector<std::pair<SizeType, Vec>>& points,
-      gsl::span<const Vec> normals,
-      gsl::span<const Col> colors,
+      std::span<const Vec> normals,
+      std::span<const Col> colors,
       SizeType start,
       SizeType end,
       SizeType depth);
@@ -156,8 +156,8 @@ class SimdKdTreef {
   /// Creates a leaf node when the number of points is equal to or greater than 8 SIMD blocks.
   virtual SizeType createLeafNode(
       std::vector<std::pair<SizeType, Vec>>& points,
-      gsl::span<const Vec> normals,
-      gsl::span<const Col> colors,
+      std::span<const Vec> normals,
+      std::span<const Col> colors,
       SizeType start,
       SizeType end,
       const Box& box);
@@ -227,9 +227,9 @@ class SimdKdTreef {
  private:
   /// Initializes the k-d tree. This function is intended to be only called by the constructor.
   void init(
-      gsl::span<const Vec> points_in,
-      gsl::span<const Vec> normals_in,
-      gsl::span<const Col> colors_in);
+      std::span<const Vec> points_in,
+      std::span<const Vec> normals_in,
+      std::span<const Col> colors_in);
 
   /// PIMPL idiom to hide the SIMD specific implementation.
   struct Implementation;
@@ -267,9 +267,9 @@ class SimdKdTreeAvxf : public SimdKdTreef<nDim> {
 
   /// Constructs k-d tree from points, normals, and colors
   explicit SimdKdTreeAvxf(
-      gsl::span<const Vec> points = gsl::span<Vec>{},
-      gsl::span<const Vec> normals = gsl::span<Vec>{},
-      gsl::span<const Col> colors = gsl::span<Col>{});
+      std::span<const Vec> points = std::span<Vec>{},
+      std::span<const Vec> normals = std::span<Vec>{},
+      std::span<const Col> colors = std::span<Col>{});
 
   /// Destructor
   ~SimdKdTreeAvxf() override;
@@ -350,8 +350,8 @@ class SimdKdTreeAvxf : public SimdKdTreef<nDim> {
   // Documentation inherited
   SizeType createLeafNode(
       std::vector<std::pair<SizeType, Vec>>& points,
-      gsl::span<const Vec> normals,
-      gsl::span<const Col> colors,
+      std::span<const Vec> normals,
+      std::span<const Col> colors,
       SizeType start,
       SizeType end,
       const Box& box) override;
@@ -380,9 +380,9 @@ class SimdKdTreeAvxf : public SimdKdTreef<nDim> {
 
   /// Initializes the k-d tree. This function is intended to be only called by the constructor.
   void init(
-      gsl::span<const Vec> points_in,
-      gsl::span<const Vec> normals_in,
-      gsl::span<const Col> colors_in);
+      std::span<const Vec> points_in,
+      std::span<const Vec> normals_in,
+      std::span<const Col> colors_in);
 
   std::vector<PointBlock> pointBlocks_;
   std::vector<NormalBlock> normalBlocks_;

include/axel/math/CoplanarityCheck.h

@@ -8,16 +8,16 @@
 #pragma once
 
 #include <Eigen/Core>
-#include <gsl/span>
+#include <span>
 
 namespace axel {
 
-int solveP3(gsl::span<double, 3> x, double a, double b, double c);
-int solveP2(gsl::span<double, 2> x, double a, double b, double c);
+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(
-    gsl::span<double, 3> t,
+    std::span<double, 3> t,
     const Eigen::Vector3d& x1,
     const Eigen::Vector3d& x2,
     const Eigen::Vector3d& x3,

include/axel/math/MeshHoleFilling.h

@@ -13,7 +13,7 @@
 
 #include <Eigen/Core>
 #include <Eigen/Geometry>
-#include <gsl/span>
+#include <span>
 
 #include "axel/common/Types.h"
 
@@ -64,8 +64,8 @@ struct HoleFillingResult {
  * @return List of detected hole boundaries
  */
 std::vector<HoleBoundary> detectMeshHoles(
-    gsl::span<const Eigen::Vector3f> vertices,
-    gsl::span<const Eigen::Vector3i> triangles);
+    std::span<const Eigen::Vector3f> vertices,
+    std::span<const Eigen::Vector3i> triangles);
 
 /**
  * Fill holes in a triangle mesh using advancing front method.
@@ -79,8 +79,8 @@ std::vector<HoleBoundary> detectMeshHoles(
  */
 template <typename ScalarType>
 HoleFillingResult fillMeshHoles(
-    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
-    gsl::span<const Eigen::Vector3i> triangles);
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles);
 
 /**
  * Convenience function that fills holes and returns complete mesh.
@@ -92,8 +92,8 @@ HoleFillingResult fillMeshHoles(
 template <typename ScalarType>
 std::pair<std::vector<Eigen::Vector3<ScalarType>>, std::vector<Eigen::Vector3i>>
 fillMeshHolesComplete(
-    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
-    gsl::span<const Eigen::Vector3i> triangles);
+    std::span<const Eigen::Vector3<ScalarType>> vertices,
+    std::span<const Eigen::Vector3i> triangles);
 
 /**
  * Apply Laplacian smoothing to mesh vertices with optional masking.
@@ -108,8 +108,8 @@ fillMeshHolesComplete(
  */
 template <typename ScalarType, typename FaceType>
 std::vector<Eigen::Vector3<ScalarType>> smoothMeshLaplacian(
-    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
-    gsl::span<const FaceType> faces,
+    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});

include/momentum/character/blend_shape.h

@@ -22,9 +22,9 @@ struct BlendShape : public BlendShapeBase {
 
   /// @param baseShape Base shape vertices
   /// @param numShapes Number of blend shapes
-  BlendShape(gsl::span<const Vector3f> baseShape, size_t numShapes);
+  BlendShape(std::span<const Vector3f> baseShape, size_t numShapes);
 
-  void setBaseShape(gsl::span<const Vector3f> baseShape) {
+  void setBaseShape(std::span<const Vector3f> baseShape) {
     baseShape_.assign(baseShape.begin(), baseShape.end());
   }
 
@@ -67,7 +67,7 @@ struct BlendShape : public BlendShapeBase {
   /// @param weights Optional per-vertex importance weights
   /// @return Estimated blend shape coefficients
   [[nodiscard]] VectorXf estimateCoefficients(
-      gsl::span<const Vector3f> vertices,
+      std::span<const Vector3f> vertices,
       float regularization = 1.0f,
       const VectorXf& weights = VectorXf()) const;
 
@@ -75,7 +75,7 @@ struct BlendShape : public BlendShapeBase {
   ///
   /// @param index Index of the shape vector to set
   /// @param shapeVector Vector of vertex offsets
-  void setShapeVector(size_t index, gsl::span<const Vector3f> shapeVector);
+  void setShapeVector(size_t index, std::span<const Vector3f> shapeVector);
 
   /// Compares all components of two blend shapes
   ///

include/momentum/character/blend_shape_base.h

@@ -52,7 +52,7 @@ struct BlendShapeBase {
 
   /// @param index Index of the shape vector to set
   /// @param shapeVector Vector of vertex offsets
-  void setShapeVector(size_t index, gsl::span<const Vector3f> shapeVector);
+  void setShapeVector(size_t index, std::span<const Vector3f> shapeVector);
 
   [[nodiscard]] Eigen::Index shapeSize() const {
     return shapeVectors_.cols();

include/momentum/character/character_utility.h

@@ -62,7 +62,7 @@ namespace momentum {
 /// specified joints.
 [[nodiscard]] Character removeJoints(
     const Character& character,
-    gsl::span<const size_t> jointsToRemove);
+    std::span<const size_t> jointsToRemove);
 
 /// Maps the input ModelParameter motion to a target character by matching model parameter names.
 /// Mismatched names will be discarded (source) or set to zero (target).

include/momentum/character/linear_skinning.h

@@ -116,7 +116,7 @@ Affine3f getInverseSSDTransformation(
 std::vector<Vector3f> applyInverseSSD(
     const TransformationList& inverseBindPose,
     const SkinWeights& skin,
-    gsl::span<const Vector3f> points,
+    std::span<const Vector3f> points,
     const SkeletonState& state);
 
 /// Applies inverse SSD to points, storing results in a mesh
@@ -132,7 +132,7 @@ std::vector<Vector3f> applyInverseSSD(
 void applyInverseSSD(
     const TransformationList& inverseBindPose,
     const SkinWeights& skin,
-    gsl::span<const Vector3f> points,
+    std::span<const Vector3f> points,
     const SkeletonState& state,
     Mesh& mesh);
 

include/momentum/character/parameter_transform.h

@@ -11,7 +11,7 @@
 #include <momentum/character/types.h>
 #include <momentum/math/utility.h>
 
-#include <gsl/span>
+#include <span>
 
 #include <string>
 #include <unordered_map>
@@ -102,7 +102,7 @@ struct ParameterTransformT {
 
   /// Return a ParameterTransform object where the model parameters are identical to the joint
   /// parameters.
-  [[nodiscard]] static ParameterTransformT<T> identity(gsl::span<const std::string> jointNames);
+  [[nodiscard]] static ParameterTransformT<T> identity(std::span<const std::string> jointNames);
 
   /// Compute activeJointParams based on the transform and the input ParameterSet.
   [[nodiscard]] VectorX<bool> computeActiveJointParams(const ParameterSet& ps = allParams()) const;

include/momentum/character_sequence_solver/model_parameters_sequence_error_function.h

@@ -24,13 +24,13 @@ class ModelParametersSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   }
 
   double getError(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> meshStates) const final;
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates) const final;
   double getGradient(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> meshStates,
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const final;
 
   // modelParameters: [numFrames() * parameterTransform] parameter vector
@@ -38,9 +38,9 @@ class ModelParametersSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   // jacobian: [getJacobianSize()] x [numFrames() * parameterTransform] Jacobian matrix
   // residual: [getJacobianSize()] residual vector.
   double getJacobian(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> meshStates,
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates,
       Eigen::Ref<Eigen::MatrixX<T>> jacobian,
       Eigen::Ref<Eigen::VectorX<T>> residual,
       int& usedRows) const final;

include/momentum/character_sequence_solver/multipose_solver_function.h

@@ -22,7 +22,7 @@ class MultiposeSolverFunctionT : public SolverFunctionT<T> {
   MultiposeSolverFunctionT(
       const Skeleton* skel,
       const ParameterTransformT<T>* parameterTransform,
-      gsl::span<const int> universal,
+      std::span<const int> universal,
       size_t frames);
   ~MultiposeSolverFunctionT() override;
 

include/momentum/character_sequence_solver/sequence_error_function.h

@@ -46,9 +46,9 @@ class SequenceErrorFunctionT {
   }
 
   [[nodiscard]] virtual double getError(
-      gsl::span<const ModelParametersT<T>> /* modelParameters */,
-      gsl::span<const SkeletonStateT<T>> /* skelStates */,
-      gsl::span<const MeshStateT<T>> /* meshStates */) const {
+      std::span<const ModelParametersT<T>> /* modelParameters */,
+      std::span<const SkeletonStateT<T>> /* skelStates */,
+      std::span<const MeshStateT<T>> /* meshStates */) const {
     return 0.0f;
   }
 
@@ -58,9 +58,9 @@ class SequenceErrorFunctionT {
   // meshStates: [numFrames()] array of mesh states
   // gradient: [numFrames() * parameterTransform] gradient vector
   virtual double getGradient(
-      gsl::span<const ModelParametersT<T>> /* modelParameters */,
-      gsl::span<const SkeletonStateT<T>> /* skelStates */,
-      gsl::span<const MeshStateT<T>> /* meshStates */,
+      std::span<const ModelParametersT<T>> /* modelParameters */,
+      std::span<const SkeletonStateT<T>> /* skelStates */,
+      std::span<const MeshStateT<T>> /* meshStates */,
       Eigen::Ref<Eigen::VectorX<T>> /* gradient */) const {
     return 0.0f;
   }
@@ -71,9 +71,9 @@ class SequenceErrorFunctionT {
   // jacobian: [getJacobianSize()] x [numFrames() * parameterTransform] Jacobian matrix
   // residual: [getJacobianSize()] residual vector.
   virtual double getJacobian(
-      gsl::span<const ModelParametersT<T>> /* modelParameters */,
-      gsl::span<const SkeletonStateT<T>> /* skelStates */,
-      gsl::span<const MeshStateT<T>> /* meshStates */,
+      std::span<const ModelParametersT<T>> /* modelParameters */,
+      std::span<const SkeletonStateT<T>> /* skelStates */,
+      std::span<const MeshStateT<T>> /* meshStates */,
       Eigen::Ref<Eigen::MatrixX<T>> /* jacobian */,
       Eigen::Ref<Eigen::VectorX<T>> /* residual */,
       int& usedRows) const {

include/momentum/character_sequence_solver/sequence_solver_function.h

@@ -79,7 +79,7 @@ class SequenceSolverFunctionT : public SolverFunctionT<T> {
   ///
   /// @return An Eigen::VectorX<T> object containing the joined parameter vector of all frames.
   [[nodiscard]] Eigen::VectorX<T> getJoinedParameterVectorFromFrameParameters(
-      gsl::span<const ModelParametersT<T>> frameParameters) const;
+      std::span<const ModelParametersT<T>> frameParameters) const;
 
   void setJoinedParameterVector(const Eigen::VectorX<T>& joinedParameters);
 
@@ -126,7 +126,7 @@ class SequenceSolverFunctionT : public SolverFunctionT<T> {
   std::atomic<size_t> numTotalPerFrameErrorFunctions_ = 0;
   std::atomic<size_t> numTotalSequenceErrorFunctions_ = 0;
 
-  bool needsMesh_ = false;
+  std::atomic<bool> needsMesh_{false};
 
   friend class SequenceSolverT<T>;
 };

include/momentum/character_sequence_solver/state_sequence_error_function.h

@@ -28,13 +28,13 @@ class StateSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   }
 
   double getError(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> /* meshStates */) const final;
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> /* meshStates */) const final;
   double getGradient(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> /* meshStates */,
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> /* meshStates */,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const final;
 
   // modelParameters: [numFrames() * parameterTransform] parameter vector
@@ -42,9 +42,9 @@ class StateSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   // jacobian: [getJacobianSize()] x [numFrames() * parameterTransform] Jacobian matrix
   // residual: [getJacobianSize()] residual vector.
   double getJacobian(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> /* meshStates */,
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> /* meshStates */,
       Eigen::Ref<Eigen::MatrixX<T>> jacobian,
       Eigen::Ref<Eigen::VectorX<T>> residual,
       int& usedRows) const final;

include/momentum/character_sequence_solver/vertex_sequence_error_function.h

@@ -14,7 +14,7 @@
 #include <momentum/character_solver/vertex_error_function.h>
 #include <momentum/math/mesh.h>
 
-#include <gsl/span>
+#include <span>
 
 namespace momentum {
 
@@ -46,13 +46,13 @@ class VertexSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   }
 
   double getError(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> meshStates) const final;
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates) const final;
   double getGradient(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> meshStates,
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const final;
 
   // modelParameters: [numFrames() * parameterTransform] parameter vector
@@ -60,13 +60,17 @@ class VertexSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   // jacobian: [getJacobianSize()] x [numFrames() * parameterTransform] Jacobian matrix
   // residual: [getJacobianSize()] residual vector.
   double getJacobian(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates,
-      gsl::span<const MeshStateT<T>> meshStates,
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates,
       Eigen::Ref<Eigen::MatrixX<T>> jacobian,
       Eigen::Ref<Eigen::VectorX<T>> residual,
       int& usedRows) const final;
 
+  bool needsMesh() const final {
+    return true;
+  }
+
   [[nodiscard]] size_t getJacobianSize() const final;
 
   /// Add a vertex velocity constraint.
@@ -98,31 +102,22 @@ class VertexSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
  private:
   /// Calculate gradient for a single vertex velocity constraint.
   double calculateVelocityGradient(
-      gsl::span<const SkeletonStateT<T>> skelStates,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates,
       const VertexVelocityConstraintT<T>& constraint,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const;
 
   /// Calculate Jacobian for a single vertex velocity constraint.
   double calculateVelocityJacobian(
-      gsl::span<const SkeletonStateT<T>> skelStates,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates,
       const VertexVelocityConstraintT<T>& constraint,
       Eigen::Ref<Eigen::MatrixX<T>> jacobian,
       Eigen::Ref<Eigen::VectorX<T>> residual,
       Eigen::Index startRow) const;
 
-  /// Update meshes for both frames.
-  void updateMeshes(
-      gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates) const;
-
   const Character& character_;
   std::vector<VertexVelocityConstraintT<T>> constraints_;
-
-  // Meshes for the two frames
-  mutable std::unique_ptr<MeshT<T>> neutralMesh_;
-  mutable std::unique_ptr<MeshT<T>> restMesh_; // Single rest mesh used for both frames
-  mutable std::unique_ptr<MeshT<T>> posedMesh0_;
-  mutable std::unique_ptr<MeshT<T>> posedMesh1_;
 };
 
 } // namespace momentum

include/momentum/character_solver/constraint_error_function.h

@@ -177,14 +177,14 @@ class ConstraintErrorFunctionT : public SkeletonErrorFunctionT<T> {
   /// Appends a list of constraints
   ///
   /// @param[in] constrs: a list of constraints to be added
-  void addConstraints(gsl::span<const Data> constrs) {
+  void addConstraints(std::span<const Data> constrs) {
     constraints_.insert(constraints_.end(), constrs.begin(), constrs.end());
   }
 
   /// Replace the current list of constraints with the input
   ///
   /// @param[in] constrs: the new list of constraints
-  void setConstraints(gsl::span<const Data> constrs) {
+  void setConstraints(std::span<const Data> constrs) {
     constraints_.assign(constrs.begin(), constrs.end());
   }
 

include/momentum/character_solver/pose_prior_error_function.h

@@ -11,7 +11,7 @@
 #include <momentum/character_solver/skeleton_error_function.h>
 #include <momentum/math/mppca.h>
 
-#include <gsl/span>
+#include <span>
 
 namespace momentum {
 

include/momentum/character_solver/skeleton_solver_function.h

@@ -13,7 +13,7 @@
 #include <momentum/character/types.h>
 #include <momentum/character_solver/fwd.h>
 #include <momentum/solver/solver_function.h>
-#include <gsl/span>
+#include <span>
 
 namespace momentum {
 
@@ -23,7 +23,7 @@ class SkeletonSolverFunctionT : public SolverFunctionT<T> {
   SkeletonSolverFunctionT(
       const Character& character,
       const ParameterTransformT<T>& parameterTransform,
-      gsl::span<const std::shared_ptr<SkeletonErrorFunctionT<T>>> errorFunctions = {});
+      std::span<const std::shared_ptr<SkeletonErrorFunctionT<T>>> errorFunctions = {});
   ~SkeletonSolverFunctionT() override;
 
   double getError(const Eigen::VectorX<T>& parameters) final;

include/momentum/character_solver/skinned_locator_triangle_error_function.h

@@ -109,23 +109,27 @@ class SkinnedLocatorTriangleErrorFunctionT : public SkeletonErrorFunctionT<T> {
 
   double calculatePositionJacobian(
       const ModelParametersT<T>& modelParameters,
+      const MeshStateT<T>& meshState,
       const SkinnedLocatorTriangleConstraintT<T>& constr,
       Ref<Eigen::MatrixX<T>> jac,
       Ref<Eigen::VectorX<T>> res) const;
 
   double calculatePlaneJacobian(
       const ModelParametersT<T>& modelParameters,
+      const MeshStateT<T>& meshState,
       const SkinnedLocatorTriangleConstraintT<T>& constr,
       Ref<Eigen::MatrixX<T>> jac,
       T& res) const;
 
   double calculatePositionGradient(
       const ModelParametersT<T>& modelParameters,
+      const MeshStateT<T>& meshState,
       const SkinnedLocatorTriangleConstraintT<T>& constr,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const;
 
   double calculatePlaneGradient(
       const ModelParametersT<T>& modelParameters,
+      const MeshStateT<T>& meshState,
       const SkinnedLocatorTriangleConstraintT<T>& constr,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const;
 
@@ -136,11 +140,7 @@ class SkinnedLocatorTriangleErrorFunctionT : public SkeletonErrorFunctionT<T> {
 
   std::vector<SkinnedLocatorTriangleConstraintT<T>> constraints_;
 
-  std::unique_ptr<MeshT<T>> neutralMesh_; // Rest mesh without facial expression basis
-  std::unique_ptr<MeshT<T>> restMesh_; // Rest positions after shape basis is applied
-
   const VertexConstraintType constraintType_;
-  void updateMeshes(const ModelParametersT<T>& modelParameters);
 };
 
 } // namespace momentum