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

include/momentum/character/skin_weights.h

@@ -0,0 +1,67 @@
+/*
+ * 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/types.h>
+#include <momentum/math/types.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace momentum {
+
+/// Maximum number of joints that can influence a single vertex
+inline static constexpr uint32_t kMaxSkinJoints = 8;
+
+/// Matrix type for storing joint indices that influence each vertex
+///
+/// Each row represents a vertex, and each column represents a joint influence.
+/// The matrix has a fixed number of columns (kMaxSkinJoints) and a dynamic number of rows.
+using IndexMatrix =
+    Eigen::Matrix<uint32_t, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign | Eigen::RowMajor>;
+
+/// Matrix type for storing weights of joint influences on each vertex
+///
+/// Each row represents a vertex, and each column represents the weight of a joint influence.
+/// The matrix has a fixed number of columns (kMaxSkinJoints) and a dynamic number of rows.
+using WeightMatrix =
+    Eigen::Matrix<float, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign | Eigen::RowMajor>;
+
+/// Stores skinning weights and joint indices for character mesh deformation
+struct SkinWeights {
+  /// Joint indices that influence each vertex
+  ///
+  /// Each row corresponds to a vertex, and each column contains the index of a joint
+  /// that influences that vertex. Unused influences are set to 0.
+  IndexMatrix index;
+
+  /// Weight of each joint's influence on each vertex
+  ///
+  /// Each row corresponds to a vertex, and each column contains the weight of a joint's
+  /// influence on that vertex. Weights for a vertex typically sum to 1.0. Unused influences
+  /// are set to 0.0.
+  WeightMatrix weight;
+
+  /// Sets the skin weights from vectors of joint indices and weights
+  ///
+  /// @param ind Vector of vectors containing joint indices for each vertex
+  /// @param wgt Vector of vectors containing weights for each vertex
+  /// @throws If ind.size() != wgt.size() (via MT_CHECK)
+  void set(const std::vector<std::vector<size_t>>& ind, const std::vector<std::vector<float>>& wgt);
+
+  /// Compares two SkinWeights objects for equality
+  ///
+  /// Two SkinWeights objects are considered equal if their index and weight matrices
+  /// are approximately equal (using Eigen's isApprox method).
+  ///
+  /// @param skinWeights The SkinWeights object to compare with
+  /// @return True if the objects are equal, false otherwise
+  bool operator==(const SkinWeights& skinWeights) const;
+};
+
+} // namespace momentum

include/momentum/character/skinned_locator.h

@@ -0,0 +1,80 @@
+/*
+ * 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/skin_weights.h>
+#include <momentum/character/types.h>
+#include <momentum/math/utility.h>
+
+namespace momentum {
+
+/// A skinned locator is a locator which can be attached to multiple bones.
+/// The locator's position is defined relative to the rest pose of the character (and not
+/// local to a single parent bone as with a regular Locator) and its position at runtime is
+/// determined by blending the skinning transforms (using LBS).
+///
+/// The purpose of the SkinnedLocator is to model mocap markers attached to the actor's skin:
+/// the location of points on e.g. the shoulder is more accurately modeled by blending
+/// multiple transforms.  In addition, the locator can be constrained to slide along the
+/// surface of the mesh using e.g. the SkinnedLocatorTriangleErrorFunction.
+///
+/// Locators can be used for various purposes such as tracking specific points
+/// on a character, defining constraints, or serving as targets for inverse kinematics.
+struct SkinnedLocator {
+  /// Name identifier for the locator
+  std::string name;
+
+  /// Index of the parent joints in the skeleton.  The final position of the locator
+  /// is determined by blending the transforms from each (valid) parent.
+  Eigen::Matrix<uint32_t, kMaxSkinJoints, 1> parents;
+
+  /// Skinning weight for each parent joint.
+  Eigen::Matrix<float, kMaxSkinJoints, 1> skinWeights;
+
+  /// Position relative to rest pose of the character
+  Vector3f position;
+
+  /// Influence weight of this locator when used in constraints
+  float weight;
+
+  /// Creates a locator with the specified properties
+  ///
+  /// @param name Identifier for the locator
+  /// @param parents Indices of the parent joints
+  /// @param weights Skinning weights for the parent joints
+  /// @param weight Influence weight in constraints
+  SkinnedLocator(
+      const std::string& name = "uninitialized",
+      const Eigen::Matrix<uint32_t, kMaxSkinJoints, 1>& parents =
+          Eigen::Matrix<uint32_t, kMaxSkinJoints, 1>::Zero(),
+      const Eigen::Matrix<float, kMaxSkinJoints, 1>& skinWeights =
+          Eigen::Matrix<float, kMaxSkinJoints, 1>::Zero(),
+      const Vector3f& position = Vector3f::Zero(),
+      const float weight = 1.0f)
+      : name(name),
+        parents(parents),
+        skinWeights(skinWeights),
+        position(position),
+        weight(weight) {}
+
+  /// Compares two locators for equality, using approximate comparison for floating-point values
+  ///
+  /// @param locator The locator to compare with
+  /// @return True if all properties are equal (or approximately equal for floating-point values)
+  inline bool operator==(const SkinnedLocator& locator) const {
+    return (
+        (name == locator.name) && (parents == locator.parents) &&
+        skinWeights.isApprox(locator.skinWeights) && position.isApprox(locator.position) &&
+        isApprox(weight, locator.weight));
+  }
+};
+
+/// A collection of locators attached to a skeleton
+using SkinnedLocatorList = std::vector<SkinnedLocator>;
+
+} // namespace momentum

include/momentum/character/types.h

@@ -0,0 +1,202 @@
+/*
+ * 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
+
+//------------------------------------------------------------------------------
+// Momentum specific Eigen defines
+//------------------------------------------------------------------------------
+
+#include <momentum/character/fwd.h>
+
+#include <Eigen/Dense>
+
+#include <array>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace momentum {
+
+inline constexpr size_t kParametersPerJoint = 7;
+enum JointParameterNames { TX = 0, TY, TZ, RX, RY, RZ, SC };
+inline constexpr std::array<const char*, kParametersPerJoint>
+    kJointParameterNames{"tx", "ty", "tz", "rx", "ry", "rz", "sc"};
+
+template <typename T>
+using JointVectorT = Eigen::Matrix<T, kParametersPerJoint, 1>;
+using JointVector = JointVectorT<float>;
+
+template <template <typename> typename Derived, typename EigenType>
+struct EigenStrongType {
+  using Scalar = typename EigenType::Scalar;
+
+  EigenType v;
+
+  EigenStrongType() : v() {}
+
+  explicit EigenStrongType(::Eigen::Index size) : v(size) {}
+
+  template <typename Other>
+  /* implicit */ EigenStrongType(const ::Eigen::EigenBase<Other>& o) : v(o) {}
+
+  template <typename Other>
+  /* implicit */ EigenStrongType(::Eigen::EigenBase<Other>&& o) : v(std::move(o)) {}
+
+  template <typename Other>
+  EigenStrongType& operator=(const ::Eigen::EigenBase<Other>& o) {
+    v = o;
+    return *this;
+  }
+
+  template <typename Other>
+  EigenStrongType& operator=(::Eigen::EigenBase<Other>&& o) {
+    v = std::move(o);
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  auto&& operator()(::Eigen::Index i) {
+    return v(i);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  auto&& operator()(::Eigen::Index i) const {
+    return v(i);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  auto&& operator[](::Eigen::Index i) {
+    return v[i];
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  auto&& operator[](::Eigen::Index i) const {
+    return v[i];
+  }
+
+  template <typename NewScalar>
+  [[nodiscard]] EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived<NewScalar> cast() const {
+    return v.template cast<NewScalar>();
+  }
+
+  [[nodiscard]] EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto size() const {
+    return v.size();
+  }
+
+  EIGEN_DEVICE_FUNC
+  static Derived<Scalar> Zero(::Eigen::Index size) {
+    return Derived<Scalar>(EigenType::Zero(size));
+  }
+};
+
+// a vector describing model parameters
+template <typename T>
+struct ModelParametersT : public EigenStrongType<ModelParametersT, ::Eigen::VectorX<T>> {
+  using t = ::Eigen::VectorX<T>;
+  using EigenStrongType<ModelParametersT, t>::EigenStrongType;
+  using EigenStrongType<ModelParametersT, t>::operator=;
+};
+
+using ModelParameters = ModelParametersT<float>;
+using ModelParametersd = ModelParametersT<double>;
+
+template <typename T>
+struct BlendWeightsT : public EigenStrongType<BlendWeightsT, ::Eigen::VectorX<T>> {
+  using t = ::Eigen::VectorX<T>;
+  using EigenStrongType<BlendWeightsT, t>::EigenStrongType;
+  using EigenStrongType<BlendWeightsT, t>::operator=;
+};
+
+using BlendWeights = BlendWeightsT<float>;
+using BlendWeightsd = BlendWeightsT<double>;
+
+static_assert(
+    sizeof(BlendWeights) == sizeof(Eigen::VectorXf),
+    "Missing Empty Base Class Optimization");
+static_assert(
+    sizeof(BlendWeightsd) == sizeof(Eigen::VectorXd),
+    "Missing Empty Base Class Optimization");
+
+// A vector describing joint parameters, the vector has size numSkeletonJoints * kParametersPerJoint
+// e.g. in case of a character body model with 159 joints, the joint parameters vector will have the
+// size 159 * 7 = 1113
+template <typename T>
+struct JointParametersT : public EigenStrongType<JointParametersT, ::Eigen::VectorX<T>> {
+  using t = ::Eigen::VectorX<T>;
+  using EigenStrongType<JointParametersT, t>::EigenStrongType;
+  using EigenStrongType<JointParametersT, t>::operator=;
+
+  [[nodiscard]] static ::Eigen::Vector3<T> fromRotationMatrix(const ::Eigen::Matrix3<T>& m) {
+    // From JointState::set(), we can see that localRotation = rz * ry * rx, but the order in
+    // JointParameters is [rx, ry, rz]. Therefore, the conversion should be
+    // rotationMatrixToEulerZYX.reverse.
+    return rotationMatrixToEulerZYX(m).reverse();
+  }
+
+  [[nodiscard]] static ::Eigen::Vector3<T> fromQuaternion(const ::Eigen::Quaternion<T>& q) {
+    return fromRotationMatrix(q.toRotationMatrix());
+  }
+};
+
+using JointParameters = JointParametersT<float>;
+using JointParametersd = JointParametersT<double>;
+
+static_assert(
+    sizeof(JointParameters) == sizeof(Eigen::VectorXf),
+    "Missing Empty Base Class Optimization");
+static_assert(
+    sizeof(JointParametersd) == sizeof(Eigen::VectorXd),
+    "Missing Empty Base Class Optimization");
+
+template <typename T>
+using JointStateListT = std::vector<JointStateT<T>>;
+
+using JointStateList = JointStateListT<float>;
+using JointStateListd = JointStateListT<double>;
+
+/// A struct that encapsulates both pose and identity parameters for a character.
+///
+/// @note This structure implies, but does not enforce, that the pose vector should contain only
+/// pose information with identity-related elements set to zero. Similarly, the identity vector
+/// should exclusively contain bone length information, excluding any pose data.
+template <typename T>
+struct CharacterParametersT {
+  /// The model parameter vector representing the pose of the character. This vector should have a
+  /// size of numModelParams.
+
+  ModelParametersT<T> pose;
+  /// The joint parameter vector representing the unique bone lengths of the character, defining
+  /// the character's identity. This vector should have a size of numSkeletonJoints *
+  /// kParametersPerJoint.
+  JointParametersT<T> offsets;
+};
+
+using CharacterParameters = CharacterParametersT<float>;
+using CharacterParametersd = CharacterParametersT<double>;
+
+// The tuple of model parameter names and corresponding matrix representing the pose in a sequence
+// of frames The poses are ordered in columns and the expected shape of motion matrix is
+// (numModelParams, numFrames)
+
+using MotionParameters = std::tuple<std::vector<std::string>, Eigen::MatrixXf>;
+
+// The tuple containing the skeleton joint names and identity parameters. The identity parameters
+// represent bone offsets and bone scales that are added to the joint states (local transform for
+// each joint wrt parent joint) during FK step The identity parameters are expressed as a vector of
+// size (numSkeletonJoints * momentum::kParametersPerJoint)
+
+using IdentityParameters = std::tuple<std::vector<std::string>, Eigen::VectorXf>;
+
+// define static kInvalidIndex for size_t
+inline constexpr size_t kInvalidIndex = std::numeric_limits<size_t>::max();
+
+} // namespace momentum

include/momentum/character_sequence_solver/fwd.h

@@ -0,0 +1,200 @@
+/*
+ * 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.
+ */
+
+// This file is @generated by gen_fwd.py
+// Do not edit this file directly, instead update gen_fwd_input.toml and run:
+// buck run @arvr/mode/platform010/opt //arvr/libraries/momentum:gen_fwd
+
+#pragma once
+
+#include <memory>
+
+namespace momentum {
+
+struct MultiposeSolverOptions;
+
+using MultiposeSolverOptions_p = ::std::shared_ptr<MultiposeSolverOptions>;
+using MultiposeSolverOptions_u = ::std::unique_ptr<MultiposeSolverOptions>;
+using MultiposeSolverOptions_w = ::std::weak_ptr<MultiposeSolverOptions>;
+using MultiposeSolverOptions_const_p = ::std::shared_ptr<const MultiposeSolverOptions>;
+using MultiposeSolverOptions_const_u = ::std::unique_ptr<const MultiposeSolverOptions>;
+using MultiposeSolverOptions_const_w = ::std::weak_ptr<const MultiposeSolverOptions>;
+
+struct SequenceSolverOptions;
+
+using SequenceSolverOptions_p = ::std::shared_ptr<SequenceSolverOptions>;
+using SequenceSolverOptions_u = ::std::unique_ptr<SequenceSolverOptions>;
+using SequenceSolverOptions_w = ::std::weak_ptr<SequenceSolverOptions>;
+using SequenceSolverOptions_const_p = ::std::shared_ptr<const SequenceSolverOptions>;
+using SequenceSolverOptions_const_u = ::std::unique_ptr<const SequenceSolverOptions>;
+using SequenceSolverOptions_const_w = ::std::weak_ptr<const SequenceSolverOptions>;
+
+template <typename T>
+class SequenceErrorFunctionT;
+using SequenceErrorFunction = SequenceErrorFunctionT<float>;
+using SequenceErrorFunctiond = SequenceErrorFunctionT<double>;
+
+using SequenceErrorFunction_p = ::std::shared_ptr<SequenceErrorFunction>;
+using SequenceErrorFunction_u = ::std::unique_ptr<SequenceErrorFunction>;
+using SequenceErrorFunction_w = ::std::weak_ptr<SequenceErrorFunction>;
+using SequenceErrorFunction_const_p = ::std::shared_ptr<const SequenceErrorFunction>;
+using SequenceErrorFunction_const_u = ::std::unique_ptr<const SequenceErrorFunction>;
+using SequenceErrorFunction_const_w = ::std::weak_ptr<const SequenceErrorFunction>;
+
+using SequenceErrorFunctiond_p = ::std::shared_ptr<SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_u = ::std::unique_ptr<SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_w = ::std::weak_ptr<SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_const_p = ::std::shared_ptr<const SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_const_u = ::std::unique_ptr<const SequenceErrorFunctiond>;
+using SequenceErrorFunctiond_const_w = ::std::weak_ptr<const SequenceErrorFunctiond>;
+
+template <typename T>
+class ModelParametersSequenceErrorFunctionT;
+using ModelParametersSequenceErrorFunction = ModelParametersSequenceErrorFunctionT<float>;
+using ModelParametersSequenceErrorFunctiond = ModelParametersSequenceErrorFunctionT<double>;
+
+using ModelParametersSequenceErrorFunction_p =
+    ::std::shared_ptr<ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_u =
+    ::std::unique_ptr<ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_w =
+    ::std::weak_ptr<ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_const_p =
+    ::std::shared_ptr<const ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_const_u =
+    ::std::unique_ptr<const ModelParametersSequenceErrorFunction>;
+using ModelParametersSequenceErrorFunction_const_w =
+    ::std::weak_ptr<const ModelParametersSequenceErrorFunction>;
+
+using ModelParametersSequenceErrorFunctiond_p =
+    ::std::shared_ptr<ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_u =
+    ::std::unique_ptr<ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_w =
+    ::std::weak_ptr<ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_const_p =
+    ::std::shared_ptr<const ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_const_u =
+    ::std::unique_ptr<const ModelParametersSequenceErrorFunctiond>;
+using ModelParametersSequenceErrorFunctiond_const_w =
+    ::std::weak_ptr<const ModelParametersSequenceErrorFunctiond>;
+
+template <typename T>
+class MultiposeSolverT;
+using MultiposeSolver = MultiposeSolverT<float>;
+using MultiposeSolverd = MultiposeSolverT<double>;
+
+using MultiposeSolver_p = ::std::shared_ptr<MultiposeSolver>;
+using MultiposeSolver_u = ::std::unique_ptr<MultiposeSolver>;
+using MultiposeSolver_w = ::std::weak_ptr<MultiposeSolver>;
+using MultiposeSolver_const_p = ::std::shared_ptr<const MultiposeSolver>;
+using MultiposeSolver_const_u = ::std::unique_ptr<const MultiposeSolver>;
+using MultiposeSolver_const_w = ::std::weak_ptr<const MultiposeSolver>;
+
+using MultiposeSolverd_p = ::std::shared_ptr<MultiposeSolverd>;
+using MultiposeSolverd_u = ::std::unique_ptr<MultiposeSolverd>;
+using MultiposeSolverd_w = ::std::weak_ptr<MultiposeSolverd>;
+using MultiposeSolverd_const_p = ::std::shared_ptr<const MultiposeSolverd>;
+using MultiposeSolverd_const_u = ::std::unique_ptr<const MultiposeSolverd>;
+using MultiposeSolverd_const_w = ::std::weak_ptr<const MultiposeSolverd>;
+
+template <typename T>
+class MultiposeSolverFunctionT;
+using MultiposeSolverFunction = MultiposeSolverFunctionT<float>;
+using MultiposeSolverFunctiond = MultiposeSolverFunctionT<double>;
+
+using MultiposeSolverFunction_p = ::std::shared_ptr<MultiposeSolverFunction>;
+using MultiposeSolverFunction_u = ::std::unique_ptr<MultiposeSolverFunction>;
+using MultiposeSolverFunction_w = ::std::weak_ptr<MultiposeSolverFunction>;
+using MultiposeSolverFunction_const_p = ::std::shared_ptr<const MultiposeSolverFunction>;
+using MultiposeSolverFunction_const_u = ::std::unique_ptr<const MultiposeSolverFunction>;
+using MultiposeSolverFunction_const_w = ::std::weak_ptr<const MultiposeSolverFunction>;
+
+using MultiposeSolverFunctiond_p = ::std::shared_ptr<MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_u = ::std::unique_ptr<MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_w = ::std::weak_ptr<MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_const_p = ::std::shared_ptr<const MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_const_u = ::std::unique_ptr<const MultiposeSolverFunctiond>;
+using MultiposeSolverFunctiond_const_w = ::std::weak_ptr<const MultiposeSolverFunctiond>;
+
+template <typename T>
+class SequenceSolverT;
+using SequenceSolver = SequenceSolverT<float>;
+using SequenceSolverd = SequenceSolverT<double>;
+
+using SequenceSolver_p = ::std::shared_ptr<SequenceSolver>;
+using SequenceSolver_u = ::std::unique_ptr<SequenceSolver>;
+using SequenceSolver_w = ::std::weak_ptr<SequenceSolver>;
+using SequenceSolver_const_p = ::std::shared_ptr<const SequenceSolver>;
+using SequenceSolver_const_u = ::std::unique_ptr<const SequenceSolver>;
+using SequenceSolver_const_w = ::std::weak_ptr<const SequenceSolver>;
+
+using SequenceSolverd_p = ::std::shared_ptr<SequenceSolverd>;
+using SequenceSolverd_u = ::std::unique_ptr<SequenceSolverd>;
+using SequenceSolverd_w = ::std::weak_ptr<SequenceSolverd>;
+using SequenceSolverd_const_p = ::std::shared_ptr<const SequenceSolverd>;
+using SequenceSolverd_const_u = ::std::unique_ptr<const SequenceSolverd>;
+using SequenceSolverd_const_w = ::std::weak_ptr<const SequenceSolverd>;
+
+template <typename T>
+class SequenceSolverFunctionT;
+using SequenceSolverFunction = SequenceSolverFunctionT<float>;
+using SequenceSolverFunctiond = SequenceSolverFunctionT<double>;
+
+using SequenceSolverFunction_p = ::std::shared_ptr<SequenceSolverFunction>;
+using SequenceSolverFunction_u = ::std::unique_ptr<SequenceSolverFunction>;
+using SequenceSolverFunction_w = ::std::weak_ptr<SequenceSolverFunction>;
+using SequenceSolverFunction_const_p = ::std::shared_ptr<const SequenceSolverFunction>;
+using SequenceSolverFunction_const_u = ::std::unique_ptr<const SequenceSolverFunction>;
+using SequenceSolverFunction_const_w = ::std::weak_ptr<const SequenceSolverFunction>;
+
+using SequenceSolverFunctiond_p = ::std::shared_ptr<SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_u = ::std::unique_ptr<SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_w = ::std::weak_ptr<SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_const_p = ::std::shared_ptr<const SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_const_u = ::std::unique_ptr<const SequenceSolverFunctiond>;
+using SequenceSolverFunctiond_const_w = ::std::weak_ptr<const SequenceSolverFunctiond>;
+
+template <typename T>
+class StateSequenceErrorFunctionT;
+using StateSequenceErrorFunction = StateSequenceErrorFunctionT<float>;
+using StateSequenceErrorFunctiond = StateSequenceErrorFunctionT<double>;
+
+using StateSequenceErrorFunction_p = ::std::shared_ptr<StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_u = ::std::unique_ptr<StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_w = ::std::weak_ptr<StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_const_p = ::std::shared_ptr<const StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_const_u = ::std::unique_ptr<const StateSequenceErrorFunction>;
+using StateSequenceErrorFunction_const_w = ::std::weak_ptr<const StateSequenceErrorFunction>;
+
+using StateSequenceErrorFunctiond_p = ::std::shared_ptr<StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_u = ::std::unique_ptr<StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_w = ::std::weak_ptr<StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_const_p = ::std::shared_ptr<const StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_const_u = ::std::unique_ptr<const StateSequenceErrorFunctiond>;
+using StateSequenceErrorFunctiond_const_w = ::std::weak_ptr<const StateSequenceErrorFunctiond>;
+
+template <typename T>
+class VertexSequenceErrorFunctionT;
+using VertexSequenceErrorFunction = VertexSequenceErrorFunctionT<float>;
+using VertexSequenceErrorFunctiond = VertexSequenceErrorFunctionT<double>;
+
+using VertexSequenceErrorFunction_p = ::std::shared_ptr<VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_u = ::std::unique_ptr<VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_w = ::std::weak_ptr<VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_const_p = ::std::shared_ptr<const VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_const_u = ::std::unique_ptr<const VertexSequenceErrorFunction>;
+using VertexSequenceErrorFunction_const_w = ::std::weak_ptr<const VertexSequenceErrorFunction>;
+
+using VertexSequenceErrorFunctiond_p = ::std::shared_ptr<VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_u = ::std::unique_ptr<VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_w = ::std::weak_ptr<VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_const_p = ::std::shared_ptr<const VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_const_u = ::std::unique_ptr<const VertexSequenceErrorFunctiond>;
+using VertexSequenceErrorFunctiond_const_w = ::std::weak_ptr<const VertexSequenceErrorFunctiond>;
+
+} // namespace momentum

include/momentum/character_sequence_solver/model_parameters_sequence_error_function.h

@@ -0,0 +1,65 @@
+/*
+ * 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/skeleton_state.h>
+#include <momentum/character_sequence_solver/fwd.h>
+#include <momentum/character_sequence_solver/sequence_error_function.h>
+
+namespace momentum {
+
+template <typename T>
+class ModelParametersSequenceErrorFunctionT : public SequenceErrorFunctionT<T> {
+ public:
+  ModelParametersSequenceErrorFunctionT(const Skeleton& skel, const ParameterTransform& pt);
+  explicit ModelParametersSequenceErrorFunctionT(const Character& character);
+
+  [[nodiscard]] size_t numFrames() const final {
+    return 2;
+  }
+
+  double getError(
+      std::span<const ModelParametersT<T>> modelParameters,
+      std::span<const SkeletonStateT<T>> skelStates,
+      std::span<const MeshStateT<T>> meshStates) const final;
+  double getGradient(
+      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
+  // skelStates: [numFrames()] array of skeleton states
+  // jacobian: [getJacobianSize()] x [numFrames() * parameterTransform] Jacobian matrix
+  // residual: [getJacobianSize()] residual vector.
+  double getJacobian(
+      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;
+
+  [[nodiscard]] size_t getJacobianSize() const final;
+
+  void setTargetWeights(const Eigen::VectorX<T>& weights) {
+    this->targetWeights_ = weights;
+  }
+
+  [[nodiscard]] const Eigen::VectorX<T>& getTargetWeights() const {
+    return this->targetWeights_;
+  }
+
+ private:
+  Eigen::VectorX<T> targetWeights_;
+
+ public:
+  static constexpr T kMotionWeight = 1e-1;
+};
+
+} // namespace momentum

include/momentum/character_sequence_solver/multipose_solver.h

@@ -0,0 +1,65 @@
+/*
+ * 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_sequence_solver/fwd.h>
+#include <momentum/character_sequence_solver/multipose_solver_function.h>
+#include <momentum/solver/solver.h>
+
+namespace momentum {
+
+/// Multipose solver specific options.
+struct MultiposeSolverOptions : SolverOptions {
+  /// Regularization parameter for QR decomposition.
+  float regularization = 0.05f;
+
+  MultiposeSolverOptions() = default;
+
+  /* implicit */ MultiposeSolverOptions(const SolverOptions& baseOptions)
+      : SolverOptions(baseOptions) {
+    // Empty
+  }
+};
+
+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;
+
+  void setOptions(const SolverOptions& options) final;
+
+  void iter() {
+    doIteration();
+    this->iteration_++;
+  }
+
+  void init() {
+    this->iteration_ = 0;
+    initializeSolver();
+  }
+
+  Eigen::VectorX<T> getP() {
+    return this->parameters_;
+  }
+
+ protected:
+  void doIteration() final;
+  void initializeSolver() final;
+
+ private:
+  Eigen::MatrixX<T> jacobianBlock_;
+  Eigen::VectorX<T> residualBlock_;
+  std::unique_ptr<MeshStateT<T>> meshState_;
+
+  float regularization_;
+};
+
+} // namespace momentum