clang formatting

Author: Tim van Wankum

src/plugins/manus/core/manus_hand_tracking_plugin.cpp

@@ -42,10 +42,8 @@ bool is_openxr_extension_supported(const char* ext_name)
     {
         return false;
     }
-    return std::any_of(props.begin(), props.end(), [ext_name](const XrExtensionProperties& p)
-    {
-        return std::string(p.extensionName) == ext_name;
-    });
+    return std::any_of(props.begin(), props.end(),
+                       [ext_name](const XrExtensionProperties& p) { return std::string(p.extensionName) == ext_name; });
 }
 
 } // anonymous namespace
@@ -169,8 +167,7 @@ void ManusTracker::initialize(const std::string& app_name) noexcept(false)
         else
         {
             std::cout << "[Manus] " << XR_EXT_HAND_TRACKING_EXTENSION_NAME
-                      << " is not supported by the current runtime; HandTracker will not be created."
-                      << std::endl;
+                      << " is not supported by the current runtime; HandTracker will not be created." << std::endl;
         }
 
         // Get required extensions from trackers
@@ -189,8 +186,7 @@ void ManusTracker::initialize(const std::string& app_name) noexcept(false)
         {
             std::cout << "[Manus] " << XR_MNDX_XDEV_SPACE_EXTENSION_NAME
                       << " is not supported by the current runtime; optical hand tracking"
-                      << " will not be available and controller fallback will be used."
-                      << std::endl;
+                      << " will not be available and controller fallback will be used." << std::endl;
         }
 
         // Create session with required extensions - constructor automatically begins the session
@@ -201,8 +197,10 @@ void ManusTracker::initialize(const std::string& app_name) noexcept(false)
         m_time_converter.emplace(m_handles);
 
         // Initialize hand injectors (one per hand)
-        m_left_injector = std::make_unique<plugin_utils::HandInjector>(m_handles.instance, m_handles.session, XR_HAND_LEFT_EXT, m_handles.space);
-        m_right_injector = std::make_unique<plugin_utils::HandInjector>(m_handles.instance, m_handles.session, XR_HAND_RIGHT_EXT, m_handles.space);
+        m_left_injector = std::make_unique<plugin_utils::HandInjector>(
+            m_handles.instance, m_handles.session, XR_HAND_LEFT_EXT, m_handles.space);
+        m_right_injector = std::make_unique<plugin_utils::HandInjector>(
+            m_handles.instance, m_handles.session, XR_HAND_RIGHT_EXT, m_handles.space);
 
         m_deviceio_session = core::DeviceIOSession::run(trackers, m_handles);
 
@@ -214,8 +212,7 @@ void ManusTracker::initialize(const std::string& app_name) noexcept(false)
             initialize_xdev_hand_trackers();
         }
 
-        std::cout << "[Manus] Initialized with wrist source: "
-                  << (m_xdev_available ? "HandTracking" : "Controllers")
+        std::cout << "[Manus] Initialized with wrist source: " << (m_xdev_available ? "HandTracking" : "Controllers")
                   << std::endl;
 
         success = true;
