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

include/momentum/diff_ik/fwd.h

@@ -0,0 +1,385 @@
+/*
+ * 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 {
+
+template <typename T>
+struct ErrorFunctionDerivativesT;
+using ErrorFunctionDerivatives = ErrorFunctionDerivativesT<float>;
+using ErrorFunctionDerivativesd = ErrorFunctionDerivativesT<double>;
+
+using ErrorFunctionDerivatives_p = ::std::shared_ptr<ErrorFunctionDerivatives>;
+using ErrorFunctionDerivatives_u = ::std::unique_ptr<ErrorFunctionDerivatives>;
+using ErrorFunctionDerivatives_w = ::std::weak_ptr<ErrorFunctionDerivatives>;
+using ErrorFunctionDerivatives_const_p = ::std::shared_ptr<const ErrorFunctionDerivatives>;
+using ErrorFunctionDerivatives_const_u = ::std::unique_ptr<const ErrorFunctionDerivatives>;
+using ErrorFunctionDerivatives_const_w = ::std::weak_ptr<const ErrorFunctionDerivatives>;
+
+using ErrorFunctionDerivativesd_p = ::std::shared_ptr<ErrorFunctionDerivativesd>;
+using ErrorFunctionDerivativesd_u = ::std::unique_ptr<ErrorFunctionDerivativesd>;
+using ErrorFunctionDerivativesd_w = ::std::weak_ptr<ErrorFunctionDerivativesd>;
+using ErrorFunctionDerivativesd_const_p = ::std::shared_ptr<const ErrorFunctionDerivativesd>;
+using ErrorFunctionDerivativesd_const_u = ::std::unique_ptr<const ErrorFunctionDerivativesd>;
+using ErrorFunctionDerivativesd_const_w = ::std::weak_ptr<const ErrorFunctionDerivativesd>;
+
+template <typename T>
+struct OrientationConstraintT;
+using OrientationConstraint = OrientationConstraintT<float>;
+using OrientationConstraintd = OrientationConstraintT<double>;
+
+using OrientationConstraint_p = ::std::shared_ptr<OrientationConstraint>;
+using OrientationConstraint_u = ::std::unique_ptr<OrientationConstraint>;
+using OrientationConstraint_w = ::std::weak_ptr<OrientationConstraint>;
+using OrientationConstraint_const_p = ::std::shared_ptr<const OrientationConstraint>;
+using OrientationConstraint_const_u = ::std::unique_ptr<const OrientationConstraint>;
+using OrientationConstraint_const_w = ::std::weak_ptr<const OrientationConstraint>;
+
+using OrientationConstraintd_p = ::std::shared_ptr<OrientationConstraintd>;
+using OrientationConstraintd_u = ::std::unique_ptr<OrientationConstraintd>;
+using OrientationConstraintd_w = ::std::weak_ptr<OrientationConstraintd>;
+using OrientationConstraintd_const_p = ::std::shared_ptr<const OrientationConstraintd>;
+using OrientationConstraintd_const_u = ::std::unique_ptr<const OrientationConstraintd>;
+using OrientationConstraintd_const_w = ::std::weak_ptr<const OrientationConstraintd>;
+
+template <typename T>
+struct OrientationConstraintStateT;
+using OrientationConstraintState = OrientationConstraintStateT<float>;
+using OrientationConstraintStated = OrientationConstraintStateT<double>;
+
+using OrientationConstraintState_p = ::std::shared_ptr<OrientationConstraintState>;
+using OrientationConstraintState_u = ::std::unique_ptr<OrientationConstraintState>;
+using OrientationConstraintState_w = ::std::weak_ptr<OrientationConstraintState>;
+using OrientationConstraintState_const_p = ::std::shared_ptr<const OrientationConstraintState>;
+using OrientationConstraintState_const_u = ::std::unique_ptr<const OrientationConstraintState>;
+using OrientationConstraintState_const_w = ::std::weak_ptr<const OrientationConstraintState>;
+
+using OrientationConstraintStated_p = ::std::shared_ptr<OrientationConstraintStated>;
+using OrientationConstraintStated_u = ::std::unique_ptr<OrientationConstraintStated>;
+using OrientationConstraintStated_w = ::std::weak_ptr<OrientationConstraintStated>;
+using OrientationConstraintStated_const_p = ::std::shared_ptr<const OrientationConstraintStated>;
+using OrientationConstraintStated_const_u = ::std::unique_ptr<const OrientationConstraintStated>;
+using OrientationConstraintStated_const_w = ::std::weak_ptr<const OrientationConstraintStated>;
+
+template <typename T>
+struct PositionConstraintT;
+using PositionConstraint = PositionConstraintT<float>;
+using PositionConstraintd = PositionConstraintT<double>;
+
+using PositionConstraint_p = ::std::shared_ptr<PositionConstraint>;
+using PositionConstraint_u = ::std::unique_ptr<PositionConstraint>;
+using PositionConstraint_w = ::std::weak_ptr<PositionConstraint>;
+using PositionConstraint_const_p = ::std::shared_ptr<const PositionConstraint>;
+using PositionConstraint_const_u = ::std::unique_ptr<const PositionConstraint>;
+using PositionConstraint_const_w = ::std::weak_ptr<const PositionConstraint>;
+
+using PositionConstraintd_p = ::std::shared_ptr<PositionConstraintd>;
+using PositionConstraintd_u = ::std::unique_ptr<PositionConstraintd>;
+using PositionConstraintd_w = ::std::weak_ptr<PositionConstraintd>;
+using PositionConstraintd_const_p = ::std::shared_ptr<const PositionConstraintd>;
+using PositionConstraintd_const_u = ::std::unique_ptr<const PositionConstraintd>;
+using PositionConstraintd_const_w = ::std::weak_ptr<const PositionConstraintd>;
+
+template <typename T>
+struct PositionConstraintStateT;
+using PositionConstraintState = PositionConstraintStateT<float>;
+using PositionConstraintStated = PositionConstraintStateT<double>;
+
+using PositionConstraintState_p = ::std::shared_ptr<PositionConstraintState>;
+using PositionConstraintState_u = ::std::unique_ptr<PositionConstraintState>;
+using PositionConstraintState_w = ::std::weak_ptr<PositionConstraintState>;
+using PositionConstraintState_const_p = ::std::shared_ptr<const PositionConstraintState>;
+using PositionConstraintState_const_u = ::std::unique_ptr<const PositionConstraintState>;
+using PositionConstraintState_const_w = ::std::weak_ptr<const PositionConstraintState>;
+
+using PositionConstraintStated_p = ::std::shared_ptr<PositionConstraintStated>;
+using PositionConstraintStated_u = ::std::unique_ptr<PositionConstraintStated>;
+using PositionConstraintStated_w = ::std::weak_ptr<PositionConstraintStated>;
+using PositionConstraintStated_const_p = ::std::shared_ptr<const PositionConstraintStated>;
+using PositionConstraintStated_const_u = ::std::unique_ptr<const PositionConstraintStated>;
+using PositionConstraintStated_const_w = ::std::weak_ptr<const PositionConstraintStated>;
+
+template <typename T>
+class FullyDifferentiableDistanceErrorFunctionT;
+using FullyDifferentiableDistanceErrorFunction = FullyDifferentiableDistanceErrorFunctionT<float>;
+using FullyDifferentiableDistanceErrorFunctiond = FullyDifferentiableDistanceErrorFunctionT<double>;
+
+using FullyDifferentiableDistanceErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiableDistanceErrorFunction>;
+using FullyDifferentiableDistanceErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiableDistanceErrorFunction>;
+using FullyDifferentiableDistanceErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiableDistanceErrorFunction>;
+using FullyDifferentiableDistanceErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiableDistanceErrorFunction>;
+using FullyDifferentiableDistanceErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiableDistanceErrorFunction>;
+using FullyDifferentiableDistanceErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiableDistanceErrorFunction>;
+
+using FullyDifferentiableDistanceErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiableDistanceErrorFunctiond>;
+using FullyDifferentiableDistanceErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiableDistanceErrorFunctiond>;
+using FullyDifferentiableDistanceErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiableDistanceErrorFunctiond>;
+using FullyDifferentiableDistanceErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiableDistanceErrorFunctiond>;
+using FullyDifferentiableDistanceErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiableDistanceErrorFunctiond>;
+using FullyDifferentiableDistanceErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiableDistanceErrorFunctiond>;
+
+template <typename T>
+class FullyDifferentiableMotionErrorFunctionT;
+using FullyDifferentiableMotionErrorFunction = FullyDifferentiableMotionErrorFunctionT<float>;
+using FullyDifferentiableMotionErrorFunctiond = FullyDifferentiableMotionErrorFunctionT<double>;
+
+using FullyDifferentiableMotionErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiableMotionErrorFunction>;
+using FullyDifferentiableMotionErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiableMotionErrorFunction>;
+using FullyDifferentiableMotionErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiableMotionErrorFunction>;
+using FullyDifferentiableMotionErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiableMotionErrorFunction>;
+using FullyDifferentiableMotionErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiableMotionErrorFunction>;
+using FullyDifferentiableMotionErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiableMotionErrorFunction>;
+
+using FullyDifferentiableMotionErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiableMotionErrorFunctiond>;
+using FullyDifferentiableMotionErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiableMotionErrorFunctiond>;
+using FullyDifferentiableMotionErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiableMotionErrorFunctiond>;
+using FullyDifferentiableMotionErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiableMotionErrorFunctiond>;
+using FullyDifferentiableMotionErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiableMotionErrorFunctiond>;
+using FullyDifferentiableMotionErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiableMotionErrorFunctiond>;
+
+template <typename T>
+class FullyDifferentiableOrientationErrorFunctionT;
+using FullyDifferentiableOrientationErrorFunction =
+    FullyDifferentiableOrientationErrorFunctionT<float>;
+using FullyDifferentiableOrientationErrorFunctiond =
+    FullyDifferentiableOrientationErrorFunctionT<double>;
+
+using FullyDifferentiableOrientationErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiableOrientationErrorFunction>;
+using FullyDifferentiableOrientationErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiableOrientationErrorFunction>;
+using FullyDifferentiableOrientationErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiableOrientationErrorFunction>;
+using FullyDifferentiableOrientationErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiableOrientationErrorFunction>;
+using FullyDifferentiableOrientationErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiableOrientationErrorFunction>;
+using FullyDifferentiableOrientationErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiableOrientationErrorFunction>;
+
+using FullyDifferentiableOrientationErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiableOrientationErrorFunctiond>;
+using FullyDifferentiableOrientationErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiableOrientationErrorFunctiond>;
+using FullyDifferentiableOrientationErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiableOrientationErrorFunctiond>;
+using FullyDifferentiableOrientationErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiableOrientationErrorFunctiond>;
+using FullyDifferentiableOrientationErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiableOrientationErrorFunctiond>;
+using FullyDifferentiableOrientationErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiableOrientationErrorFunctiond>;
+
+template <typename T>
+class FullyDifferentiablePosePriorErrorFunctionT;
+using FullyDifferentiablePosePriorErrorFunction = FullyDifferentiablePosePriorErrorFunctionT<float>;
+using FullyDifferentiablePosePriorErrorFunctiond =
+    FullyDifferentiablePosePriorErrorFunctionT<double>;
+
+using FullyDifferentiablePosePriorErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiablePosePriorErrorFunction>;
+using FullyDifferentiablePosePriorErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiablePosePriorErrorFunction>;
+using FullyDifferentiablePosePriorErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiablePosePriorErrorFunction>;
+using FullyDifferentiablePosePriorErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiablePosePriorErrorFunction>;
+using FullyDifferentiablePosePriorErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiablePosePriorErrorFunction>;
+using FullyDifferentiablePosePriorErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiablePosePriorErrorFunction>;
+
+using FullyDifferentiablePosePriorErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiablePosePriorErrorFunctiond>;
+using FullyDifferentiablePosePriorErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiablePosePriorErrorFunctiond>;
+using FullyDifferentiablePosePriorErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiablePosePriorErrorFunctiond>;
+using FullyDifferentiablePosePriorErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiablePosePriorErrorFunctiond>;
+using FullyDifferentiablePosePriorErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiablePosePriorErrorFunctiond>;
+using FullyDifferentiablePosePriorErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiablePosePriorErrorFunctiond>;
+
+template <typename T>
+class FullyDifferentiablePositionErrorFunctionT;
+using FullyDifferentiablePositionErrorFunction = FullyDifferentiablePositionErrorFunctionT<float>;
+using FullyDifferentiablePositionErrorFunctiond = FullyDifferentiablePositionErrorFunctionT<double>;
+
+using FullyDifferentiablePositionErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiablePositionErrorFunction>;
+using FullyDifferentiablePositionErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiablePositionErrorFunction>;
+using FullyDifferentiablePositionErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiablePositionErrorFunction>;
+using FullyDifferentiablePositionErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiablePositionErrorFunction>;
+using FullyDifferentiablePositionErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiablePositionErrorFunction>;
+using FullyDifferentiablePositionErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiablePositionErrorFunction>;
+
+using FullyDifferentiablePositionErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiablePositionErrorFunctiond>;
+using FullyDifferentiablePositionErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiablePositionErrorFunctiond>;
+using FullyDifferentiablePositionErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiablePositionErrorFunctiond>;
+using FullyDifferentiablePositionErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiablePositionErrorFunctiond>;
+using FullyDifferentiablePositionErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiablePositionErrorFunctiond>;
+using FullyDifferentiablePositionErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiablePositionErrorFunctiond>;
+
+template <typename T>
+class FullyDifferentiableProjectionErrorFunctionT;
+using FullyDifferentiableProjectionErrorFunction =
+    FullyDifferentiableProjectionErrorFunctionT<float>;
+using FullyDifferentiableProjectionErrorFunctiond =
+    FullyDifferentiableProjectionErrorFunctionT<double>;
+
+using FullyDifferentiableProjectionErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiableProjectionErrorFunction>;
+using FullyDifferentiableProjectionErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiableProjectionErrorFunction>;
+using FullyDifferentiableProjectionErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiableProjectionErrorFunction>;
+using FullyDifferentiableProjectionErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiableProjectionErrorFunction>;
+using FullyDifferentiableProjectionErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiableProjectionErrorFunction>;
+using FullyDifferentiableProjectionErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiableProjectionErrorFunction>;
+
+using FullyDifferentiableProjectionErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiableProjectionErrorFunctiond>;
+using FullyDifferentiableProjectionErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiableProjectionErrorFunctiond>;
+using FullyDifferentiableProjectionErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiableProjectionErrorFunctiond>;
+using FullyDifferentiableProjectionErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiableProjectionErrorFunctiond>;
+using FullyDifferentiableProjectionErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiableProjectionErrorFunctiond>;
+using FullyDifferentiableProjectionErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiableProjectionErrorFunctiond>;
+
+template <typename T>
+class FullyDifferentiableSkeletonErrorFunctionT;
+using FullyDifferentiableSkeletonErrorFunction = FullyDifferentiableSkeletonErrorFunctionT<float>;
+using FullyDifferentiableSkeletonErrorFunctiond = FullyDifferentiableSkeletonErrorFunctionT<double>;
+
+using FullyDifferentiableSkeletonErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiableSkeletonErrorFunction>;
+using FullyDifferentiableSkeletonErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiableSkeletonErrorFunction>;
+using FullyDifferentiableSkeletonErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiableSkeletonErrorFunction>;
+using FullyDifferentiableSkeletonErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiableSkeletonErrorFunction>;
+using FullyDifferentiableSkeletonErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiableSkeletonErrorFunction>;
+using FullyDifferentiableSkeletonErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiableSkeletonErrorFunction>;
+
+using FullyDifferentiableSkeletonErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiableSkeletonErrorFunctiond>;
+using FullyDifferentiableSkeletonErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiableSkeletonErrorFunctiond>;
+using FullyDifferentiableSkeletonErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiableSkeletonErrorFunctiond>;
+using FullyDifferentiableSkeletonErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiableSkeletonErrorFunctiond>;
+using FullyDifferentiableSkeletonErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiableSkeletonErrorFunctiond>;
+using FullyDifferentiableSkeletonErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiableSkeletonErrorFunctiond>;
+
+template <typename T>
+class FullyDifferentiableStateErrorFunctionT;
+using FullyDifferentiableStateErrorFunction = FullyDifferentiableStateErrorFunctionT<float>;
+using FullyDifferentiableStateErrorFunctiond = FullyDifferentiableStateErrorFunctionT<double>;
+
+using FullyDifferentiableStateErrorFunction_p =
+    ::std::shared_ptr<FullyDifferentiableStateErrorFunction>;
+using FullyDifferentiableStateErrorFunction_u =
+    ::std::unique_ptr<FullyDifferentiableStateErrorFunction>;
+using FullyDifferentiableStateErrorFunction_w =
+    ::std::weak_ptr<FullyDifferentiableStateErrorFunction>;
+using FullyDifferentiableStateErrorFunction_const_p =
+    ::std::shared_ptr<const FullyDifferentiableStateErrorFunction>;
+using FullyDifferentiableStateErrorFunction_const_u =
+    ::std::unique_ptr<const FullyDifferentiableStateErrorFunction>;
+using FullyDifferentiableStateErrorFunction_const_w =
+    ::std::weak_ptr<const FullyDifferentiableStateErrorFunction>;
+
+using FullyDifferentiableStateErrorFunctiond_p =
+    ::std::shared_ptr<FullyDifferentiableStateErrorFunctiond>;
+using FullyDifferentiableStateErrorFunctiond_u =
+    ::std::unique_ptr<FullyDifferentiableStateErrorFunctiond>;
+using FullyDifferentiableStateErrorFunctiond_w =
+    ::std::weak_ptr<FullyDifferentiableStateErrorFunctiond>;
+using FullyDifferentiableStateErrorFunctiond_const_p =
+    ::std::shared_ptr<const FullyDifferentiableStateErrorFunctiond>;
+using FullyDifferentiableStateErrorFunctiond_const_u =
+    ::std::unique_ptr<const FullyDifferentiableStateErrorFunctiond>;
+using FullyDifferentiableStateErrorFunctiond_const_w =
+    ::std::weak_ptr<const FullyDifferentiableStateErrorFunctiond>;
+
+template <typename T>
+class UnionErrorFunctionT;
+using UnionErrorFunction = UnionErrorFunctionT<float>;
+using UnionErrorFunctiond = UnionErrorFunctionT<double>;
+
+using UnionErrorFunction_p = ::std::shared_ptr<UnionErrorFunction>;
+using UnionErrorFunction_u = ::std::unique_ptr<UnionErrorFunction>;
+using UnionErrorFunction_w = ::std::weak_ptr<UnionErrorFunction>;
+using UnionErrorFunction_const_p = ::std::shared_ptr<const UnionErrorFunction>;
+using UnionErrorFunction_const_u = ::std::unique_ptr<const UnionErrorFunction>;
+using UnionErrorFunction_const_w = ::std::weak_ptr<const UnionErrorFunction>;
+
+using UnionErrorFunctiond_p = ::std::shared_ptr<UnionErrorFunctiond>;
+using UnionErrorFunctiond_u = ::std::unique_ptr<UnionErrorFunctiond>;
+using UnionErrorFunctiond_w = ::std::weak_ptr<UnionErrorFunctiond>;
+using UnionErrorFunctiond_const_p = ::std::shared_ptr<const UnionErrorFunctiond>;
+using UnionErrorFunctiond_const_u = ::std::unique_ptr<const UnionErrorFunctiond>;
+using UnionErrorFunctiond_const_w = ::std::weak_ptr<const UnionErrorFunctiond>;
+
+} // namespace momentum

include/momentum/diff_ik/union_error_function.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_solver/skeleton_error_function.h>
+#include <momentum/diff_ik/fully_differentiable_skeleton_error_function.h>
+
+#include <unordered_map>
+
+namespace momentum {
+
+template <typename T>
+class UnionErrorFunctionT : public SkeletonErrorFunctionT<T>,
+                            public virtual FullyDifferentiableSkeletonErrorFunctionT<T> {
+ public:
+  UnionErrorFunctionT(
+      const Skeleton& skel,
+      const ParameterTransform& pt,
+      const std::vector<std::shared_ptr<SkeletonErrorFunctionT<T>>>& errorFunctions);
+
+  [[nodiscard]] double getError(
+      const ModelParametersT<T>& params,
+      const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState) final;
+  double getGradient(
+      const ModelParametersT<T>& params,
+      const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState,
+      Eigen::Ref<Eigen::VectorX<T>> gradient) final;
+  double getJacobian(
+      const ModelParametersT<T>& params,
+      const SkeletonStateT<T>& state,
+      const MeshStateT<T>& meshState,
+      Eigen::Ref<Eigen::MatrixX<T>> jacobian,
+      Eigen::Ref<Eigen::VectorX<T>> residual,
+      int& usedRows) final;
+  [[nodiscard]] size_t getJacobianSize() const final;
+
+  std::vector<std::string> inputs() const override;
+  void getInputImp(const std::string& name, Eigen::Ref<Eigen::VectorX<T>> result) const override;
+  void setInputImp(const std::string& name, Eigen::Ref<const Eigen::VectorX<T>> value) override;
+  Eigen::Index getInputSize(const std::string& name) const override;
+  const char* name() const override {
+    return name_.c_str();
+  }
+
+  Eigen::VectorX<T> d_gradient_d_input_dot(
+      const std::string& inputName,
+      const ModelParametersT<T>& modelParams,
+      const SkeletonStateT<T>& state,
+      Eigen::Ref<const Eigen::VectorX<T>> inputVec) override;
+
+ private:
+  std::vector<std::shared_ptr<SkeletonErrorFunctionT<T>>> errorFunctions_;
+  std::vector<std::shared_ptr<FullyDifferentiableSkeletonErrorFunctionT<T>>> diffErrorFunctions_;
+  std::string name_;
+
+  // For each input, which error functions support that input
+  std::unordered_map<std::string, std::vector<size_t>> inputs_;
+};
+
+} // namespace momentum

include/momentum/gui/rerun/eigen_adapters.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 <rerun.hpp>
+#include <Eigen/Core>
+
+#include <algorithm>
+#include <cstring>
+#include <vector>
+
+namespace rerun {
+
+// Rerun Adapter for Eigen::Vector3<T>
+template <typename TElement, typename T>
+struct CollectionAdapter<TElement, std::vector<Eigen::Vector3<T>>> {
+  /// Borrow for non-temporary.
+  Collection<TElement> operator()(const std::vector<Eigen::Vector3<T>>& container) {
+    return Collection<TElement>::borrow(container.data(), container.size());
+  }
+
+  // Do a full copy for temporaries (otherwise the data might be deleted when the temporary is
+  // destroyed).
+  Collection<TElement> operator()(std::vector<Eigen::Vector3<T>>&& container) {
+    std::vector<TElement> positions(container.size());
+    std::memcpy(positions.data(), container.data(), container.size() * sizeof(Eigen::Vector3<T>));
+    return Collection<TElement>::take_ownership(std::move(positions));
+  }
+};
+
+// Rerun Adapter for Eigen::Vector4<T>
+template <typename TElement, typename T>
+struct CollectionAdapter<TElement, std::vector<Eigen::Vector4<T>>> {
+  /// Borrow for non-temporary.
+  Collection<TElement> operator()(const std::vector<Eigen::Vector4<T>>& container) {
+    return Collection<TElement>::borrow(container.data(), container.size());
+  }
+
+  // Do a full copy for temporaries (otherwise the data might be deleted when the temporary is
+  // destroyed).
+  Collection<TElement> operator()(std::vector<Eigen::Vector4<T>>&& container) {
+    std::vector<TElement> positions(container.size());
+    std::memcpy(positions.data(), container.data(), container.size() * sizeof(Eigen::Vector4<T>));
+    return Collection<TElement>::take_ownership(std::move(positions));
+  }
+};
+
+// Adapter for converting a vector of Eigen::Vector3b to a vector of rerun::Color
+template <>
+struct CollectionAdapter<Color, std::vector<Eigen::Vector3<uint8_t>>> {
+  Collection<Color> operator()(const std::vector<Eigen::Vector3<uint8_t>>& container) {
+    std::vector<rerun::Color> colors;
+    colors.reserve(container.size());
+    std::transform(
+        container.cbegin(),
+        container.cend(),
+        std::back_inserter(colors),
+        [](const Eigen::Vector3<uint8_t>& vertexColor) {
+          return rerun::Color(vertexColor[0], vertexColor[1], vertexColor[2]);
+        });
+    return Collection<Color>::take_ownership(std::move(colors));
+  }
+};
+
+} // namespace rerun

include/momentum/gui/rerun/logger.h

@@ -0,0 +1,102 @@
+/*
+ * 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/fwd.h>
+#include <momentum/character/locator.h>
+#include <momentum/character/locator_state.h>
+#include <momentum/character/marker.h>
+
+#include <rerun.hpp>
+
+#include <map>
+#include <string>
+
+namespace momentum {
+
+/// @param[in] (Optional) The color to use for the mesh. If not provided, the colors stored in the
+/// mesh are used.
+void logMesh(
+    const rerun::RecordingStream& rec,
+    const std::string& streamName,
+    const Mesh& mesh,
+    std::optional<rerun::Color> color = std::nullopt);
+
+void logJoints(
+    const rerun::RecordingStream& rec,
+    const std::string& streamName,
+    const Skeleton& skeleton,
+    const JointStateList& jointStates);
+
+void logMarkers(
+    const rerun::RecordingStream& rec,
+    const std::string& streamName,
+    gsl::span<const Marker> markers);
+
+void logLocators(
+    const rerun::RecordingStream& rec,
+    const std::string& streamName,
+    const LocatorList& locators,
+    const LocatorState& locatorState);
+
+void logMarkerLocatorCorrespondence(
+    const rerun::RecordingStream& rec,
+    const std::string& streamName,
+    const std::map<std::string, size_t>& locatorLookup,
+    const LocatorState& locatorState,
+    gsl::span<const Marker> markers,
+    float kPositionErrorThreshold);
+
+void logBvh(
+    const rerun::RecordingStream& rec,
+    const std::string& streamName,
+    const CollisionGeometry& collisionGeometry,
+    const SkeletonState& skeletonState);
+
+void logCollisionGeometry(
+    const rerun::RecordingStream& rec,
+    const std::string& streamName,
+    const CollisionGeometry& collisionGeometry,
+    const SkeletonState& skeletonState);
+
+void logCharacter(
+    const rerun::RecordingStream& rec,
+    const std::string& charStreamName,
+    const Character& character,
+    const CharacterState& characterState,
+    const rerun::Color& color = rerun::Color(200, 200, 200));
+
+// Separate logs for world parameters vs pose parameters because they are in different scale
+void logModelParams(
+    const rerun::RecordingStream& rec,
+    const std::string& worldPrefix,
+    const std::string& posePrefix,
+    gsl::span<const std::string> names,
+    const Eigen::VectorXf& params);
+
+void logJointParams(
+    const rerun::RecordingStream& rec,
+    const std::string& worldPrefix,
+    const std::string& posePrefix,
+    gsl::span<const std::string> names,
+    const Eigen::VectorXf& params);
+
+void logModelParamNames(
+    const rerun::RecordingStream& rec,
+    const std::string& worldPrefix,
+    const std::string& posePrefix,
+    gsl::span<const std::string> names);
+
+void logJointParamNames(
+    const rerun::RecordingStream& rec,
+    const std::string& worldPrefix,
+    const std::string& posePrefix,
+    gsl::span<const std::string> names);
+
+} // namespace momentum

include/momentum/gui/rerun/logging_redirect.h

@@ -0,0 +1,27 @@
+/*
+ * 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 <rerun.hpp>
+
+#include <string>
+
+namespace momentum {
+
+/// Redirects logs from the XR_LOG framework to the Rerun logger.
+///
+/// This function registers a custom log sink for the XR_LOG framework, redirecting its log messages
+/// to the Rerun logger. The redirection is only performed once, and subsequent calls to this
+/// function have no effect.
+///
+/// @param[in] rec The recording stream to which to write the logs. You should make sure the
+/// lifetime of this is longer than the loggings from momentum libraries.
+/// @return Returns true if the redirection is successful or has already been done.
+bool redirectLogsToRerun(const rerun::RecordingStream& rec);
+
+} // namespace momentum