pymomentum-cpu 0.0.0__cp312-cp312-manylinux_2_39_x86_64.whl → 0.1.77.post30__cp312-cp312-manylinux_2_39_x86_64.whl

include/axel/DualContouring.h

@@ -0,0 +1,79 @@
+/*
+ * 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 <array>
+#include <unordered_map>
+#include <vector>
+
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <gsl/span>
+
+#include "axel/BoundingBox.h"
+#include "axel/SignedDistanceField.h"
+#include "axel/common/Types.h"
+
+namespace axel {
+
+/**
+ * Result of dual contouring operation.
+ * Dual contouring naturally produces quads, so this always contains quads.
+ * Use triangulateQuads() to convert to triangles if needed.
+ */
+template <typename S>
+struct DualContouringResult {
+  using Scalar = S;
+
+  /// Generated vertices
+  std::vector<Eigen::Vector3<S>> vertices;
+
+  /// Generated quads (dual contouring naturally produces quads)
+  std::vector<Eigen::Vector4i> quads;
+
+  /// Success flag
+  bool success = false;
+
+  /// Number of cells processed
+  size_t processedCells = 0;
+
+  /// Number of vertices generated
+  size_t generatedVertices = 0;
+};
+
+/**
+ * Extract an isosurface from a signed distance field using dual contouring.
+ *
+ * Dual contouring places vertices inside grid cells (rather than on edges like marching cubes)
+ * and uses both function values and gradients to determine optimal vertex placement.
+ * This results in better preservation of sharp features and corners compared to marching cubes.
+ *
+ * The algorithm works by:
+ * 1. Finding all cells that intersect the isosurface (sign changes across cell corners)
+ * 2. Placing one vertex at each intersecting cell, positioned on the surface using gradient descent
+ * 3. Generating quads for each edge crossing that connects 4 adjacent cells
+ *
+ * @param sdf The signed distance field to extract from
+ * @param isovalue The isovalue to extract (typically 0.0 for zero level set)
+ * @return Result containing extracted mesh
+ */
+template <typename ScalarType>
+DualContouringResult<ScalarType> dualContouring(
+    const SignedDistanceField<ScalarType>& sdf,
+    ScalarType isovalue = ScalarType{0.0});
+
+/**
+ * Triangulate a quad mesh into triangles.
+ * Each quad is split into two triangles using the diagonal (0,2).
+ *
+ * @param quads Vector of quads to triangulate
+ * @return Vector of triangles
+ */
+std::vector<Eigen::Vector3i> triangulateQuads(const std::vector<Eigen::Vector4i>& quads);
+
+} // namespace axel

include/axel/SignedDistanceField.h

