pymomentum-cpu 0.0.0__cp312-cp312-manylinux_2_39_x86_64.whl

include/momentum/character_solver/vertex_vertex_distance_error_function.h

@@ -0,0 +1,143 @@
+/*
+ * 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/fwd.h>
+#include <momentum/character_solver/skeleton_error_function.h>
+#include <momentum/math/fwd.h>
+
+#include <Eigen/Dense>
+#include <memory>
+#include <vector>
+
+namespace momentum {
+
+/// Constraint for vertex-to-vertex distance errors
+template <typename T>
+struct VertexVertexDistanceConstraintT {
+  int vertexIndex1 = -1; ///< First vertex index
+  int vertexIndex2 = -1; ///< Second vertex index
+  T weight = 1; ///< Constraint weight
+  T targetDistance = 0; ///< Desired distance between the two vertices
+
+  template <typename T2>
+  VertexVertexDistanceConstraintT<T2> cast() const {
+    return {
+        this->vertexIndex1,
+        this->vertexIndex2,
+        static_cast<T2>(this->weight),
+        static_cast<T2>(this->targetDistance)};
+  }
+};
+
+/// Error function for vertex-to-vertex distance constraints
+template <typename T>
+class VertexVertexDistanceErrorFunctionT : public SkeletonErrorFunctionT<T> {
+ public:
+  explicit VertexVertexDistanceErrorFunctionT(const Character& character);
+  ~VertexVertexDistanceErrorFunctionT() override;
+
+  VertexVertexDistanceErrorFunctionT(const VertexVertexDistanceErrorFunctionT& other) = delete;
+  VertexVertexDistanceErrorFunctionT(VertexVertexDistanceErrorFunctionT&& other) noexcept = delete;
+  VertexVertexDistanceErrorFunctionT& operator=(const VertexVertexDistanceErrorFunctionT& other) =
+      delete;
+  VertexVertexDistanceErrorFunctionT& operator=(VertexVertexDistanceErrorFunctionT&& other) =
+      delete;
+
+  [[nodiscard]] double getError(
+      const ModelParametersT<T>& modelParameters,
+      const SkeletonStateT<T>& state) final;
+
+  double getGradient(
+      const ModelParametersT<T>& modelParameters,
+      const SkeletonStateT<T>& state,
+      Eigen::Ref<Eigen::VectorX<T>> gradient) final;
+
+  double getJacobian(
+      const ModelParametersT<T>& modelParameters,
+      const SkeletonStateT<T>& state,
+      Eigen::Ref<Eigen::MatrixX<T>> jacobian,
+      Eigen::Ref<Eigen::VectorX<T>> residual,
+      int& usedRows) final;
+
+  [[nodiscard]] size_t getJacobianSize() const final;
+
+  /// Add a vertex-to-vertex distance constraint
+  void addConstraint(int vertexIndex1, int vertexIndex2, T weight, T targetDistance);
+
+  /// Clear all constraints
+  void clearConstraints();
+
+  /// Get all constraints
+  [[nodiscard]] const std::vector<VertexVertexDistanceConstraintT<T>>& getConstraints() const {
+    return constraints_;
+  }
+
+  /// Get the number of constraints
+  [[nodiscard]] size_t numConstraints() const {
+    return constraints_.size();
+  }
+
+  /// Get the character
+  [[nodiscard]] const Character& getCharacter() const {
+    return character_;
+  }
+
+ private:
+  /// Calculate jacobian for a distance constraint
+  double calculateJacobian(
+      const ModelParametersT<T>& modelParameters,
+      const SkeletonStateT<T>& state,
+      const VertexVertexDistanceConstraintT<T>& constraint,
+      Eigen::Ref<Eigen::MatrixX<T>> jacobian,
+      T& residual) const;
+
+  /// Calculate gradient for a distance constraint
+  double calculateGradient(
+      const ModelParametersT<T>& modelParameters,
+      const SkeletonStateT<T>& state,
+      const VertexVertexDistanceConstraintT<T>& constraint,
+      Eigen::Ref<Eigen::VectorX<T>> gradient) const;
+
+  /// Calculate gradient contribution from a single vertex
+  void calculateVertexGradient(
+      const ModelParametersT<T>& modelParameters,
+      const SkeletonStateT<T>& state,
+      int vertexIndex,
+      const Eigen::Vector3<T>& gradientDirection,
+      Eigen::Ref<Eigen::VectorX<T>> gradient) const;
+
+  /// Calculate jacobian contribution from a single vertex
+  void calculateVertexJacobian(
+      const ModelParametersT<T>& modelParameters,
+      const SkeletonStateT<T>& state,
+      int vertexIndex,
+      const Eigen::Vector3<T>& jacobianDirection,
+      Eigen::Ref<Eigen::MatrixX<T>> jacobian) const;
+
+  /// Calculate world space position derivative for blend shape parameters
+  void calculateDWorldPos(
+      const SkeletonStateT<T>& state,
+      int vertexIndex,
+      const Eigen::Vector3<T>& d_restPos,
+      Eigen::Vector3<T>& d_worldPos) const;
+
+  /// Update the meshes with current parameters and state
+  void updateMeshes(const ModelParametersT<T>& modelParameters, const SkeletonStateT<T>& state);
+
+  const Character& character_;
+
+  std::vector<VertexVertexDistanceConstraintT<T>> constraints_;
+
+  /// Mesh used to store rest positions
+  std::unique_ptr<MeshT<T>> restMesh_;
+  /// Mesh used to store posed positions
+  std::unique_ptr<MeshT<T>> posedMesh_;
+};
+
+} // namespace momentum

include/momentum/common/aligned.h

@@ -0,0 +1,155 @@
+/*
+ * 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/common/exception.h>
+
+#include <limits>
+#include <memory>
+
+namespace momentum {
+
+#if defined(_WIN32)
+
+[[nodiscard]] inline void* aligned_malloc(size_t size, size_t align) {
+  return _aligned_malloc(size, align);
+}
+
+inline void aligned_free(void* ptr) {
+  return _aligned_free(ptr);
+}
+
+#elif (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000) || \
+    (defined(__ANDROID_API__) && __ANDROID_API__ < 28)
+
+[[nodiscard]] inline void* aligned_malloc(size_t size, size_t align) {
+  void* result = nullptr;
+  posix_memalign(&result, align, size);
+  return result;
+}
+
+inline void aligned_free(void* ptr) {
+  return std::free(ptr);
+}
+
+#else
+
+[[nodiscard]] inline void* aligned_malloc(size_t size, size_t align) {
+  return std::aligned_alloc(align, size);
+}
+
+inline void aligned_free(void* ptr) {
+  return std::free(ptr);
+}
+
+#endif
+
+inline constexpr std::size_t roundUpToAlignment(std::size_t value, std::size_t alignment) {
+  MT_THROW_IF_T(alignment == 0, std::invalid_argument, "Alignment must be non-zero");
+  return ((value + alignment - 1) / alignment) * alignment;
+}
+
+/// Allocates a block of memory that can hold `n` elements of type `T` with the specified alignment.
+///
+/// This function is intended to be used in the `AlignedAllocator::allocate()` method and throws
+/// exceptions as `std::allocator<T>::allocate` does.
+template <typename T, std::size_t Alignment = alignof(T)>
+[[nodiscard]] T* alignedAlloc(std::size_t n) {
+  MT_THROW_IF_T(std::numeric_limits<std::size_t>::max() / sizeof(T) < n, std::bad_array_new_length);
+
+  const std::size_t size = roundUpToAlignment(n * sizeof(T), Alignment);
+  void* ptr = aligned_malloc(size, Alignment);
+
+  MT_THROW_IF_T(ptr == nullptr, std::bad_alloc);
+
+  return static_cast<T*>(ptr);
+}
+
+/// Custom deleter for aligned memory
+struct AlignedDeleter {
+  void operator()(void* ptr) const {
+    aligned_free(ptr);
+  }
+};
+
+/// Creates a std::unique_ptr for aligned memory.
+template <typename T, std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
+[[nodiscard]] std::unique_ptr<T, Deleter> makeAlignedUnique(
+    std::size_t n,
+    Deleter deleter = Deleter()) {
+  return std::unique_ptr<T, Deleter>(alignedAlloc<T, Alignment>(n), std::move(deleter));
+}
+
+/// Creates a std::shared_ptr for aligned memory.
+template <typename T, std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
+[[nodiscard]] std::shared_ptr<T> makeAlignedShared(std::size_t n, Deleter deleter = Deleter()) {
+  return std::shared_ptr<T>(alignedAlloc<T, Alignment>(n), std::move(deleter));
+}
+
+/// An allocator that aligns memory blocks according to a specified alignment.
+/// The allocator is compatible with `std::allocator` and can be used in
+/// place of `std::allocator` in STL containers.
+///
+/// @tparam T The type of elements that the allocator will allocate.
+/// @tparam Alignment The alignment for the allocated memory blocks.
+template <class T, std::size_t Alignment>
+class AlignedAllocator {
+ public:
+  using value_type = T;
+
+  AlignedAllocator() noexcept = default;
+
+  template <class U>
+  explicit AlignedAllocator(const AlignedAllocator<U, Alignment>& /*other*/) noexcept {
+    // Empty
+  }
+
+  /// Allocates a block of memory that can hold `n` elements of type `T`.
+  ///
+  /// @param[in] n The number of elements to allocate space for.
+  /// @return A pointer to the first byte of the allocated memory block.
+  [[nodiscard]] T* allocate(std::size_t n) {
+    return alignedAlloc<T, Alignment>(n);
+  }
+
+  /// Deallocates a block of memory that was previously allocated by `allocate`.
+  ///
+  /// @param[in] ptr A pointer to the first byte of the memory block to deallocate.
+  /// @param size The size of the memory block to deallocate. This parameter is not used, but it is
+  /// included to maintain compatibility with `std::allocator`.
+  void deallocate(T* ptr, std::size_t /*n*/) noexcept {
+    aligned_free(ptr);
+  }
+
+  template <class U>
+  struct rebind {
+    using other = AlignedAllocator<U, Alignment>;
+  };
+};
+
+/// Checks if storage allocated from `lhs` can be deallocated from `rhs`, and vice versa.
+///
+/// This always returns true for stateless allocators.
+template <class T, class U, std::size_t Alignment>
+[[nodiscard]] bool operator==(
+    const AlignedAllocator<T, Alignment>& /*lhs*/,
+    const AlignedAllocator<U, Alignment>& /*rhs*/) {
+  return true;
+}
+
+/// Checks if storage allocated from `lhs` cannot be deallocated from `rhs`, and vice versa.
+///
+/// This always returns false for stateless allocators.
+template <class T, class U, std::size_t Alignment>
+[[nodiscard]] bool operator!=(
+    const AlignedAllocator<T, Alignment>& /*lhs*/,
+    const AlignedAllocator<U, Alignment>& /*rhs*/) {
+  return false;
+}
+
+} // namespace momentum

