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

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

include/momentum/character/joint.h

@@ -0,0 +1,82 @@
+/*
+ * 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/constants.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+/// A simplified version of a Maya joint with pre-rotation only (no post-rotation).
+template <typename T>
+struct JointT {
+  using Scalar = T;
+
+  /// Joint name
+  std::string name{"uninitialized"};
+
+  /// Index of the parent joint in the skeleton hierarchy
+  size_t parent{kInvalidIndex};
+
+  // TODO: does it make sense to save its own index too?
+
+  /// Pre-rotation matrix from its parent's axes to its own axes.
+  /// @note: Braces initialization is avoided due to issues with CUDA 11.
+  Quaternion<T> preRotation = Quaternion<T>::Identity();
+
+  /// The constant translation offset from the parent joint to this joint's origin.
+  Vector3<T> translationOffset = Vector3<T>::Zero();
+
+  /// Checks if the current joint is approximately equal to the provided joint.
+  [[nodiscard]] bool isApprox(
+      const JointT<T>& joint,
+      const T& rotTol = Eps<T>(1e-4, 1e-10),
+      const T& tranTol = Eigen::NumTraits<Scalar>::dummy_precision()) const {
+    if (name != joint.name) {
+      return false;
+    }
+
+    if (parent != joint.parent) {
+      return false;
+    }
+
+    if (!preRotation.toRotationMatrix().isApprox(joint.preRotation.toRotationMatrix(), rotTol)) {
+      return false;
+    }
+
+    if (!translationOffset.isApprox(joint.translationOffset, tranTol)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /// Casts the current joint to another scalar type.
+  template <typename U>
+  [[nodiscard]] auto cast() const {
+    if constexpr (std::is_same_v<T, U>) {
+      return *this;
+    } else {
+      JointT<U> newJoint;
+      newJoint.name = name;
+      newJoint.parent = parent;
+      newJoint.preRotation = preRotation.template cast<U>();
+      newJoint.translationOffset = translationOffset.template cast<U>();
+      return newJoint;
+    }
+  }
+};
+
+/// A list of joints (e.g., of a skeleton).
+template <typename T>
+using JointListT = std::vector<JointT<T>>;
+using JointList = JointListT<float>;
+using JointListd = JointListT<double>;
+
+} // namespace momentum

include/momentum/character/joint_state.h

@@ -0,0 +1,241 @@
+/*
+ * 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/joint.h>
+#include <momentum/character/types.h>
+#include <momentum/math/transform.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+/// Represents the state of a joint with local and global transformations.
+///
+/// Joint transform hierarchy is defined as:
+///     WorldTransform = ParentWorldTransform * Tz * Ty * Tx * Rpre * R * S
+///
+/// Where:
+/// - Tx, Ty, Tz are translations along each axis
+/// - Rpre is the pre-rotation from the joint definition
+/// - R is the joint rotation (applied in order: rz * ry * rx)
+/// - S is the uniform scale factor
+///
+/// Each joint has 7 parameters: 3 translation, 3 rotation, and 1 scale.
+template <typename T>
+struct JointStateT {
+  /// Local transformation relative to parent joint
+  ///
+  /// Defined by the joint parameters (translation, rotation, scale)
+  TransformT<T> localTransform;
+
+  /// Global transformation in world space
+  ///
+  /// Combines parent transformations with local transformation
+  TransformT<T> transform;
+
+  /// Translation axes in global space
+  ///
+  /// Each column represents one translation axis (X, Y, Z) in global coordinates
+  Matrix3<T> translationAxis;
+
+  /// Rotation axes in global space
+  ///
+  /// Each column represents one rotation axis (X, Y, Z) in global coordinates
+  Matrix3<T> rotationAxis;
+
+  /// Indicates if derivative data needs recomputation
+  ///
+  /// When true, derivative methods should not be called as they may return invalid results
+  bool derivDirty = true;
+
+  /// Updates joint state based on joint definition and parameters
+  ///
+  /// Recursively computes all transformations from parent to child, including
+  /// local and global transforms, and optionally derivative information.
+  ///
+  /// @param joint The joint definition containing offset and pre-rotation
+  /// @param parameters The 7 joint parameters [tx, ty, tz, rx, ry, rz, scale]
+  /// @param parentState Optional parent joint state for hierarchical transformations
+  /// @param computeDeriv Whether to compute derivative information (translation/rotation axes)
+  void set(
+      const JointT<T>& joint,
+      const JointVectorT<T>& parameters,
+      const JointStateT<T>* parentState = nullptr,
+      bool computeDeriv = true) noexcept;
+
+  /// Calculates the derivative of a point with respect to rotation around a specific axis
+  ///
+  /// @param index The rotation axis index (0=X, 1=Y, 2=Z)
+  /// @param ref The reference point in global space
+  /// @return The derivative vector
+  [[nodiscard]] Vector3<T> getRotationDerivative(size_t index, const Vector3<T>& ref) const;
+
+  /// Calculates the derivative with respect to translation along a specific axis
+  ///
+  /// @param index The translation axis index (0=X, 1=Y, 2=Z)
+  /// @return The derivative vector
+  [[nodiscard]] Vector3<T> getTranslationDerivative(size_t index) const;
+
+  /// Calculates the derivative of a point with respect to uniform scaling
+  ///
+  /// @param ref The reference point in global space
+  /// @return The derivative vector
+  [[nodiscard]] Vector3<T> getScaleDerivative(const Vector3<T>& ref) const noexcept;
+
+  /// Copies state from another JointState with potentially different scalar type
+  ///
+  /// @tparam T2 Source scalar type
+  /// @param rhs Source joint state to copy from
+  template <typename T2>
+  void set(const JointStateT<T2>& rhs);
+
+  /// Access the joint's local rotation quaternion
+  [[nodiscard]] const Quaternion<T>& localRotation() const {
+    return localTransform.rotation;
+  }
+
+  /// Access the joint's local rotation quaternion (mutable)
+  Quaternion<T>& localRotation() {
+    return localTransform.rotation;
+  }
+
+  /// Access the joint's local translation vector
+  [[nodiscard]] const Vector3<T>& localTranslation() const {
+    return localTransform.translation;
+  }
+
+  /// Access the joint's local translation vector (mutable)
+  Vector3<T>& localTranslation() {
+    return localTransform.translation;
+  }
+
+  /// Access the joint's local scale factor
+  ///
+  /// This scale propagates to all descendant joints
+  [[nodiscard]] const T& localScale() const {
+    return localTransform.scale;
+  }
+
+  /// Access the joint's local scale factor (mutable)
+  T& localScale() {
+    return localTransform.scale;
+  }
+
+  /// Access the joint's global rotation quaternion
+  [[nodiscard]] const Quaternion<T>& rotation() const {
+    return transform.rotation;
+  }
+
+  /// Access the joint's global rotation quaternion (mutable)
+  Quaternion<T>& rotation() {
+    return transform.rotation;
+  }
+
+  /// Access the joint's global position vector
+  [[nodiscard]] const Vector3<T>& translation() const {
+    return transform.translation;
+  }
+
+  /// Access the joint's global position vector (mutable)
+  Vector3<T>& translation() {
+    return transform.translation;
+  }
+
+  /// Access the X component of the global position
+  [[nodiscard]] const T& x() const {
+    return transform.translation.x();
+  }
+
+  /// Access the X component of the global position (mutable)
+  T& x() {
+    return transform.translation.x();
+  }
+
+  /// Access the Y component of the global position
+  [[nodiscard]] const T& y() const {
+    return transform.translation.y();
+  }
+
+  /// Access the Y component of the global position (mutable)
+  T& y() {
+    return transform.translation.y();
+  }
+
+  /// Access the Z component of the global position
+  [[nodiscard]] const T& z() const {
+    return transform.translation.z();
+  }
+
+  /// Access the Z component of the global position (mutable)
+  T& z() {
+    return transform.translation.z();
+  }
+
+  /// Access the W component of the global rotation quaternion
+  [[nodiscard]] const T& quatW() const {
+    return transform.rotation.w();
+  }
+
+  /// Access the W component of the global rotation quaternion (mutable)
+  T& quatW() {
+    return transform.rotation.w();
+  }
+
+  /// Access the X component of the global rotation quaternion
+  [[nodiscard]] const T& quatX() const {
+    return transform.rotation.x();
+  }
+
+  /// Access the X component of the global rotation quaternion (mutable)
+  T& quatX() {
+    return transform.rotation.x();
+  }
+
+  /// Access the Y component of the global rotation quaternion
+  [[nodiscard]] const T& quatY() const {
+    return transform.rotation.y();
+  }
+
+  /// Access the Y component of the global rotation quaternion (mutable)
+  T& quatY() {
+    return transform.rotation.y();
+  }
+
+  /// Access the Z component of the global rotation quaternion
+  [[nodiscard]] const T& quatZ() const {
+    return transform.rotation.z();
+  }
+
+  /// Access the Z component of the global rotation quaternion (mutable)
+  T& quatZ() {
+    return transform.rotation.z();
+  }
+
+  /// Access the joint's global scale factor
+  ///
+  /// This is the cumulative scale from all parent joints
+  [[nodiscard]] const T& scale() const {
+    return transform.scale;
+  }
+
+  /// Access the joint's global scale factor (mutable)
+  T& scale() {
+    return transform.scale;
+  }
+
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+};
+
+/// Structure describing the state of all joints in a skeleton
+template <typename T>
+using JointStateListT = std::vector<JointStateT<T>>;
+
+using JointState = JointStateT<float>;
+using JointStateList = JointStateListT<float>;
+
+} // namespace momentum