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

include/axel/math/RayTriangleIntersection.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <Eigen/Core>
+
+namespace axel {
+
+template <typename T>
+bool rayTriangleIntersect(
+    const Eigen::Vector3<T>& beginRay,
+    const Eigen::Vector3<T>& direction,
+    const Eigen::Vector3<T>& p0,
+    const Eigen::Vector3<T>& p1,
+    const Eigen::Vector3<T>& p2,
+    Eigen::Vector3<T>& intersectionPoint,
+    T& tOut);
+
+template <typename T>
+bool rayTriangleIntersect(
+    const Eigen::Vector3<T>& beginRay,
+    const Eigen::Vector3<T>& direction,
+    const Eigen::Vector3<T>& p0,
+    const Eigen::Vector3<T>& p1,
+    const Eigen::Vector3<T>& p2,
+    Eigen::Vector3<T>& intersectionPoint,
+    T& tOut,
+    T& u,
+    T& v);
+
+} // namespace axel

include/momentum/character/blend_shape.h

@@ -0,0 +1,91 @@
+/*
+ * 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/blend_shape_base.h>
+
+namespace momentum {
+
+/// Skinning class that combines blend shape vectors with a base shape
+///
+/// Extends BlendShapeBase by adding a base shape (e.g., PCA mean) and
+/// functionality for computing deformed shapes and estimating blend coefficients.
+/// Primarily used to model identity-dependent shape deformations.
+struct BlendShape : public BlendShapeBase {
+ public:
+  BlendShape() : factorizationValid_(false) {}
+
+  /// @param baseShape Base shape vertices
+  /// @param numShapes Number of blend shapes
+  BlendShape(gsl::span<const Vector3f> baseShape, size_t numShapes);
+
+  void setBaseShape(gsl::span<const Vector3f> baseShape) {
+    baseShape_.assign(baseShape.begin(), baseShape.end());
+  }
+
+  [[nodiscard]] const std::vector<Vector3f>& getBaseShape() const {
+    return baseShape_;
+  }
+
+  /// Whether SVD factorization is up-to-date
+  [[nodiscard]] bool getFactorizationValid() const {
+    return factorizationValid_;
+  }
+
+  /// Applies blend weights to create a deformed shape
+  ///
+  /// Adds weighted shape vectors to the base shape
+  ///
+  /// @tparam T Scalar type (float or double)
+  /// @param coefficients Weights for each shape vector
+  /// @return Resulting deformed shape
+  template <typename T>
+  [[nodiscard]] std::vector<Eigen::Vector3<T>> computeShape(
+      const BlendWeightsT<T>& coefficients) const;
+
+  /// Output parameter version of computeShape
+  ///
+  /// @tparam T Scalar type (float or double)
+  /// @param coefficients Weights for each shape vector
+  /// @param result [out] Resulting deformed shape
+  template <typename T>
+  void computeShape(const BlendWeightsT<T>& coefficients, std::vector<Eigen::Vector3<T>>& result)
+      const;
+
+  /// Solves for blend weights that best approximate a target shape
+  ///
+  /// Uses SVD to find optimal coefficients with optional regularization
+  /// and per-vertex weighting
+  ///
+  /// @param vertices Target shape to approximate
+  /// @param regularization Higher values produce smaller coefficients
+  /// @param weights Optional per-vertex importance weights
+  /// @return Estimated blend shape coefficients
+  [[nodiscard]] VectorXf estimateCoefficients(
+      gsl::span<const Vector3f> vertices,
+      float regularization = 1.0f,
+      const VectorXf& weights = VectorXf()) const;
+
+  /// Overrides base method to also invalidate factorization
+  ///
+  /// @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);
+
+  /// Compares all components of two blend shapes
+  ///
+  /// @param blendShape Other blend shape to compare with
+  [[nodiscard]] bool isApprox(const BlendShape& blendShape) const;
+
+ private:
+  std::vector<Vector3f> baseShape_;
+  mutable Eigen::JacobiSVD<MatrixXf> factorization_;
+  mutable bool factorizationValid_;
+};
+
+} // namespace momentum

include/momentum/character/blend_shape_base.h

@@ -0,0 +1,70 @@
+/*
+ * 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>
+
+namespace momentum {
+
+/// Skinning class that manages blend shape vectors/offsets
+///
+/// Used to model facial expressions and potentially other deformations
+/// such as pose-dependent shape changes
+struct BlendShapeBase {
+ public:
+  BlendShapeBase() = default;
+
+  /// @param modelSize Number of vertices in the model
+  /// @param numShapes Number of blend shapes
+  BlendShapeBase(size_t modelSize, size_t numShapes);
+
+  /// @param shapeVectors Matrix where each column is a shape vector
+  void setShapeVectors(const MatrixXf& shapeVectors) {
+    shapeVectors_ = shapeVectors;
+  }
+
+  [[nodiscard]] const MatrixXf& getShapeVectors() const {
+    return shapeVectors_;
+  }
+
+  /// Calculates weighted combination of shape vectors
+  ///
+  /// @tparam T Scalar type (float or double)
+  /// @param blendWeights Weights for each shape vector
+  /// @return Combined vertex offsets
+  template <typename T>
+  [[nodiscard]] VectorX<T> computeDeltas(const BlendWeightsT<T>& blendWeights) const;
+
+  /// Adds weighted shape vectors to existing vertices
+  ///
+  /// @tparam T Scalar type (float or double)
+  /// @param blendWeights Weights for each shape vector
+  /// @param result [in,out] Vertices to modify
+  template <typename T>
+  void applyDeltas(const BlendWeightsT<T>& blendWeights, std::vector<Eigen::Vector3<T>>& result)
+      const;
+
+  /// @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);
+
+  [[nodiscard]] Eigen::Index shapeSize() const {
+    return shapeVectors_.cols();
+  }
+
+  /// Returns number of vertices (rows/3)
+  [[nodiscard]] size_t modelSize() const {
+    return shapeVectors_.rows() / 3;
+  }
+
+ protected:
+  MatrixXf shapeVectors_;
+};
+
+} // namespace momentum

include/momentum/character/blend_shape_skinning.h

@@ -0,0 +1,96 @@
+/*
+ * 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/fwd.h>
+
+namespace momentum {
+
+/// @file blend_shape_skinning.h
+///
+/// This file provides functions for applying blend shape deformations and skeletal transformations
+/// to character meshes. It contains two main sets of functionality:
+///
+/// 1. Skinning functions:
+///    - skinWithBlendShapes(character, state, blendWeights, outputMesh): Use when you already have
+///      blend weights calculated and want to apply them directly.
+///    - skinWithBlendShapes(character, state, modelParams, outputMesh): Use when you have model
+///      parameters and need to extract blend weights before skinning. This is more convenient for
+///      high-level character animation where you work with model parameters.
+///
+/// 2. Weight extraction functions:
+///    - extractBlendWeights(): Use to get blend shape weights from model parameters for
+///    identity/shape
+///      blend shapes (e.g., body shape variations).
+///    - extractFaceExpressionBlendWeights(): Use to get blend shape weights specifically for facial
+///      expressions, which are stored separately from regular blend shapes.
+
+/// Applies blend shape deformations and skeletal transformations to a mesh.
+///
+/// Computes the final vertex positions by applying blend shape offsets to the base mesh,
+/// then transforming the resulting vertices using linear blend skinning based on the
+/// skeleton state. Use this version when you already have pre-calculated blend weights.
+///
+/// @param character Character containing mesh, blend shapes, and skinning data
+/// @param state Current pose of the skeleton
+/// @param blendWeights Weights for each blend shape
+/// @param outputMesh Mesh to store the resulting deformed vertices
+template <typename T>
+void skinWithBlendShapes(
+    const Character& character,
+    const SkeletonStateT<T>& state,
+    const BlendWeightsT<T>& blendWeights,
+    MeshT<T>& outputMesh);
+
+/// Applies blend shape deformations and skeletal transformations to a mesh.
+///
+/// Overload that extracts blend shape weights from model parameters before skinning.
+/// Use this version when working with high-level character animation where you have
+/// model parameters rather than direct blend weights.
+///
+/// @param character Character containing mesh, blend shapes, and skinning data
+/// @param state Current pose of the skeleton
+/// @param modelParams Model parameters containing blend shape weights
+/// @param outputMesh Mesh to store the resulting deformed vertices
+template <typename T>
+void skinWithBlendShapes(
+    const Character& character,
+    const SkeletonStateT<T>& state,
+    const ModelParametersT<T>& modelParams,
+    MeshT<T>& outputMesh);
+
+/// Extracts blend shape weights from model parameters.
+///
+/// Maps from the model parameter space to blend shape weights using the parameter transform.
+/// Use this function to get weights for identity/shape blend shapes (e.g., body shape variations).
+///
+/// @param paramTransform Mapping between model parameters and blend shape parameters
+/// @param modelParams Current model parameters
+/// @return Vector of blend shape weights
+template <typename T>
+BlendWeightsT<T> extractBlendWeights(
+    const ParameterTransform& paramTransform,
+    const ModelParametersT<T>& modelParams);
+
+/// Extracts facial expression blend shape weights from model parameters.
+///
+/// Maps from the model parameter space to facial expression blend shape weights
+/// using the parameter transform. Use this function specifically for facial animation
+/// parameters, which are stored separately from regular blend shapes.
+///
+/// @param paramTransform Mapping between model parameters and face expression parameters
+/// @param modelParams Current model parameters
+/// @return Vector of facial expression blend shape weights
+template <typename T>
+BlendWeightsT<T> extractFaceExpressionBlendWeights(
+    const ParameterTransform& paramTransform,
+    const ModelParametersT<T>& modelParams);
+
+} // namespace momentum

include/momentum/character/character.h

@@ -0,0 +1,272 @@
+/*
+ * 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/collision_geometry.h>
+#include <momentum/character/fwd.h>
+#include <momentum/character/locator.h>
+#include <momentum/character/parameter_limits.h>
+#include <momentum/character/parameter_transform.h>
+#include <momentum/character/skeleton.h>
+#include <momentum/character/skinned_locator.h>
+#include <momentum/character/types.h>
+#include <momentum/math/fwd.h>
+
+namespace momentum {
+
+/// A character model with skeletal structure, mesh, and optional components.
+template <typename T>
+struct CharacterT {
+  /// @{ @name Required components
+
+  /// Skeletal structure defining the character's joints and hierarchy
+  Skeleton skeleton;
+
+  /// Maps model parameters to joint parameters
+  ParameterTransform parameterTransform;
+
+  /// @}
+
+  /// @{ @name Optional components
+
+  /// Constraints on model parameters
+  ParameterLimits parameterLimits;
+
+  /// Points of interest attached to joints
+  LocatorList locators;
+
+  /// Points of interest attached to joints, with skinning weights
+  SkinnedLocatorList skinnedLocators;
+
+  /// 3D mesh representing the character's surface
+  Mesh_u mesh;
+
+  /// Defines how mesh vertices are influenced by joints
+  SkinWeights_u skinWeights;
+
+  /// Pose-dependent shape corrections
+  PoseShape_u poseShapes;
+
+  /// Collision volumes for the character
+  CollisionGeometry_u collision;
+
+  /// Shape variations that can be blended
+  BlendShape_const_p blendShape;
+
+  /// Facial expression blend shapes
+  BlendShapeBase_const_p faceExpressionBlendShape;
+
+  /// Inverse of the bind pose transformations for each joint
+  TransformationList inverseBindPose;
+
+  /// Maps from original joint indices to simplified joint indices
+  std::vector<size_t> jointMap;
+
+  /// Character identifier
+  std::string name;
+
+  /// @}
+
+  /// Default constructor
+  CharacterT();
+
+  /// Destructor
+  ~CharacterT();
+
+  /// Constructs a character with the specified components
+  ///
+  /// @param s Skeleton defining joint hierarchy
+  /// @param pt Parameter transform mapping model parameters to joint parameters
+  /// @param pl Optional parameter limits/constraints
+  /// @param l Optional locators attached to joints
+  /// @param m Optional mesh representing the character's surface
+  /// @param sw Optional skin weights defining how mesh vertices are influenced by joints
+  /// @param cg Optional collision geometry
+  /// @param bs Optional pose-dependent shape corrections
+  /// @param blendShapes Optional shape variations that can be blended
+  /// @param faceExpressionBlendShapes Optional facial expression blend shapes
+  /// @param nameIn Optional character identifier
+  /// @param inverseBindPose Optional inverse bind pose transformations
+  CharacterT(
+      const Skeleton& s,
+      const ParameterTransform& pt,
+      const ParameterLimits& pl = ParameterLimits(),
+      const LocatorList& l = LocatorList(),
+      const Mesh* m = nullptr,
+      const SkinWeights* sw = nullptr,
+      const CollisionGeometry* cg = nullptr,
+      const PoseShape* bs = nullptr,
+      BlendShape_const_p blendShapes = {},
+      BlendShapeBase_const_p faceExpressionBlendShapes = {},
+      const std::string& nameIn = "",
+      const momentum::TransformationList& inverseBindPose = {},
+      const SkinnedLocatorList& skinnedLocators = {});
+
+  /// Copy constructor
+  CharacterT(const CharacterT& c);
+
+  /// Move constructor
+  CharacterT(CharacterT&& c) noexcept;
+
+  /// Copy assignment operator
+  CharacterT& operator=(const CharacterT& rhs);
+
+  /// Move assignment operator
+  CharacterT& operator=(CharacterT&& rhs) noexcept;
+
+  /// Creates a simplified character with only joints affected by the specified parameters
+  ///
+  /// @param activeParams Parameters to keep (defaults to all parameters)
+  /// @return A new character with simplified skeleton and parameter transform
+  [[nodiscard]] CharacterT simplify(const ParameterSet& activeParams = ParameterSet().flip()) const;
+
+  /// Creates a simplified character with only the specified joints
+  ///
+  /// @param activeJoints Boolean vector indicating which joints to keep
+  /// @return A new character with only the requested joints
+  [[nodiscard]] CharacterT simplifySkeleton(const std::vector<bool>& activeJoints) const;
+
+  /// Creates a simplified character with only the specified parameters
+  ///
+  /// @param parameterSet Set of parameters to keep
+  /// @return A new character with only the requested parameters
+  [[nodiscard]] CharacterT simplifyParameterTransform(const ParameterSet& parameterSet) const;
+
+  /// Remaps skin weights from original character to simplified version
+  ///
+  /// @param skinWeights Original skin weights
+  /// @param originalCharacter Original character containing the full joint hierarchy
+  /// @return Remapped skin weights for the simplified character
+  [[nodiscard]] SkinWeights remapSkinWeights(
+      const SkinWeights& skinWeights,
+      const CharacterT& originalCharacter) const;
+
+  /// Remaps parameter limits from original character to simplified version
+  ///
+  /// @param limits Original parameter limits
+  /// @param originalCharacter Original character containing the full joint hierarchy
+  /// @return Remapped parameter limits for the simplified character
+  [[nodiscard]] ParameterLimits remapParameterLimits(
+      const ParameterLimits& limits,
+      const CharacterT& originalCharacter) const;
+
+  /// Remaps locators from original character to simplified version
+  ///
+  /// @param locs Original locators
+  /// @param originalCharacter Original character containing the full joint hierarchy
+  /// @return Remapped locators for the simplified character
+  [[nodiscard]] LocatorList remapLocators(
+      const LocatorList& locs,
+      const CharacterT& originalCharacter) const;
+
+  [[nodiscard]] SkinnedLocatorList remapSkinnedLocators(
+      const SkinnedLocatorList& locs,
+      const CharacterT& originalCharacter) const;
+
+  /// Determines which joints are affected by the specified parameters
+  ///
+  /// @param parameterSet Set of parameters to check
+  /// @return Boolean vector indicating which joints are affected by the parameters
+  [[nodiscard]] std::vector<bool> parametersToActiveJoints(const ParameterSet& parameterSet) const;
+
+  /// Determines which parameters affect the specified joints
+  ///
+  /// @param activeJoints Boolean vector indicating which joints to check
+  /// @return Set of parameters that affect the specified joints
+  [[nodiscard]] ParameterSet activeJointsToParameters(const std::vector<bool>& activeJoints) const;
+
+  /// Returns parameters representing the character's bind pose
+  ///
+  /// The bind pose is the rest pose when all model parameters and joint offsets are zero.
+  /// When forward kinematics is applied to the bind pose, it results in the rest pose skeleton.
+  [[nodiscard]] CharacterParameters bindPose() const;
+
+  /// Initializes the parameter transform with the correct dimensions for this character
+  void initParameterTransform();
+
+  /// Resets the joint map to identity (each joint maps to itself)
+  void resetJointMap();
+
+  /// Initializes the inverse bind pose transformations
+  ///
+  /// The inverse bind pose is a set of affine transformations for each joint that
+  /// map from world space to local joint space in the bind pose configuration.
+  void initInverseBindPose();
+
+  /// Splits character parameters into active and inactive components
+  ///
+  /// @param character Character to use for the parameter transform
+  /// @param parameters Input parameters to split
+  /// @param parameterSet Set indicating which parameters are active
+  /// @return Parameters with active parameters zeroed in pose and applied to offsets
+  [[nodiscard]] static CharacterParameters splitParameters(
+      const CharacterT& character,
+      const CharacterParameters& parameters,
+      const ParameterSet& parameterSet);
+
+  /// Creates a new character with the specified blend shapes
+  ///
+  /// @param blendShape_in Blend shapes to add to the character
+  /// @param maxBlendShapes Maximum number of blend shape parameters to add (use all if <= 0)
+  /// @return A new character with the specified blend shapes
+  [[nodiscard]] CharacterT withBlendShape(
+      BlendShape_const_p blendShape_in,
+      Eigen::Index maxBlendShapes) const;
+
+  /// Creates a new character with the specified face expression blend shapes
+  ///
+  /// @param blendShape_in Face expression blend shapes to add to the character
+  /// @param maxBlendShapes Maximum number of blend shape parameters to add (use all if <= 0)
+  /// @return A new character with the specified face expression blend shapes
+  [[nodiscard]] CharacterT withFaceExpressionBlendShape(
+      BlendShapeBase_const_p blendShape_in,
+      Eigen::Index maxBlendShapes = -1) const;
+
+  /// Adds blend shapes to this character
+  ///
+  /// @param blendShape_in Blend shapes to add to the character
+  /// @param maxBlendShapes Maximum number of blend shape parameters to add (use all if <= 0)
+  void addBlendShape(const BlendShape_const_p& blendShape_in, Eigen::Index maxBlendShapes);
+
+  /// Adds face expression blend shapes to this character
+  ///
+  /// @param blendShape_in Face expression blend shapes to add to the character
+  /// @param maxBlendShapes Maximum number of blend shape parameters to add (use all if <= 0)
+  void addFaceExpressionBlendShape(
+      const BlendShapeBase_const_p& blendShape_in,
+      Eigen::Index maxBlendShapes = -1);
+
+  /// Creates a new character with blend shapes baked into the mesh
+  ///
+  /// @param modelParams Model parameters containing blend shape weights
+  /// @return A new character with blend shapes baked into the mesh
+  [[nodiscard]] CharacterT bakeBlendShape(const ModelParameters& modelParams) const;
+
+  /// Creates a new character with blend shapes baked into the mesh
+  ///
+  /// @param blendWeights Blend shape weights to apply
+  /// @return A new character with blend shapes baked into the mesh
+  [[nodiscard]] CharacterT bakeBlendShape(const BlendWeights& blendWeights) const;
+
+  /// Generic "bake-out" for turning a character into self-contained geometry.
+  ///
+  /// @param[in] modelParams Current pose/scale/blend-shape parameters.
+  /// @param[in] bakeBlendShapes Set true (default) to apply blend-shape deltas and remove their
+  /// parameters from the character.
+  /// @param[in] bakeScales Set true (default) to evaluate the posed skeleton, run
+  /// Linear-Blend-Skinning once, and remove all scaling parameters from the character.
+  ///
+  /// The returned character contains a static mesh with all requested deformations baked in, while
+  /// still supporting any parameters you elected to keep.
+  [[nodiscard]] CharacterT bake(
+      const ModelParameters& modelParams,
+      bool bakeBlendShapes = true,
+      bool bakeScales = true) const;
+};
+
+} // namespace momentum

include/momentum/character/character_state.h

@@ -0,0 +1,108 @@
+/*
+ * 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/character.h>
+#include <momentum/character/locator_state.h>
+#include <momentum/character/skeleton_state.h>
+#include <momentum/math/fwd.h>
+
+namespace momentum {
+
+/// Represents the complete state of a character at a specific point in time.
+///
+/// Stores the character's parameters, skeleton state, locator positions,
+/// skinned mesh, and collision geometry state. This class is used for
+/// character animation and rendering.
+template <typename T>
+struct CharacterStateT {
+  /// Model parameters and joint offsets
+  CharacterParameters parameters;
+
+  /// Joint transformations
+  SkeletonState skeletonState;
+
+  /// Locator positions and orientations
+  LocatorState locatorState;
+
+  /// Skinned mesh (may be null if updateMesh=false)
+  Mesh_u meshState;
+
+  /// Collision geometry state (may be null if updateCollision=false)
+  CollisionGeometryState_u collisionState;
+
+  /// Creates an empty character state
+  CharacterStateT();
+
+  /// Creates a deep copy of another character state
+  explicit CharacterStateT(const CharacterStateT& other);
+
+  /// Move constructor
+  CharacterStateT(CharacterStateT&& c) noexcept;
+
+  /// Copy assignment is disabled
+  CharacterStateT& operator=(const CharacterStateT& rhs) = delete;
+
+  /// Move assignment operator
+  CharacterStateT& operator=(CharacterStateT&& rhs) noexcept;
+
+  /// Destructor
+  ~CharacterStateT();
+
+  /// Creates a character state in bind pose
+  ///
+  /// @param referenceCharacter The character to use as reference
+  /// @param updateMesh Whether to compute the skinned mesh
+  /// @param updateCollision Whether to update collision geometry
+  explicit CharacterStateT(
+      const CharacterT<T>& referenceCharacter,
+      bool updateMesh = true,
+      bool updateCollision = true);
+
+  /// Creates a character state with specific parameters
+  ///
+  /// @param parameters The character parameters to use
+  /// @param referenceCharacter The character to use as reference
+  /// @param updateMesh Whether to compute the skinned mesh
+  /// @param updateCollision Whether to update collision geometry
+  /// @param applyLimits Whether to apply joint parameter limits
+  CharacterStateT(
+      const CharacterParameters& parameters,
+      const CharacterT<T>& referenceCharacter,
+      bool updateMesh = true,
+      bool updateCollision = true,
+      bool applyLimits = true);
+
+  /// Updates the character state with specific parameters
+  ///
+  /// If parameters.offsets is empty, it will be initialized with zeros.
+  ///
+  /// @param parameters The character parameters to use
+  /// @param referenceCharacter The character to use as reference
+  /// @param updateMesh Whether to compute the skinned mesh
+  /// @param updateCollision Whether to update collision geometry
+  /// @param applyLimits Whether to apply joint parameter limits
+  void set(
+      const CharacterParameters& parameters,
+      const CharacterT<T>& referenceCharacter,
+      bool updateMesh = true,
+      bool updateCollision = true,
+      bool applyLimits = true);
+
+  /// Sets the character state to the bind pose
+  ///
+  /// @param referenceCharacter The character to use as reference
+  /// @param updateMesh Whether to compute the skinned mesh
+  /// @param updateCollision Whether to update collision geometry
+  void setBindPose(
+      const CharacterT<T>& referenceCharacter,
+      bool updateMesh = true,
+      bool updateCollision = true);
+};
+
+} // namespace momentum