include/momentum/common/checks.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
+
+#if defined(MOMENTUM_WITH_XR_LOGGER)
+
+#include <logging/Checks.h>
+
+#define MT_CHECK(condition, ...) XR_CHECK(condition, __VA_ARGS__)
+#define MT_CHECK_LT(val1, val2, ...) XR_CHECK_DETAIL_OP1(val1, val2, <, ##__VA_ARGS__)
+#define MT_CHECK_NOTNULL(ptr, ...) XR_CHECK(ptr != nullptr, ##__VA_ARGS__)
+
+#else
+
+#include <cassert>
+
+// TODO: Support asserts with messages as XR_CHECK does
+#define MT_CHECK(condition, ...) assert(condition)
+#define MT_CHECK_LT(val1, val2, ...) assert(val1 < val2)
+#define MT_CHECK_NOTNULL(ptr, ...) assert(ptr != nullptr)
+
+#endif

include/momentum/common/exception.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 <fmt/format.h>
+
+#include <stdexcept>
+
+/// Throws an exception of a specified type with a formatted message.
+/// @param Exception The type of exception to throw.
+/// @param ... The message and format specifiers.
+/// @code
+///   MT_THROW_T(std::invalid_argument, "Invalid argument: {}", arg);
+///   MT_THROW_T(std::bad_array_new_length); // No message
+/// @endcode
+#define MT_THROW_T(Exception, ...) ::momentum::detail::throwImpl<Exception>(__VA_ARGS__)
+
+/// Throws a std::runtime_error with a formatted message.
+/// @param ... The message and format specifiers.
+/// @code
+///   MT_THROW("Error occurred: {}", errorDetail);
+/// @endcode
+#define MT_THROW(...) MT_THROW_T(::momentum::detail::DefaultException, ##__VA_ARGS__)
+
+/// Conditionally throws an exception of a specified type with a formatted message if the condition
+/// is true.
+/// @param Condition The condition to evaluate.
+/// @param Exception The type of exception to throw.
+/// @param ... The message and format specifiers.
+/// @code
+///   MT_THROW_IF_T(x > y, std::out_of_range, "x ({}) is greater than y ({})", x, y);
+///   MT_THROW_IF_T(x > y, std::bad_array_new_length); // No message
+/// @endcode
+#define MT_THROW_IF_T(Condition, Exception, ...) \
+  if (Condition) {                               \
+    MT_THROW_T(Exception, ##__VA_ARGS__);        \
+  }
+
+/// Conditionally throws a std::runtime_error with a formatted message if the condition is true.
+/// @param Condition The condition to evaluate.
+/// @param ... The message and format specifiers.
+/// @code
+///   MT_THROW_IF(x == nullptr, "x cannot be nullptr");
+/// @endcode
+#define MT_THROW_IF(Condition, ...) \
+  MT_THROW_IF_T(Condition, ::momentum::detail::DefaultException, ##__VA_ARGS__)
+
+namespace momentum::detail {
+
+using DefaultException = std::runtime_error;
+
+// Helper function template to throw with formatted message
+template <typename Exception = DefaultException, typename... Args>
+[[noreturn]] void throwImpl(fmt::format_string<Args...> format, Args&&... args) {
+  throw Exception{fmt::format(format, std::forward<Args>(args)...)};
+}
+
+// Overload for throwing exceptions that do not require any message or whose constructors do not
+// take any arguments.
+template <typename Exception>
+[[noreturn]] void throwImpl() {
+  throw Exception{};
+}
+
+} // namespace momentum::detail

include/momentum/common/filesystem.h

@@ -0,0 +1,20 @@
+/*
+ * 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
+
+#if defined(MOMENTUM_WITH_PORTABILITY)
+
+#include <portability/Filesystem.h>
+
+#else
+
+#include <filesystem>
+
+namespace filesystem = std::filesystem;
+
+#endif

include/momentum/common/fwd.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.
+ */
+
+// 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 {
+
+class ProgressBar;
+
+using ProgressBar_p = ::std::shared_ptr<ProgressBar>;
+using ProgressBar_u = ::std::unique_ptr<ProgressBar>;
+using ProgressBar_w = ::std::weak_ptr<ProgressBar>;
+using ProgressBar_const_p = ::std::shared_ptr<const ProgressBar>;
+using ProgressBar_const_u = ::std::unique_ptr<const ProgressBar>;
+using ProgressBar_const_w = ::std::weak_ptr<const ProgressBar>;
+
+} // namespace momentum

include/momentum/common/log.h

@@ -0,0 +1,173 @@
+/*
+ * 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
+
+#if defined(MOMENTUM_WITH_XR_LOGGER)
+
+// Allow DEFAULT_LOG_CHANNEL to be defined before including this file if you want to override the
+// default channel name. To set your own channel name (the order matters):
+//   #define DEFAULT_LOG_CHANNEL "my_custom_channel_name"
+//   #include <momentum/common/logging.h>
+#ifndef DEFAULT_LOG_CHANNEL
+#include <momentum/common/log_channel.h>
+#define DEFAULT_LOG_CHANNEL MOMENTUM_LOG_CHANNEL
+#endif
+
+#include <logging/Log.h>
+
+#define MT_LOGT(...) XR_LOGT(__VA_ARGS__)
+#define MT_LOGD(...) XR_LOGD(__VA_ARGS__)
+#define MT_LOGI(...) XR_LOGI(__VA_ARGS__)
+#define MT_LOGW(...) XR_LOGW(__VA_ARGS__)
+#define MT_LOGE(...) XR_LOGE(__VA_ARGS__)
+
+#define MT_LOGT_IF(condition, ...) XR_LOGT_IF(condition, __VA_ARGS__)
+#define MT_LOGD_IF(condition, ...) XR_LOGD_IF(condition, __VA_ARGS__)
+#define MT_LOGI_IF(condition, ...) XR_LOGI_IF(condition, __VA_ARGS__)
+#define MT_LOGW_IF(condition, ...) XR_LOGW_IF(condition, __VA_ARGS__)
+#define MT_LOGE_IF(condition, ...) XR_LOGE_IF(condition, __VA_ARGS__)
+
+#define MT_LOGT_ONCE(...) XR_LOGT_ONCE(__VA_ARGS__)
+#define MT_LOGD_ONCE(...) XR_LOGD_ONCE(__VA_ARGS__)
+#define MT_LOGI_ONCE(...) XR_LOGI_ONCE(__VA_ARGS__)
+#define MT_LOGW_ONCE(...) XR_LOGW_ONCE(__VA_ARGS__)
+#define MT_LOGE_ONCE(...) XR_LOGE_ONCE(__VA_ARGS__)
+
+#define MT_LOGT_ONCE_IF(condition, ...) XR_LOGT_ONCE_IF(condition, __VA_ARGS__)
+#define MT_LOGD_ONCE_IF(condition, ...) XR_LOGD_ONCE_IF(condition, __VA_ARGS__)
+#define MT_LOGI_ONCE_IF(condition, ...) XR_LOGI_ONCE_IF(condition, __VA_ARGS__)
+#define MT_LOGW_ONCE_IF(condition, ...) XR_LOGW_ONCE_IF(condition, __VA_ARGS__)
+#define MT_LOGE_ONCE_IF(condition, ...) XR_LOGE_ONCE_IF(condition, __VA_ARGS__)
+
+#elif defined(MOMENTUM_WITH_SPDLOG)
+
+#include <spdlog/spdlog.h>
+
+#include <atomic>
+
+#define MT_LOGT(...) ::spdlog::trace(__VA_ARGS__)
+#define MT_LOGD(...) ::spdlog::debug(__VA_ARGS__)
+#define MT_LOGI(...) ::spdlog::info(__VA_ARGS__)
+#define MT_LOGW(...) ::spdlog::warn(__VA_ARGS__)
+#define MT_LOGE(...) ::spdlog::error(__VA_ARGS__)
+
+#define MT_LOGT_IF(condition, ...) \
+  if (condition) {                 \
+    MT_LOGT(__VA_ARGS__);          \
+  }
+#define MT_LOGD_IF(condition, ...) \
+  if (condition) {                 \
+    MT_LOGD(__VA_ARGS__);          \
+  }
+#define MT_LOGI_IF(condition, ...) \
+  if (condition) {                 \
+    MT_LOGI(__VA_ARGS__);          \
+  }
+#define MT_LOGW_IF(condition, ...) \
+  if (condition) {                 \
+    MT_LOGW(__VA_ARGS__);          \
+  }
+#define MT_LOGE_IF(condition, ...) \
+  if (condition) {                 \
+    MT_LOGE(__VA_ARGS__);          \
+  }
+
+// This function is designed to limit the number of times an error is logged.
+// Please note that in a multi-threaded context, its behavior may not be guaranteed.
+#define _MT_RUN_ONCE(runcode)                                \
+  {                                                          \
+    static std::atomic<bool> codeRan(false);                 \
+    if (!codeRan) {                                          \
+      bool expected = false;                                 \
+      if (codeRan.compare_exchange_strong(expected, true)) { \
+        runcode;                                             \
+      }                                                      \
+    }                                                        \
+  }
+
+#define MT_LOGT_ONCE(...) _MT_RUN_ONCE(MT_LOGT(__VA_ARGS__))
+#define MT_LOGD_ONCE(...) _MT_RUN_ONCE(MT_LOGD(__VA_ARGS__))
+#define MT_LOGI_ONCE(...) _MT_RUN_ONCE(MT_LOGI(__VA_ARGS__))
+#define MT_LOGW_ONCE(...) _MT_RUN_ONCE(MT_LOGW(__VA_ARGS__))
+#define MT_LOGE_ONCE(...) _MT_RUN_ONCE(MT_LOGE(__VA_ARGS__))
+
+#define MT_LOGT_ONCE_IF(condition, ...) \
+  if (condition) {                      \
+    MT_LOGT_ONCE(__VA_ARGS__);          \
+  }
+#define MT_LOGD_ONCE_IF(condition, ...) \
+  if (condition) {                      \
+    MT_LOGD_ONCE(__VA_ARGS__);          \
+  }
+#define MT_LOGI_ONCE_IF(condition, ...) \
+  if (condition) {                      \
+    MT_LOGI_ONCE(__VA_ARGS__);          \
+  }
+#define MT_LOGW_ONCE_IF(condition, ...) \
+  if (condition) {                      \
+    MT_LOGW_ONCE(__VA_ARGS__);          \
+  }
+#define MT_LOGE_ONCE_IF(condition, ...) \
+  if (condition) {                      \
+    MT_LOGE_ONCE(__VA_ARGS__);          \
+  }
+
+#else
+
+#define MT_LOGT(...)
+#define MT_LOGD(...)
+#define MT_LOGI(...)
+#define MT_LOGW(...)
+#define MT_LOGE(...)
+
+#define MT_LOGT_IF(condition, ...)
+#define MT_LOGD_IF(condition, ...)
+#define MT_LOGI_IF(condition, ...)
+#define MT_LOGW_IF(condition, ...)
+#define MT_LOGE_IF(condition, ...)
+
+#define MT_LOGT_ONCE(...)
+#define MT_LOGD_ONCE(...)
+#define MT_LOGI_ONCE(...)
+#define MT_LOGW_ONCE(...)
+#define MT_LOGE_ONCE(...)
+
+#define MT_LOGT_ONCE_IF(condition, ...)
+#define MT_LOGD_ONCE_IF(condition, ...)
+#define MT_LOGI_ONCE_IF(condition, ...)
+#define MT_LOGW_ONCE_IF(condition, ...)
+#define MT_LOGE_ONCE_IF(condition, ...)
+
+#endif
+
+#include <momentum/common/checks.h>
+
+#include <map>
+#include <string>
+
+namespace momentum {
+
+/// Logging levels in descending order of verbosity
+enum class LogLevel {
+  Disabled = 0,
+  Error,
+  Warning,
+  Info,
+  Debug,
+  Trace,
+};
+
+[[nodiscard]] std::map<std::string, LogLevel> logLevelMap();
+
+void setLogLevel(LogLevel level);
+
+void setLogLevel(const std::string& levelStr);
+
+[[nodiscard]] LogLevel getLogLevel();
+
+} // namespace momentum

include/momentum/common/log_channel.h

@@ -0,0 +1,17 @@
+/*
+ * 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
+
+#if defined(MOMENTUM_WITH_XR_LOGGER)
+
+// The file to include in header files. Used as XR_LOGCI(MOMENTUM_LOG_CHANNEL, "message");
+
+#include <logging/Log.h>
+#define MOMENTUM_LOG_CHANNEL "MOMENTUM"
+
+#endif