@@ -89,7 +89,8 @@ class SignedDistanceField {
    * @param position 3D world-space position to query
    * @return Interpolated signed distance value
    */
-  [[nodiscard]] Scalar sample(const Vector3& position) const;
+  template <typename InputScalar = Scalar>
+  [[nodiscard]] InputScalar sample(const Eigen::Vector3<InputScalar>& position) const;
 
   /**
    * Sample the SDF gradient at a continuous 3D position using analytical gradients
@@ -98,7 +99,9 @@ class SignedDistanceField {
    * @param position 3D world-space position to query
    * @return Gradient vector at the given position
    */
-  [[nodiscard]] Vector3 gradient(const Vector3& position) const;
+  template <typename InputScalar = Scalar>
+  [[nodiscard]] Eigen::Vector3<InputScalar> gradient(
+      const Eigen::Vector3<InputScalar>& position) const;
 
   /**
    * Sample both the SDF value and gradient at a continuous 3D position using
@@ -108,7 +111,9 @@ class SignedDistanceField {
    * @param position 3D world-space position to query
    * @return Pair of (value, gradient) at the given position
    */
-  [[nodiscard]] std::pair<Scalar, Vector3> sampleWithGradient(const Vector3& position) const;
+  template <typename InputScalar = Scalar>
+  [[nodiscard]] std::pair<InputScalar, Eigen::Vector3<InputScalar>> sampleWithGradient(
+      const Eigen::Vector3<InputScalar>& position) const;
 
   /**
    * Convert a 3D world-space position to continuous grid coordinates.
@@ -116,7 +121,9 @@ class SignedDistanceField {
    * @param position 3D world-space position
    * @return Continuous grid coordinates (may be fractional)
    */
-  [[nodiscard]] Vector3 worldToGrid(const Vector3& position) const;
+  template <typename InputScalar = Scalar>
+  [[nodiscard]] Eigen::Vector3<InputScalar> worldToGrid(
+      const Eigen::Vector3<InputScalar>& position) const;
 
   /**
    * Convert continuous grid coordinates to 3D world-space position.
@@ -124,7 +131,9 @@ class SignedDistanceField {
    * @param gridPos Continuous grid coordinates
    * @return 3D world-space position
    */
-  [[nodiscard]] Vector3 gridToWorld(const Vector3& gridPos) const;
+  template <typename InputScalar = Scalar>
+  [[nodiscard]] Eigen::Vector3<InputScalar> gridToWorld(
+      const Eigen::Vector3<InputScalar>& gridPos) const;
 
   /**
    * Get the world-space position of a grid cell center given discrete indices.
@@ -220,7 +229,9 @@ class SignedDistanceField {
    * @param gridPos Input grid coordinates
    * @return Clamped grid coordinates
    */
-  [[nodiscard]] Vector3 clampToGrid(const Vector3& gridPos) const;
+  template <typename InputScalar = Scalar>
+  [[nodiscard]] Eigen::Vector3<InputScalar> clampToGrid(
+      const Eigen::Vector3<InputScalar>& gridPos) const;
 
   BoundingBoxType bounds_;
   Eigen::Vector3<Index> resolution_;

include/axel/math/MeshHoleFilling.h

@@ -95,4 +95,23 @@ fillMeshHolesComplete(
     gsl::span<const Eigen::Vector3<ScalarType>> vertices,
     gsl::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(
+    gsl::span<const Eigen::Vector3<ScalarType>> vertices,
+    gsl::span<const FaceType> faces,
+    const std::vector<bool>& vertex_mask = {},
+    Index iterations = 1,
+    ScalarType step = ScalarType{0.5});
+
 } // namespace axel

include/momentum/character/fwd.h

@@ -221,6 +221,25 @@ using SkeletonStated_const_p = ::std::shared_ptr<const SkeletonStated>;
 using SkeletonStated_const_u = ::std::unique_ptr<const SkeletonStated>;
 using SkeletonStated_const_w = ::std::weak_ptr<const SkeletonStated>;
 
+template <typename T>
+struct MeshStateT;
+using MeshState = MeshStateT<float>;
+using MeshStated = MeshStateT<double>;
+
+using MeshState_p = ::std::shared_ptr<MeshState>;
+using MeshState_u = ::std::unique_ptr<MeshState>;
+using MeshState_w = ::std::weak_ptr<MeshState>;
+using MeshState_const_p = ::std::shared_ptr<const MeshState>;
+using MeshState_const_u = ::std::unique_ptr<const MeshState>;
+using MeshState_const_w = ::std::weak_ptr<const MeshState>;
+
+using MeshStated_p = ::std::shared_ptr<MeshStated>;
+using MeshStated_u = ::std::unique_ptr<MeshStated>;
+using MeshStated_w = ::std::weak_ptr<MeshStated>;
+using MeshStated_const_p = ::std::shared_ptr<const MeshStated>;
+using MeshStated_const_u = ::std::unique_ptr<const MeshStated>;
+using MeshStated_const_w = ::std::weak_ptr<const MeshStated>;
+
 template <typename T>
 struct TaperedCapsuleT;
 using TaperedCapsule = TaperedCapsuleT<float>;

include/momentum/character/mesh_state.h

@@ -0,0 +1,71 @@
+/*
+ * 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/character/fwd.h>
+#include <momentum/character/types.h>
+#include <momentum/math/mesh.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+/// Represents the complete state of a model's mesh
+///
+/// Stores the mesh in its various states throughout the deformation pipeline:
+/// - neutralMesh: Base mesh before any deformations
+/// - restMesh: Mesh after blend shapes/expressions are applied
+/// - posedMesh: Final mesh after skinning is applied
+template <typename T>
+struct MeshStateT {
+  std::unique_ptr<MeshT<T>>
+      neutralMesh_; // Rest mesh without facial expression basis,
+                    // used to restore the neutral shape after facial expressions are applied.
+                    // Not used with there is a shape basis.
+  std::unique_ptr<MeshT<T>> restMesh_; // The rest positions of the mesh after shape basis
+                                       // (and potentially facial expression) has been applied
+  std::unique_ptr<MeshT<T>>
+      posedMesh_; // The posed mesh after the skeleton transforms have been applied.
+
+  /// Creates an empty mesh state
+  MeshStateT() noexcept = default;
+  MeshStateT(
+      const ModelParametersT<T>& parameters,
+      const SkeletonStateT<T>& state,
+      const Character& character) noexcept;
+  ~MeshStateT() noexcept;
+
+  /// Copy constructor
+  MeshStateT(const MeshStateT& other);
+
+  /// Copy assignment operator
+  MeshStateT& operator=(const MeshStateT& other);
+
+  /// Move constructor
+  MeshStateT(MeshStateT&& other) noexcept = default;
+
+  /// Move assignment operator
+  MeshStateT& operator=(MeshStateT&& other) noexcept = default;
+
+  /// Updates the mesh state based on model parameters and skeleton state
+  ///
+  /// This applies the full deformation pipeline:
+  /// 1. Apply blend shapes to create rest mesh
+  /// 2. Apply face expression blend shapes
+  /// 3. Update normals
+  /// 4. Apply skinning to create posed mesh
+  ///
+  /// @param parameters Model parameters containing blend weights
+  /// @param state Current skeleton state for skinning
+  /// @param character Character containing mesh, blend shapes, and skinning data
+  void update(
+      const ModelParametersT<T>& parameters,
+      const SkeletonStateT<T>& state,
+      const Character& character);
+};
+
+} // namespace momentum

include/momentum/character_sequence_solver/model_parameters_sequence_error_function.h

@@ -25,10 +25,12 @@ class ModelParametersSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
 
   double getError(
       gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates) const final;
+      gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::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,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const final;
 
   // modelParameters: [numFrames() * parameterTransform] parameter vector
@@ -38,6 +40,7 @@ class ModelParametersSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   double getJacobian(
       gsl::span<const ModelParametersT<T>> modelParameters,
       gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::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.h

@@ -30,6 +30,7 @@ template <typename T>
 class MultiposeSolverT : public SolverT<T> {
  public:
   MultiposeSolverT(const SolverOptions& options, MultiposeSolverFunctionT<T>* function);
+  ~MultiposeSolverT() override;
 
   [[nodiscard]] std::string_view getName() const override;
 
@@ -56,6 +57,7 @@ class MultiposeSolverT : public SolverT<T> {
  private:
   Eigen::MatrixX<T> jacobianBlock_;
   Eigen::VectorX<T> residualBlock_;
+  std::unique_ptr<MeshStateT<T>> meshState_;
 
   float regularization_;
 };

include/momentum/character_sequence_solver/multipose_solver_function.h

@@ -24,6 +24,7 @@ class MultiposeSolverFunctionT : public SolverFunctionT<T> {
       const ParameterTransformT<T>* parameterTransform,
       gsl::span<const int> universal,
       size_t frames);
+  ~MultiposeSolverFunctionT() override;
 
   double getError(const Eigen::VectorX<T>& parameters) final;
 
@@ -62,7 +63,8 @@ class MultiposeSolverFunctionT : public SolverFunctionT<T> {
  private:
   const Skeleton* skeleton_;
   const ParameterTransformT<T>* parameterTransform_;
-  std::vector<std::unique_ptr<SkeletonStateT<T>>> states_;
+  std::vector<SkeletonStateT<T>> states_;
+  std::vector<MeshStateT<T>> meshStates_;
   VectorX<bool> activeJointParams_;
 
   std::vector<ModelParametersT<T>> frameParameters_;

include/momentum/character_sequence_solver/sequence_error_function.h

@@ -41,30 +41,39 @@ class SequenceErrorFunctionT {
     enabledParameters_ = ps;
   }
 
+  [[nodiscard]] virtual bool needsMesh() const {
+    return false;
+  }
+
   [[nodiscard]] virtual double getError(
       gsl::span<const ModelParametersT<T>> /* modelParameters */,
-      gsl::span<const SkeletonStateT<T>> /* skelStates */) const {
+      gsl::span<const SkeletonStateT<T>> /* skelStates */,
+      gsl::span<const MeshStateT<T>> /* meshStates */) const {
     return 0.0f;
   }
 
   // Get the gradient of the error.
   // modelParameters: numFrames() array of parameter vectors
   // skelStates: [numFrames()] array of skeleton states
