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

include/momentum/character/character_utility.h

@@ -0,0 +1,128 @@
+/*
+ * 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>
+
+namespace momentum {
+
+/// Scales the character (mesh and skeleton) by the desired amount.
+///
+/// Note that this should primarily be used when transforming the character into different units. If
+/// you simply want to apply an identity-specific scale to the character, you should use the
+/// 'scale_global' parameter in the ParameterTransform class.
+///
+/// @param[in] character Character to be scaled
+/// @param[in] scale Scale factor to apply
+/// @return A new Character object that has been scaled
+[[nodiscard]] Character scaleCharacter(const Character& character, float scale);
+
+/// Transforms the character (mesh and skeleton) by the desired transformation matrix.  The
+/// transformation matrix should not have any scale or shear.
+///
+/// Note that this should primarily be used for transforming models between different coordinate
+/// spaces (e.g. y-up vs. z-up). If you want to move a character around the scene, you should
+/// preferably use the model parameters.
+///
+/// @param[in] character Character to be transformed
+/// @param[in] xform Transformation to apply
+/// @return A new Character object that has been transformed
+[[nodiscard]] Character transformCharacter(const Character& character, const Affine3f& xform);
+
+/// Replaces the part of target_character's skeleton rooted at target_root with the part of
+/// source_character's skeleton rooted at source_root.
+///
+/// This function is typically used to swap one character's hand skeleton with another, for example.
+///
+/// @param[in] srcCharacter The source character whose skeleton will be copied.
+/// @param[in] tgtCharacter The target character whose skeleton will be replaced.
+/// @param[in] srcRootJoint Root of the source skeleton hierarchy to be copied.
+/// @param[in] tgtRootJoint Root of the target skeleton hierarchy to be replaced.
+/// @return A new Character that is identical to tgtCharacter except that the skeleton under
+/// tgtRootJoint has been replaced by the part of srcCharacter's skeleton rooted at srcRootJoint.
+[[nodiscard]] Character replaceSkeletonHierarchy(
+    const Character& srcCharacter,
+    const Character& tgtCharacter,
+    const std::string& srcRootJoint,
+    const std::string& tgtRootJoint);
+
+/// Removes the specified joints and any joints parented beneath them from the character.
+///
+/// Currently, it is necessary to remove child joints to prevent dangling joints. Mesh points
+/// skinned to the removed joints are re-skinned to their parent joint in the hierarchy.
+///
+/// @param[in] character The character from which joints will be removed.
+/// @param[in] jointsToRemove A vector of joint indices to be removed.
+/// @return A new Character object that is identical to the original except for the removal of
+/// specified joints.
+[[nodiscard]] Character removeJoints(
+    const Character& character,
+    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).
+///
+/// @param[in] inputMotion Input ModelParameter motion with names.
+/// @param[in] targetCharacter Target character that defines its own ModelParameters.
+/// @return A matrix of model parameters for the target character.
+MatrixXf mapMotionToCharacter(
+    const MotionParameters& inputMotion,
+    const Character& targetCharacter);
+
+/// Maps the input JointParameter vector to a target character by matching joint names. Mismatched
+/// names will be discarded (source) or set to zero (target). For every matched joint, all 7
+/// parameters will be copied over.
+///
+/// @param[in] inputIdentity Input JointParameter vector with joint names.
+/// @param[in] targetCharacter Target character that defines its own Joints.
+/// @return A vector of joint parameters for the target character.
+VectorXf mapIdentityToCharacter(
+    const IdentityParameters& inputIdentity,
+    const Character& targetCharacter);
+
+/// Reduces the mesh to only include the specified vertices and associated faces
+///
+/// @param[in] character Character to be reduced
+/// @param[in] activeVertices Boolean vector indicating which vertices to keep
+/// @return A new character with mesh reduced to the specified vertices
+template <typename T>
+[[nodiscard]] CharacterT<T> reduceMeshByVertices(
+    const CharacterT<T>& character,
+    const std::vector<bool>& activeVertices);
+
+/// Reduces the mesh to only include the specified faces and associated vertices
+///
+/// @param[in] character Character to be reduced
+/// @param[in] activeFaces Boolean vector indicating which faces to keep
+/// @return A new character with mesh reduced to the specified faces
+template <typename T>
+[[nodiscard]] CharacterT<T> reduceMeshByFaces(
+    const CharacterT<T>& character,
+    const std::vector<bool>& activeFaces);
+
+/// Converts vertex selection to face selection
+///
+/// @param[in] character Character containing the mesh
+/// @param[in] activeVertices Boolean vector indicating which vertices are active
+/// @return Boolean vector indicating which faces only contain active vertices
+template <typename T>
+[[nodiscard]] std::vector<bool> verticesToFaces(
+    const MeshT<T>& mesh,
+    const std::vector<bool>& activeVertices);
+
+/// Converts face selection to vertex selection
+///
+/// @param[in] character Character containing the mesh
+/// @param[in] activeFaces Boolean vector indicating which faces are active
+/// @return Boolean vector indicating which vertices are used by active faces
+template <typename T>
+[[nodiscard]] std::vector<bool> facesToVertices(
+    const MeshT<T>& mesh,
+    const std::vector<bool>& activeFaces);
+
+} // namespace momentum

include/momentum/character/collision_geometry.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/types.h>
+#include <momentum/common/memory.h>
+#include <momentum/math/constants.h>
+#include <momentum/math/transform.h>
+#include <momentum/math/utility.h>
+
+namespace momentum {
+
+/// Tapered capsule collision geometry for character collision detection.
+///
+/// Defined by a transformation, length, and two radii at the endpoints, creating
+/// a capsule with potentially different radii at each end.
+template <typename S>
+struct TaperedCapsuleT {
+  using Scalar = S;
+
+  /// Transformation defining the orientation and starting point relative to the parent coordinate
+  /// system.
+  TransformT<S> transformation;
+
+  /// Radii at the two endpoints of the capsule.
+  Vector2<S> radius;
+
+  /// Parent joint to which the geometry is attached.
+  size_t parent;
+
+  /// Length of the collision geometry along the x-axis.
+  S length;
+
+  TaperedCapsuleT()
+      : transformation(TransformT<S>()),
+        radius(Vector2<S>::Zero()),
+        parent(kInvalidIndex),
+        length(S(0)) {
+    // Empty
+  }
+
+  /// Checks if the current capsule is approximately equal to another.
+  [[nodiscard]] bool isApprox(const TaperedCapsuleT& other, const S& tol = Eps<S>(1e-4f, 1e-10))
+      const {
+    if (!transformation.isApprox(other.transformation, tol)) {
+      return false;
+    }
+
+    if (!radius.isApprox(other.radius)) {
+      return false;
+    }
+
+    if (parent != other.parent) {
+      return false;
+    }
+
+    if (!::momentum::isApprox(length, other.length)) {
+      return false;
+    }
+
+    return true;
+  }
+};
+
+/// Collection of tapered capsules representing a character's collision geometry.
+template <typename S>
+using CollisionGeometryT = std::vector<TaperedCapsuleT<S>>;
+
+using CollisionGeometry = CollisionGeometryT<float>;
+using CollisionGeometryd = CollisionGeometryT<double>;
+
+MOMENTUM_DEFINE_POINTERS(CollisionGeometry)
+MOMENTUM_DEFINE_POINTERS(CollisionGeometryd)
+
+} // namespace momentum

include/momentum/character/collision_geometry_state.h

@@ -0,0 +1,130 @@
+/*
+ * 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 <axel/BoundingBox.h>
+
+namespace momentum {
+
+/// Represents collision geometry states using a Structure of Arrays (SoA) format.
+template <typename T>
+struct CollisionGeometryStateT {
+  // ASCII Art to visualize the capsule:
+  //
+  //           ^
+  //           :
+  //           :________________________________________
+  //          /:                                        :\
+  //        /  :                                        : \
+  //       |   :(origin)                                :  |
+  //       |   O-------------(direction)--------------->:--|------------------> X-axis
+  //       |   :                                        :  |
+  //        \  : (radius[0])                            : /  (radius[1])
+  //          \:________________________________________:/
+  //
+  //
+  // Note: radius[0] and radius[1] can be different.
+
+  /// Capsule's origin in global coordinates.
+  std::vector<Vector3<T>> origin;
+
+  /// Capsule's direction vector (representing the X-axis) in global coordinates.
+  std::vector<Vector3<T>> direction;
+
+  /// Scaled radii of the capsule's endpoints.
+  std::vector<Vector2<T>> radius;
+
+  /// Signed difference between the capsule's radii (radius[1] - radius[0]).
+  std::vector<T> delta;
+
+  /// Updates the state based on a given skeleton state and collision geometry.
+  void update(const SkeletonStateT<T>& skeletonState, const CollisionGeometry& collisionGeometry);
+};
+
+/// Determines if two tapered capsules overlap.
+///
+/// @param originA Origin of the first capsule
+/// @param directionA Direction vector of the first capsule
+/// @param radiiA Radii at the endpoints of the first capsule
+/// @param deltaA Difference between radii of the first capsule
+/// @param originB Origin of the second capsule
+/// @param directionB Direction vector of the second capsule
+/// @param radiiB Radii at the endpoints of the second capsule
+/// @param deltaB Difference between radii of the second capsule
+/// @param outDistance Output parameter for the distance between the closest points
+/// (normalized). No modification on return false.
+/// @param outOverlap Output parameter for the overlap amount (positive if overlapping)
+/// @return True if the capsules overlap, false otherwise
+template <typename T>
+bool overlaps(
+    const Vector3<T>& originA,
+    const Vector3<T>& directionA,
+    const Vector2<T>& radiiA,
+    T deltaA,
+    const Vector3<T>& originB,
+    const Vector3<T>& directionB,
+    const Vector2<T>& radiiB,
+    T deltaB,
+    T& outDistance,
+    Vector2<T>& outClosestPoints,
+    T& outOverlap) {
+  // Sum of the maximum radii of the tapered capsules
+  const T maxRadiiSum = radiiA.maxCoeff() + radiiB.maxCoeff();
+
+  // Determine the closest points on the segments of the tapered capsules
+  auto [success, closestDist, closestPoints] =
+      closestPointsOnSegments<T>(originA, directionA, originB, directionB, maxRadiiSum);
+
+  if (!success) {
+    return false;
+  }
+
+  // Store the closest points to the output argument
+  outClosestPoints = closestPoints;
+
+  // Calculate the radii at the closest points
+  const T radiusAtClosestPoints =
+      radiiA[0] + closestPoints[0] * deltaA + radiiB[0] + closestPoints[1] * deltaB;
+
+  // Determine the overlap and distance between the closest points
+  outOverlap = radiusAtClosestPoints - closestDist;
+  outDistance = closestDist;
+
+  // Check for overlap and sufficient proximity
+  return (outOverlap > T(0)) && (closestDist >= Eps<T>(1e-8, 1e-17));
+}
+
+/// Updates an axis-aligned bounding box to encompass a tapered capsule.
+///
+/// @param aabb The bounding box to update
+/// @param originA Origin of the capsule
+/// @param direction Direction vector of the capsule
+/// @param radii Radii at the endpoints of the capsule
+template <typename T>
+void updateAabb(
+    axel::BoundingBox<T>& aabb,
+    const Vector3<T>& originA,
+    const Vector3<T>& direction,
+    const Vector2<T>& radii) {
+  const Vector3<T> radius0 = Vector3<T>::Constant(radii[0]);
+  const Vector3<T> radius1 = Vector3<T>::Constant(radii[1]);
+  const Vector3<T> originB = originA + direction;
+
+  const Vector3<T> minA = originA - radius0;
+  const Vector3<T> maxA = originA + radius0;
+  const Vector3<T> minB = originB - radius1;
+  const Vector3<T> maxB = originB + radius1;
+
+  aabb.aabb.min() = minA.cwiseMin(minB);
+  aabb.aabb.max() = maxA.cwiseMax(maxB);
+}
+
+} // namespace momentum

include/momentum/character/fwd.h

@@ -0,0 +1,262 @@
+/*
+ * 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 BlendShape;
+
+using BlendShape_p = ::std::shared_ptr<BlendShape>;
+using BlendShape_u = ::std::unique_ptr<BlendShape>;
+using BlendShape_w = ::std::weak_ptr<BlendShape>;
+using BlendShape_const_p = ::std::shared_ptr<const BlendShape>;
+using BlendShape_const_u = ::std::unique_ptr<const BlendShape>;
+using BlendShape_const_w = ::std::weak_ptr<const BlendShape>;
+
+struct BlendShapeBase;
+
+using BlendShapeBase_p = ::std::shared_ptr<BlendShapeBase>;
+using BlendShapeBase_u = ::std::unique_ptr<BlendShapeBase>;
+using BlendShapeBase_w = ::std::weak_ptr<BlendShapeBase>;
+using BlendShapeBase_const_p = ::std::shared_ptr<const BlendShapeBase>;
+using BlendShapeBase_const_u = ::std::unique_ptr<const BlendShapeBase>;
+using BlendShapeBase_const_w = ::std::weak_ptr<const BlendShapeBase>;
+
+struct Locator;
+
+using Locator_p = ::std::shared_ptr<Locator>;
+using Locator_u = ::std::unique_ptr<Locator>;
+using Locator_w = ::std::weak_ptr<Locator>;
+using Locator_const_p = ::std::shared_ptr<const Locator>;
+using Locator_const_u = ::std::unique_ptr<const Locator>;
+using Locator_const_w = ::std::weak_ptr<const Locator>;
+
+struct PoseShape;
+
+using PoseShape_p = ::std::shared_ptr<PoseShape>;
+using PoseShape_u = ::std::unique_ptr<PoseShape>;
+using PoseShape_w = ::std::weak_ptr<PoseShape>;
+using PoseShape_const_p = ::std::shared_ptr<const PoseShape>;
+using PoseShape_const_u = ::std::unique_ptr<const PoseShape>;
+using PoseShape_const_w = ::std::weak_ptr<const PoseShape>;
+
+struct SkinWeights;
+
+using SkinWeights_p = ::std::shared_ptr<SkinWeights>;
+using SkinWeights_u = ::std::unique_ptr<SkinWeights>;
+using SkinWeights_w = ::std::weak_ptr<SkinWeights>;
+using SkinWeights_const_p = ::std::shared_ptr<const SkinWeights>;
+using SkinWeights_const_u = ::std::unique_ptr<const SkinWeights>;
+using SkinWeights_const_w = ::std::weak_ptr<const SkinWeights>;
+
+struct SkinnedLocator;
+
+using SkinnedLocator_p = ::std::shared_ptr<SkinnedLocator>;
+using SkinnedLocator_u = ::std::unique_ptr<SkinnedLocator>;
+using SkinnedLocator_w = ::std::weak_ptr<SkinnedLocator>;
+using SkinnedLocator_const_p = ::std::shared_ptr<const SkinnedLocator>;
+using SkinnedLocator_const_u = ::std::unique_ptr<const SkinnedLocator>;
+using SkinnedLocator_const_w = ::std::weak_ptr<const SkinnedLocator>;
+
+template <typename T>
+struct CharacterT;
+using Character = CharacterT<float>;
+using Characterd = CharacterT<double>;
+
+using Character_p = ::std::shared_ptr<Character>;
+using Character_u = ::std::unique_ptr<Character>;
+using Character_w = ::std::weak_ptr<Character>;
+using Character_const_p = ::std::shared_ptr<const Character>;
+using Character_const_u = ::std::unique_ptr<const Character>;
+using Character_const_w = ::std::weak_ptr<const Character>;
+
+using Characterd_p = ::std::shared_ptr<Characterd>;
+using Characterd_u = ::std::unique_ptr<Characterd>;
+using Characterd_w = ::std::weak_ptr<Characterd>;
+using Characterd_const_p = ::std::shared_ptr<const Characterd>;
+using Characterd_const_u = ::std::unique_ptr<const Characterd>;
+using Characterd_const_w = ::std::weak_ptr<const Characterd>;
+
+template <typename T>
+struct CharacterStateT;
+using CharacterState = CharacterStateT<float>;
+using CharacterStated = CharacterStateT<double>;
+
+using CharacterState_p = ::std::shared_ptr<CharacterState>;
+using CharacterState_u = ::std::unique_ptr<CharacterState>;
+using CharacterState_w = ::std::weak_ptr<CharacterState>;
+using CharacterState_const_p = ::std::shared_ptr<const CharacterState>;
+using CharacterState_const_u = ::std::unique_ptr<const CharacterState>;
+using CharacterState_const_w = ::std::weak_ptr<const CharacterState>;
+
+using CharacterStated_p = ::std::shared_ptr<CharacterStated>;
+using CharacterStated_u = ::std::unique_ptr<CharacterStated>;
+using CharacterStated_w = ::std::weak_ptr<CharacterStated>;
+using CharacterStated_const_p = ::std::shared_ptr<const CharacterStated>;
+using CharacterStated_const_u = ::std::unique_ptr<const CharacterStated>;
+using CharacterStated_const_w = ::std::weak_ptr<const CharacterStated>;
+
+template <typename T>
+struct CollisionGeometryStateT;
+using CollisionGeometryState = CollisionGeometryStateT<float>;
+using CollisionGeometryStated = CollisionGeometryStateT<double>;
+
+using CollisionGeometryState_p = ::std::shared_ptr<CollisionGeometryState>;
+using CollisionGeometryState_u = ::std::unique_ptr<CollisionGeometryState>;
+using CollisionGeometryState_w = ::std::weak_ptr<CollisionGeometryState>;
+using CollisionGeometryState_const_p = ::std::shared_ptr<const CollisionGeometryState>;
+using CollisionGeometryState_const_u = ::std::unique_ptr<const CollisionGeometryState>;
+using CollisionGeometryState_const_w = ::std::weak_ptr<const CollisionGeometryState>;
+
+using CollisionGeometryStated_p = ::std::shared_ptr<CollisionGeometryStated>;
+using CollisionGeometryStated_u = ::std::unique_ptr<CollisionGeometryStated>;
+using CollisionGeometryStated_w = ::std::weak_ptr<CollisionGeometryStated>;
+using CollisionGeometryStated_const_p = ::std::shared_ptr<const CollisionGeometryStated>;
+using CollisionGeometryStated_const_u = ::std::unique_ptr<const CollisionGeometryStated>;
+using CollisionGeometryStated_const_w = ::std::weak_ptr<const CollisionGeometryStated>;
+
+template <typename T>
+struct JointT;
+using Joint = JointT<float>;
+using Jointd = JointT<double>;
+
+using Joint_p = ::std::shared_ptr<Joint>;
+using Joint_u = ::std::unique_ptr<Joint>;
+using Joint_w = ::std::weak_ptr<Joint>;
+using Joint_const_p = ::std::shared_ptr<const Joint>;
+using Joint_const_u = ::std::unique_ptr<const Joint>;
+using Joint_const_w = ::std::weak_ptr<const Joint>;
+
+using Jointd_p = ::std::shared_ptr<Jointd>;
+using Jointd_u = ::std::unique_ptr<Jointd>;
+using Jointd_w = ::std::weak_ptr<Jointd>;
+using Jointd_const_p = ::std::shared_ptr<const Jointd>;
+using Jointd_const_u = ::std::unique_ptr<const Jointd>;
+using Jointd_const_w = ::std::weak_ptr<const Jointd>;
+
+template <typename T>
+struct JointStateT;
+using JointState = JointStateT<float>;
+using JointStated = JointStateT<double>;
+
+using JointState_p = ::std::shared_ptr<JointState>;
+using JointState_u = ::std::unique_ptr<JointState>;
+using JointState_w = ::std::weak_ptr<JointState>;
+using JointState_const_p = ::std::shared_ptr<const JointState>;
+using JointState_const_u = ::std::unique_ptr<const JointState>;
+using JointState_const_w = ::std::weak_ptr<const JointState>;
+
+using JointStated_p = ::std::shared_ptr<JointStated>;
+using JointStated_u = ::std::unique_ptr<JointStated>;
+using JointStated_w = ::std::weak_ptr<JointStated>;
+using JointStated_const_p = ::std::shared_ptr<const JointStated>;
+using JointStated_const_u = ::std::unique_ptr<const JointStated>;
+using JointStated_const_w = ::std::weak_ptr<const JointStated>;
+
+template <typename T>
+struct ParameterTransformT;
+using ParameterTransform = ParameterTransformT<float>;
+using ParameterTransformd = ParameterTransformT<double>;
+
+using ParameterTransform_p = ::std::shared_ptr<ParameterTransform>;
+using ParameterTransform_u = ::std::unique_ptr<ParameterTransform>;
+using ParameterTransform_w = ::std::weak_ptr<ParameterTransform>;
+using ParameterTransform_const_p = ::std::shared_ptr<const ParameterTransform>;
+using ParameterTransform_const_u = ::std::unique_ptr<const ParameterTransform>;
+using ParameterTransform_const_w = ::std::weak_ptr<const ParameterTransform>;
+
+using ParameterTransformd_p = ::std::shared_ptr<ParameterTransformd>;
+using ParameterTransformd_u = ::std::unique_ptr<ParameterTransformd>;
+using ParameterTransformd_w = ::std::weak_ptr<ParameterTransformd>;
+using ParameterTransformd_const_p = ::std::shared_ptr<const ParameterTransformd>;
+using ParameterTransformd_const_u = ::std::unique_ptr<const ParameterTransformd>;
+using ParameterTransformd_const_w = ::std::weak_ptr<const ParameterTransformd>;
+
+template <typename T>
+struct SkeletonT;
+using Skeleton = SkeletonT<float>;
+using Skeletond = SkeletonT<double>;
+
+using Skeleton_p = ::std::shared_ptr<Skeleton>;
+using Skeleton_u = ::std::unique_ptr<Skeleton>;
+using Skeleton_w = ::std::weak_ptr<Skeleton>;
+using Skeleton_const_p = ::std::shared_ptr<const Skeleton>;
+using Skeleton_const_u = ::std::unique_ptr<const Skeleton>;
+using Skeleton_const_w = ::std::weak_ptr<const Skeleton>;
+
+using Skeletond_p = ::std::shared_ptr<Skeletond>;
+using Skeletond_u = ::std::unique_ptr<Skeletond>;
+using Skeletond_w = ::std::weak_ptr<Skeletond>;
+using Skeletond_const_p = ::std::shared_ptr<const Skeletond>;
+using Skeletond_const_u = ::std::unique_ptr<const Skeletond>;
+using Skeletond_const_w = ::std::weak_ptr<const Skeletond>;
+
+template <typename T>
+struct SkeletonStateT;
+using SkeletonState = SkeletonStateT<float>;
+using SkeletonStated = SkeletonStateT<double>;
+
+using SkeletonState_p = ::std::shared_ptr<SkeletonState>;
+using SkeletonState_u = ::std::unique_ptr<SkeletonState>;
+using SkeletonState_w = ::std::weak_ptr<SkeletonState>;
+using SkeletonState_const_p = ::std::shared_ptr<const SkeletonState>;
+using SkeletonState_const_u = ::std::unique_ptr<const SkeletonState>;
+using SkeletonState_const_w = ::std::weak_ptr<const SkeletonState>;
+
+using SkeletonStated_p = ::std::shared_ptr<SkeletonStated>;
+using SkeletonStated_u = ::std::unique_ptr<SkeletonStated>;
+using SkeletonStated_w = ::std::weak_ptr<SkeletonStated>;
+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>;
+using TaperedCapsuled = TaperedCapsuleT<double>;
+
+using TaperedCapsule_p = ::std::shared_ptr<TaperedCapsule>;
+using TaperedCapsule_u = ::std::unique_ptr<TaperedCapsule>;
+using TaperedCapsule_w = ::std::weak_ptr<TaperedCapsule>;
+using TaperedCapsule_const_p = ::std::shared_ptr<const TaperedCapsule>;
+using TaperedCapsule_const_u = ::std::unique_ptr<const TaperedCapsule>;
+using TaperedCapsule_const_w = ::std::weak_ptr<const TaperedCapsule>;
+
+using TaperedCapsuled_p = ::std::shared_ptr<TaperedCapsuled>;
+using TaperedCapsuled_u = ::std::unique_ptr<TaperedCapsuled>;
+using TaperedCapsuled_w = ::std::weak_ptr<TaperedCapsuled>;
+using TaperedCapsuled_const_p = ::std::shared_ptr<const TaperedCapsuled>;
+using TaperedCapsuled_const_u = ::std::unique_ptr<const TaperedCapsuled>;
+using TaperedCapsuled_const_w = ::std::weak_ptr<const TaperedCapsuled>;
+
+} // namespace momentum

include/momentum/character/inverse_parameter_transform.h

@@ -0,0 +1,58 @@
+/*
+ * 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/types.h>
+
+#include <Eigen/Sparse>
+
+namespace momentum {
+
+// Maps from joint parameters back to the model parameters.  Because the joint
+// parameters have a much higher dimensionality (7*nJoints) than the number of
+// model parameters, in general we can't always find a set of model parameters
+// that reproduce the passed-in joint parameters.  Therefore, the mapping is
+// done in a least squares sense: we find the model parameters that bring use
+// closest to the passed-in joint parameters under L2.
+//
+// Note that this assumes the parameter transform is well-formed, in the sense
+// that it has rank equal to the number of model parameters.  Any sane
+// parameter transform should have this property (if not, it would be possible
+// to generate the same set of joint parameters with two different model
+// parameter vectors).
+
+template <typename T>
+struct InverseParameterTransformT {
+ public:
+  const SparseRowMatrix<T> transform;
+  const Eigen::SparseQR<Eigen::SparseMatrix<T>, Eigen::COLAMDOrdering<int>> inverseTransform;
+  const Eigen::VectorX<T> offsets; // DEPRECATED: constant offset factor for each joint
+
+  explicit InverseParameterTransformT(const ParameterTransformT<T>& paramTransform);
+
+  // map joint parameters to model parameters.  The residual from the fit is
+  // left in the result's offsets vector.
+  [[nodiscard]] CharacterParametersT<T> apply(const JointParametersT<T>& parameters) const;
+
+  // Dimension of the output model parameters vector:
+  [[nodiscard]] Eigen::Index numAllModelParameters() const {
+    return transform.cols();
+  }
+
+  // Dimension of the input joint parameters vector:
+  [[nodiscard]] Eigen::Index numJointParameters() const {
+    return transform.rows();
+  }
+};
+
+using InverseParameterTransform = InverseParameterTransformT<float>;
+using InverseParameterTransformd = InverseParameterTransformT<double>;
+
+} // namespace momentum