@@ -409,32 +406,34 @@ void ManusTracker::OnLandscapeStream(const Landscape* landscape)
     {
         const GloveLandscapeData& glove = gloves.gloves[i];
         if (glove.side == Side::Side_Left)
+        {
+            tracker.left_glove_id = glove.id;
+            left_present = true;
+            // Fetch bone topology once on connect
+            uint32_t nc = 0;
+            if (CoreSdk_GetRawSkeletonNodeCount(glove.id, nc) == SDKReturnCode::SDKReturnCode_Success && nc > 0)
             {
-                tracker.left_glove_id = glove.id;
-                left_present = true;
-                // Fetch bone topology once on connect
-                uint32_t nc = 0;
-                if (CoreSdk_GetRawSkeletonNodeCount(glove.id, nc) == SDKReturnCode::SDKReturnCode_Success && nc > 0)
-                {
-                    std::lock_guard<std::mutex> sk(tracker.m_skeleton_mutex);
-                    tracker.m_left_node_info.resize(nc);
-                    if (CoreSdk_GetRawSkeletonNodeInfoArray(glove.id, tracker.m_left_node_info.data(), nc) != SDKReturnCode::SDKReturnCode_Success)
-                        tracker.m_left_node_info.clear();
-                }
+                std::lock_guard<std::mutex> sk(tracker.m_skeleton_mutex);
+                tracker.m_left_node_info.resize(nc);
+                if (CoreSdk_GetRawSkeletonNodeInfoArray(glove.id, tracker.m_left_node_info.data(), nc) !=
+                    SDKReturnCode::SDKReturnCode_Success)
+                    tracker.m_left_node_info.clear();
             }
-            else if (glove.side == Side::Side_Right)
+        }
+        else if (glove.side == Side::Side_Right)
+        {
+            tracker.right_glove_id = glove.id;
+            right_present = true;
+            uint32_t nc = 0;
+            if (CoreSdk_GetRawSkeletonNodeCount(glove.id, nc) == SDKReturnCode::SDKReturnCode_Success && nc > 0)
             {
-                tracker.right_glove_id = glove.id;
-                right_present = true;
-                uint32_t nc = 0;
-                if (CoreSdk_GetRawSkeletonNodeCount(glove.id, nc) == SDKReturnCode::SDKReturnCode_Success && nc > 0)
-                {
-                    std::lock_guard<std::mutex> sk(tracker.m_skeleton_mutex);
-                    tracker.m_right_node_info.resize(nc);
-                    if (CoreSdk_GetRawSkeletonNodeInfoArray(glove.id, tracker.m_right_node_info.data(), nc) != SDKReturnCode::SDKReturnCode_Success)
-                        tracker.m_right_node_info.clear();
-                }
+                std::lock_guard<std::mutex> sk(tracker.m_skeleton_mutex);
+                tracker.m_right_node_info.resize(nc);
+                if (CoreSdk_GetRawSkeletonNodeInfoArray(glove.id, tracker.m_right_node_info.data(), nc) !=
+                    SDKReturnCode::SDKReturnCode_Success)
+                    tracker.m_right_node_info.clear();
             }
+        }
     }
 
     // Clear stale state for any glove that is no longer present in this landscape