+  // 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 */,
       Eigen::Ref<Eigen::VectorX<T>> /* gradient */) const {
     return 0.0f;
   }
 
   // modelParameters: [numFrames() * parameterTransform] parameter vector
   // skelStates: [numFrames()] array of skeleton states
+  // meshStates: [numFrames()] array of mesh states
   // 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 */,
       Eigen::Ref<Eigen::MatrixX<T>> /* jacobian */,
       Eigen::Ref<Eigen::VectorX<T>> /* residual */,
       int& usedRows) const {

include/momentum/character_sequence_solver/sequence_solver.h

@@ -132,10 +132,10 @@ class SequenceSolverT : public SolverT<T> {
       const SequenceSolverFunctionT<T>* fn,
       size_t bandwidth);
 
-  float regularization_;
-  bool doLineSearch_;
-  bool multithreaded_;
-  bool progressBar_;
+  float regularization_ = 0.05f;
+  bool doLineSearch_ = false;
+  bool multithreaded_ = false;
+  bool progressBar_ = false;
 
   // bandwidth in frames:
   size_t bandwidth_ = 0;

include/momentum/character_sequence_solver/sequence_solver_function.h

@@ -24,10 +24,11 @@ template <typename T>
 class SequenceSolverFunctionT : public SolverFunctionT<T> {
  public:
   SequenceSolverFunctionT(
-      const Skeleton* skel,
-      const ParameterTransformT<T>* parameterTransform,
+      const Character& character,
+      const ParameterTransformT<T>& parameterTransform,
       const ParameterSet& universal,
       size_t nFrames);
+  ~SequenceSolverFunctionT() override;
 
   double getError(const Eigen::VectorX<T>& parameters) final;
 
@@ -46,6 +47,10 @@ class SequenceSolverFunctionT : public SolverFunctionT<T> {
     return universalParameters_;
   }
 
+  [[nodiscard]] bool needsMesh() const {
+    return needsMesh_;
+  }
+
   // Passing in the special frame index kAllFrames will add the error function to every frame; this
   // is convenient for e.g. limit errors but requires that the error function be stateless. Note:
   // you are allowed to call this in a multithreaded context but you must ensure the frame indices
@@ -78,11 +83,11 @@ class SequenceSolverFunctionT : public SolverFunctionT<T> {
 
   void setJoinedParameterVector(const Eigen::VectorX<T>& joinedParameters);
 
-  [[nodiscard]] const Skeleton* getSkeleton() const {
-    return skeleton_;
-  }
+  [[nodiscard]] const Skeleton* getSkeleton() const;
+  [[nodiscard]] const Character& getCharacter() const;
+
   [[nodiscard]] const ParameterTransformT<T>* getParameterTransform() const {
-    return parameterTransform_;
+    return &parameterTransform_;
   }
 
   [[nodiscard]] const auto& getErrorFunctions(size_t iFrame) const {
@@ -97,9 +102,10 @@ class SequenceSolverFunctionT : public SolverFunctionT<T> {
   void setFrameParametersFromJoinedParameterVector(const Eigen::VectorX<T>& parameters);
 
  private:
-  const Skeleton* skeleton_;
-  const ParameterTransformT<T>* parameterTransform_;
+  const Character& character_;
+  const ParameterTransformT<T>& parameterTransform_;
   std::vector<SkeletonStateT<T>> states_;
+  std::vector<MeshStateT<T>> meshStates_;
   VectorX<bool> activeJointParams_;
 
   std::vector<ModelParametersT<T>> frameParameters_;
@@ -120,6 +126,8 @@ class SequenceSolverFunctionT : public SolverFunctionT<T> {
   std::atomic<size_t> numTotalPerFrameErrorFunctions_ = 0;
   std::atomic<size_t> numTotalSequenceErrorFunctions_ = 0;
 
+  bool needsMesh_ = false;
+
   friend class SequenceSolverT<T>;
 };
 

include/momentum/character_sequence_solver/state_sequence_error_function.h

@@ -29,10 +29,12 @@ class StateSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
 
   double getError(
       gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates) const final;
+      gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::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 */,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const final;
 
   // modelParameters: [numFrames() * parameterTransform] parameter vector
@@ -42,6 +44,7 @@ class StateSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   double getJacobian(
       gsl::span<const ModelParametersT<T>> modelParameters,
       gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::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

@@ -47,10 +47,12 @@ class VertexSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
 
   double getError(
       gsl::span<const ModelParametersT<T>> modelParameters,
-      gsl::span<const SkeletonStateT<T>> skelStates) const final;
+      gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::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,
       Eigen::Ref<Eigen::VectorX<T>> gradient) const final;
 
   // modelParameters: [numFrames() * parameterTransform] parameter vector
@@ -60,6 +62,7 @@ class VertexSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
   double getJacobian(
       gsl::span<const ModelParametersT<T>> modelParameters,
       gsl::span<const SkeletonStateT<T>> skelStates,
+      gsl::span<const MeshStateT<T>> meshStates,
       Eigen::Ref<Eigen::MatrixX<T>> jacobian,
       Eigen::Ref<Eigen::VectorX<T>> residual,
       int& usedRows) const final;

include/momentum/character_solver/collision_error_function.h

@@ -29,17 +29,21 @@ class CollisionErrorFunctionT : public SkeletonErrorFunctionT<T> {
 
   explicit CollisionErrorFunctionT(const Character& character);
 
-  [[nodiscard]] double getError(const ModelParametersT<T>& params, const SkeletonStateT<T>& state)
-      final;
+  [[nodiscard]] double getError(
+      const ModelParametersT<T>& params,
+      const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState) final;
 
   double getGradient(
       const ModelParametersT<T>& params,
       const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState,
       Ref<VectorX<T>> gradient) override;
 
   double getJacobian(
       const ModelParametersT<T>& /*unused*/,
       const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState,
       Ref<MatrixX<T>> jacobian,
       Ref<VectorX<T>> residual,
       int& usedRows) override;

include/momentum/character_solver/collision_error_function_stateless.h

@@ -32,17 +32,21 @@ class CollisionErrorFunctionStatelessT : public SkeletonErrorFunctionT<T> {
 
   explicit CollisionErrorFunctionStatelessT(const Character& character);
 
-  [[nodiscard]] double getError(const ModelParametersT<T>& params, const SkeletonStateT<T>& state)
-      final;
+  [[nodiscard]] double getError(
+      const ModelParametersT<T>& params,
+      const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState) final;
 
   double getGradient(
       const ModelParametersT<T>& params,
       const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState,
       Ref<VectorX<T>> gradient) override;
 
   double getJacobian(
       const ModelParametersT<T>& /*unused*/,
       const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState,
       Ref<MatrixX<T>> jacobian,
       Ref<VectorX<T>> residual,
       int& usedRows) override;

include/momentum/character_solver/constraint_error_function-inl.h

@@ -31,7 +31,8 @@ ConstraintErrorFunctionT<T, Data, FuncDim, NumVec, NumPos>::ConstraintErrorFunct
 template <typename T, class Data, size_t FuncDim, size_t NumVec, size_t NumPos>
 double ConstraintErrorFunctionT<T, Data, FuncDim, NumVec, NumPos>::getError(
     const ModelParametersT<T>& /* params */,
-    const SkeletonStateT<T>& state) {
+    const SkeletonStateT<T>& state,
+    const MeshStateT<T>& /* meshState */) {
   MT_PROFILE_FUNCTION();
 
   // loop over all constraints and calculate the error
@@ -172,6 +173,7 @@ template <typename T, class Data, size_t FuncDim, size_t NumVec, size_t NumPos>
 double ConstraintErrorFunctionT<T, Data, FuncDim, NumVec, NumPos>::getJacobian(
     const ModelParametersT<T>& /*params*/,
     const SkeletonStateT<T>& state,
+    const MeshStateT<T>& /* meshState */,
     Ref<Eigen::MatrixX<T>> jacobian,
     Ref<Eigen::VectorX<T>> residual,
     int& usedRows) {
@@ -298,6 +300,7 @@ template <typename T, class Data, size_t FuncDim, size_t NumVec, size_t NumPos>
 double ConstraintErrorFunctionT<T, Data, FuncDim, NumVec, NumPos>::getGradient(
     const ModelParametersT<T>& /*unused*/,
     const SkeletonStateT<T>& state,
+    const MeshStateT<T>& /* meshState */,
     Ref<Eigen::VectorX<T>> gradient) {
   MT_PROFILE_FUNCTION();
 

include/momentum/character_solver/constraint_error_function.h

@@ -116,22 +116,27 @@ class ConstraintErrorFunctionT : public SkeletonErrorFunctionT<T> {
   ///
   /// @param[in] params: current model parameters
   /// @param[in] state: curren global skeleton joint states computed from the model parameters
+  /// @param[in] meshState: current mesh state (unused by this base class)
   ///
   /// @return the error function value l
-  [[nodiscard]] double getError(const ModelParametersT<T>& params, const SkeletonStateT<T>& state)
-      final;
+  [[nodiscard]] double getError(
+      const ModelParametersT<T>& params,
+      const SkeletonStateT<T>& state,
+      const MeshStateT<T>& /* meshState */) final;
 
   /// The gradient of the error function: dl/dq = dl/d[f^2] * 2f * df/dv * dv/dq. It gets df/dv from
   /// the derived class, and implements the rest.
   ///
   /// @param[in] params: current model parameters
   /// @param[in] state: curren global skeleton joint states computed from the model parameters
+  /// @param[in] meshState: current mesh state (unused by this base class)
   /// @param[out] gradient: the gradient vector to accumulate into
   ///
   /// @return the error function value l
   double getGradient(
       const ModelParametersT<T>& params,
       const SkeletonStateT<T>& state,
+      const MeshStateT<T>& /* meshState */,
       Ref<VectorX<T>> gradient) final;
 
   /// For least-square problems, we assume l is the square of a vector function F. The jacobian is
@@ -142,6 +147,7 @@ class ConstraintErrorFunctionT : public SkeletonErrorFunctionT<T> {
   ///
   /// @param[in] params: current model parameters
   /// @param[in] state: curren global skeleton joint states computed from the model parameters
+  /// @param[in] meshState: current mesh state (unused by this base class)
   /// @param[out] jacobian: the output jacobian matrix
   /// @param[out] residual: the output function residual (ie. f scaled by the loss gradient)
   /// @param[out] usedRows: number of rows in the jacobian/residual used by this error function
@@ -150,6 +156,7 @@ class ConstraintErrorFunctionT : public SkeletonErrorFunctionT<T> {
   double getJacobian(
       const ModelParametersT<T>& params,
       const SkeletonStateT<T>& state,
+      const MeshStateT<T>& /* meshState */,
       Ref<MatrixX<T>> jacobian,
       Ref<VectorX<T>> residual,
       int& usedRows) final;

include/momentum/character_solver/distance_error_function.h

@@ -31,14 +31,17 @@ class DistanceErrorFunctionT : public momentum::SkeletonErrorFunctionT<T> {
 
   [[nodiscard]] double getError(
       const momentum::ModelParametersT<T>& params,
-      const momentum::SkeletonStateT<T>& state) final;
+      const momentum::SkeletonStateT<T>& state,
+      const momentum::MeshStateT<T>& meshState) final;
   double getGradient(
       const momentum::ModelParametersT<T>& params,
       const momentum::SkeletonStateT<T>& state,
+      const momentum::MeshStateT<T>& meshState,
       Eigen::Ref<Eigen::VectorX<T>> gradient) final;
   double getJacobian(
       const momentum::ModelParametersT<T>& params,
       const momentum::SkeletonStateT<T>& state,
+      const momentum::MeshStateT<T>& meshState,
       Eigen::Ref<Eigen::MatrixX<T>> jacobian,
       Eigen::Ref<Eigen::VectorX<T>> residual,
       int& usedRows) final;

include/momentum/character_solver/gauss_newton_solver_qr.h

@@ -38,6 +38,7 @@ template <typename T>
 class GaussNewtonSolverQRT : public SolverT<T> {
  public:
   GaussNewtonSolverQRT(const SolverOptions& options, SkeletonSolverFunctionT<T>* solver);
+  ~GaussNewtonSolverQRT() override;
 
   [[nodiscard]] std::string_view getName() const override;
 
@@ -49,6 +50,7 @@ class GaussNewtonSolverQRT : public SolverT<T> {
 
  private:
   std::unique_ptr<SkeletonStateT<T>> skeletonState_;
+  std::unique_ptr<MeshStateT<T>> meshState_;
 
   ResizeableMatrix<T> jacobian_;
   ResizeableMatrix<T> residual_;