@@ -463,7 +462,8 @@ void ManusTracker::OnLandscapeStream(const Landscape* landscape)
 void ManusTracker::initialize_xdev_hand_trackers()
 {
     // Load XDev extension function pointers
-    auto load_func = [this](const char* name, PFN_xrVoidFunction* ptr) -> bool {
+    auto load_func = [this](const char* name, PFN_xrVoidFunction* ptr) -> bool
+    {
         XrResult result = m_handles.xrGetInstanceProcAddr(m_handles.instance, name, ptr);
         return XR_SUCCEEDED(result) && *ptr != nullptr;
     };
@@ -553,20 +553,21 @@ void ManusTracker::initialize_xdev_hand_trackers()
         std::string serials_list;
         for (const auto& s : seen_serials)
         {
-            if (!serials_list.empty()) serials_list += ", ";
+            if (!serials_list.empty())
+                serials_list += ", ";
             serials_list += '"';
             serials_list += s;
             serials_list += '"';
         }
         std::cerr << "[Manus] Could not match optical hand-tracking XDevs by serial. "
-                  << "Expected \"Head Device (0)\" (left) and \"Head Device (1)\" (right), "
-                  << "but found: [" << serials_list << "]. "
-                  << "These serial strings are runtime-specific and may have changed."
+                  << "Expected \"Head Device (0)\" (left) and \"Head Device (1)\" (right), " << "but found: ["
+                  << serials_list << "]. " << "These serial strings are runtime-specific and may have changed."
                   << std::endl;
     }
 
     // Create hand trackers from XDevs
-    auto create_tracker = [this](XrXDevIdMNDX xdev_id, XrHandEXT hand, XrHandTrackerEXT& out_tracker) -> bool {
+    auto create_tracker = [this](XrXDevIdMNDX xdev_id, XrHandEXT hand, XrHandTrackerEXT& out_tracker) -> bool
+    {
         if (xdev_id == 0)
         {
             return false;
@@ -662,8 +663,8 @@ bool ManusTracker::update_xdev_hand(XrHandTrackerEXT tracker, XrTime time, XrPos
 
 bool ManusTracker::get_controller_wrist_pose(bool is_left, XrPosef& out_wrist_pose)
 {
-    const auto& tracked = is_left ? m_controller_tracker->get_left_controller(*m_deviceio_session)
-                                  : m_controller_tracker->get_right_controller(*m_deviceio_session);
+    const auto& tracked = is_left ? m_controller_tracker->get_left_controller(*m_deviceio_session) :
+                                    m_controller_tracker->get_right_controller(*m_deviceio_session);
 
     if (!tracked.data)
     {

src/plugins/manus/inc/core/manus_hand_tracking_plugin.hpp

@@ -3,17 +3,16 @@
 
 #pragma once
 
-#include <deviceio_trackers/controller_tracker.hpp>
 #include <deviceio_session/deviceio_session.hpp>
+#include <deviceio_trackers/controller_tracker.hpp>
 #include <deviceio_trackers/hand_tracker.hpp>
 #include <openxr/openxr_platform.h>
 #include <oxr/oxr_session.hpp>
 #include <oxr_utils/oxr_time.hpp>
 #include <plugin_utils/hand_injector.hpp>
 
-#include <XR_MNDX_xdev_space.h>
-
 #include <ManusSDK.h>
+#include <XR_MNDX_xdev_space.h>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -39,8 +38,8 @@ class __attribute__((visibility("default"))) ManusTracker
     void update();
     std::vector<SkeletonNode> get_left_hand_nodes() const;
     std::vector<SkeletonNode> get_right_hand_nodes() const;
-    std::vector<NodeInfo>     get_left_node_info() const;
-    std::vector<NodeInfo>     get_right_node_info() const;
+    std::vector<NodeInfo> get_left_node_info() const;
+    std::vector<NodeInfo> get_right_node_info() const;
 
 private:
     // Lifecycle

src/plugins/manus/tools/manus_hand_tracker_printer.cpp

@@ -1,9 +1,10 @@
-// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-#include <core/manus_hand_tracking_plugin.hpp>
 #include "manus_hand_visualizer.hpp"
 
+#include <core/manus_hand_tracking_plugin.hpp>
+
 #include <algorithm>
 #include <chrono>
 #include <iomanip>
@@ -27,18 +28,19 @@ try
     // continues without the window.
     // std::jthread automatically requests stop and joins on destruction,
     // preventing the thread from outliving the tracker singleton.
-    std::jthread vis_thread([&tracker](std::stop_token st)
-    {
-        try
-        {
-            plugins::manus::HandVisualizer vis;
-            vis.run(tracker, std::move(st));
-        }
-        catch (const std::exception& e)
+    std::jthread vis_thread(
+        [&tracker](std::stop_token st)
         {
-            std::cerr << "[Vis] " << e.what() << " — running without visualizer" << std::endl;
-        }
-    });
+            try
+            {
+                plugins::manus::HandVisualizer vis;
+                vis.run(tracker, std::move(st));
+            }
+            catch (const std::exception& e)
+            {
+                std::cerr << "[Vis] " << e.what() << " — running without visualizer" << std::endl;
+            }
+        });
 
     std::cout << "[Manus] Press Ctrl+C to stop. Printing joint data..." << std::endl;
 
@@ -79,10 +81,9 @@ try
                 const auto& pos = nodes[i].transform.position;
                 const auto& ori = nodes[i].transform.rotation;
 
-                std::cout << "[Manus]   Joint " << i << ": "
-                          << "pos=[" << std::fixed << std::setprecision(3) << pos.x << ", " << pos.y << ", " << pos.z
-                          << "] "
-                          << "ori=[" << ori.x << ", " << ori.y << ", " << ori.z << ", " << ori.w << "]" << std::endl;
+                std::cout << "[Manus]   Joint " << i << ": " << "pos=[" << std::fixed << std::setprecision(3) << pos.x
+                          << ", " << pos.y << ", " << pos.z << "] " << "ori=[" << ori.x << ", " << ori.y << ", "
+                          << ori.z << ", " << ori.w << "]" << std::endl;
             }
 
             if (nodes.size() > 5)