time for profiling

Author: dooly123

Basis/Packages/com.basis.framework/BasisUI/BasisSettingsDefaults.cs

@@ -196,6 +196,14 @@ public static class BasisSettingsDefaults
 
         public static BasisSettingsBinding<bool> EnableStatistics = new("enablestatistics", new BasisPlatformDefault<bool>(false));
 
+        /// <summary>
+        /// When on, the client runs a loopback-only HTTP listener (127.0.0.1:9080)
+        /// exposing /stats.json and /overlay.html so OBS Browser Source (or any
+        /// local tool) can pull FPS / CCU / ping. Off by default — the listener
+        /// is only opened after the user explicitly enables this.
+        /// </summary>
+        public static BasisSettingsBinding<bool> EnableStreamingMeta = new("enablestreamingmeta", new BasisPlatformDefault<bool>(false));
+
         public static BasisSettingsBinding<bool> AvatarShowTextureStats = new("avatarshowtexturestats", new BasisPlatformDefault<bool>(false));
 
         public static BasisSettingsBinding<bool> AvatarShowTrackerRoles = new("avatarshowtrackerroles", new BasisPlatformDefault<bool>(false));
@@ -886,6 +894,7 @@ public static void LoadAll()
             DisableLogging.LoadBindingValue();
             BasisDebug.LoggingDisabled = DisableLogging.RawValue;
             DisableLogging.OnChanged += value => BasisDebug.LoggingDisabled = value;
+            EnableStreamingMeta.LoadBindingValue();
             MemoryAllocation.LoadBindingValue();
             VisualState.LoadBindingValue();
             FoveatedRendering.LoadBindingValue();

Basis/Packages/com.basis.framework/BasisUI/Menus/Main Menu Providers/SettingsProvider.cs

@@ -1401,6 +1401,16 @@ public static PanelTabPage DeveloperTab(PanelTabGroup tabGroup)
             toggleStatistics.Descriptor.SetDescription(BasisLocalization.Get("settings.developer.enableStatistics.description"));
             toggleStatistics.AssignBinding(BasisSettingsDefaults.EnableStatistics);
 
+            PanelToggle toggleStreamingMeta = PanelToggle.CreateNewEntry(debugGroup.ContentParent);
+            toggleStreamingMeta.Descriptor.SetTitle("Streaming Meta (OBS)");
+            toggleStreamingMeta.Descriptor.SetDescription(
+                "Exposes FPS and CCU on a loopback-only web server at " +
+                "http://127.0.0.1:9080/overlay.html (drop that URL into an OBS " +
+                "Browser Source). Raw JSON is available at /stats.json. Off by " +
+                "default — only binds to localhost, never the LAN."
+            );
+            toggleStreamingMeta.AssignBinding(BasisSettingsDefaults.EnableStreamingMeta);
+
             PanelToggle toggleDisableLogging = PanelToggle.CreateNewEntry(debugGroup.ContentParent);
             toggleDisableLogging.Descriptor.SetTitle(BasisLocalization.Get("settings.developer.disableLogging"));
             toggleDisableLogging.Descriptor.SetDescription(BasisLocalization.Get("settings.developer.disableLogging.description"));
@@ -1563,6 +1573,7 @@ private static void ResetDeveloperDefaults()
             BasisSettingsDefaults.DebugVisuals.ResetToDefault();
             BasisSettingsDefaults.VisualState.SetValue("off");
             BasisSettingsDefaults.EnableStatistics.ResetToDefault();
+            BasisSettingsDefaults.EnableStreamingMeta.ResetToDefault();
             BasisSettingsDefaults.DisableLogging.ResetToDefault();
             BasisSettingsDefaults.DevShowBuildInfo.ResetToDefault();
             BasisSettingsDefaults.DevShowConsole.ResetToDefault();

Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalBoneDriver.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using UnityEngine;
 
 namespace Basis.Scripts.Drivers
@@ -106,6 +107,18 @@ public class BasisLocalBoneDriver
         /// <summary>Gizmo size for hand-related visuals (scaled by avatar height).</summary>
         public static float HandGizmoSize = 0.02f;
 
+        /// <summary>Minimum bones in a dependency level before dispatching to thread pool.</summary>
+        public static int ParallelThreshold = 4;
+
+        /// <summary>
+        /// Bone indices grouped by dependency depth (level 0 = no Target, level N = Target at level &lt; N).
+        /// Each level is safe to run in parallel; levels run sequentially.
+        /// </summary>
+        private int[][] _dependencyLevels;
+
+        /// <summary>True when <see cref="_dependencyLevels"/> must be rebuilt before next Simulate.</summary>
+        private bool _dependencyLevelsDirty = true;
+
         /// <summary>
         /// Discovers common tracked roles and assigns cached references (e.g., head, spine).
         /// </summary>
@@ -142,10 +155,27 @@ public void Initialize()
         /// <param name="transform">Parent transform whose <see cref="Transform.localToWorldMatrix"/> seeds world computation.</param>
         public void Simulate(float deltaTime, Matrix4x4 parentMatrix)
         {
-            // sequence all other devices to run at the same time
-            for (int Index = 0; Index < ControlsLength; Index++)
+            if (_dependencyLevelsDirty) RebuildDependencyLevels();
+
+            BasisLocalBoneControl[] controls = Controls;
+            int[][] levels = _dependencyLevels;
+            for (int levelIndex = 0; levelIndex < levels.Length; levelIndex++)
             {
-                Controls[Index].ComputeMovementLocal(parentMatrix, deltaTime);
+                int[] level = levels[levelIndex];
+                if (level.Length < ParallelThreshold)
+                {
+                    for (int k = 0; k < level.Length; k++)
+                    {
+                        controls[level[k]].ComputeMovementLocal(parentMatrix, deltaTime);
+                    }
+                }
+                else
+                {
+                    Parallel.For(0, level.Length, k =>
+                    {
+                        controls[level[k]].ComputeMovementLocal(parentMatrix, deltaTime);
+                    });
+                }
             }
             if (SMModuleDebugOptions.UseGizmos)
             {
@@ -160,20 +190,134 @@ public void Simulate(float deltaTime, Matrix4x4 parentMatrix)
         /// <param name="transform">Parent transform for world calculations.</param>
         public void SimulateWithoutLerp(Matrix4x4 parentMatrix)
         {
-            // sequence all other devices to run at the same time
+            if (_dependencyLevelsDirty) RebuildDependencyLevels();
+
             float DeltaTime = Time.deltaTime;
-            for (int Index = 0; Index < ControlsLength; Index++)
+            BasisLocalBoneControl[] controls = Controls;
+
+            // Seed LastRunData across all bones — independent per-bone, safe in parallel regardless of levels.
+            int total = ControlsLength;
+            if (total < ParallelThreshold)
             {
-                Controls[Index].LastRunData.position = Controls[Index].OutGoingData.position;
-                Controls[Index].LastRunData.rotation = Controls[Index].OutGoingData.rotation;
-                Controls[Index].ComputeMovementLocal(parentMatrix, DeltaTime);
+                for (int Index = 0; Index < total; Index++)
+                {
+                    controls[Index].LastRunData.position = controls[Index].OutGoingData.position;
+                    controls[Index].LastRunData.rotation = controls[Index].OutGoingData.rotation;
+                }
+            }
+            else
+            {
+                Parallel.For(0, total, Index =>
+                {
+                    controls[Index].LastRunData.position = controls[Index].OutGoingData.position;
+                    controls[Index].LastRunData.rotation = controls[Index].OutGoingData.rotation;
+                });
+            }
+
+            int[][] levels = _dependencyLevels;
+            for (int levelIndex = 0; levelIndex < levels.Length; levelIndex++)
+            {
+                int[] level = levels[levelIndex];
+                if (level.Length < ParallelThreshold)
+                {
+                    for (int k = 0; k < level.Length; k++)
+                    {
+                        controls[level[k]].ComputeMovementLocal(parentMatrix, DeltaTime);
+                    }
+                }
+                else
+                {
+                    Parallel.For(0, level.Length, k =>
+                    {
+                        controls[level[k]].ComputeMovementLocal(parentMatrix, DeltaTime);
+                    });
+                }
             }
             if (SMModuleDebugOptions.UseGizmos)
             {
                 DrawGizmos();
             }
         }
 
+        /// <summary>
+        /// Marks the cached dependency-level grouping as stale. Call whenever Controls or Targets change.
+        /// </summary>
+        public void MarkDependencyLevelsDirty()
+        {
+            _dependencyLevelsDirty = true;
+        }
+
+        /// <summary>
+        /// Topologically groups Controls by Target-chain depth so bones within a level never
+        /// read another bone in the same (or later) level. Cycles degrade to level 0 to stay safe.
+        /// </summary>
+        private void RebuildDependencyLevels()
+        {
+            int count = ControlsLength;
+            if (count == 0)
+            {
+                _dependencyLevels = Array.Empty<int[]>();
+                _dependencyLevelsDirty = false;
+                return;
+            }
+
+            Dictionary<BasisLocalBoneControl, int> indexOf = new Dictionary<BasisLocalBoneControl, int>(count);
+            for (int i = 0; i < count; i++)
+            {
+                indexOf[Controls[i]] = i;
+            }
+
+            int[] depth = new int[count];
+            for (int i = 0; i < count; i++) depth[i] = -1;
+
+            for (int i = 0; i < count; i++)
+            {
+                ComputeDepth(i, depth, indexOf);
+            }
+
+            int maxDepth = 0;
+            for (int i = 0; i < count; i++)
+            {
+                if (depth[i] > maxDepth) maxDepth = depth[i];
+            }
+
+            int[] counts = new int[maxDepth + 1];
+            for (int i = 0; i < count; i++) counts[depth[i]]++;
+
+            int[][] levels = new int[maxDepth + 1][];
+            for (int d = 0; d <= maxDepth; d++) levels[d] = new int[counts[d]];
+
+            int[] cursor = new int[maxDepth + 1];
+            for (int i = 0; i < count; i++)
+            {
+                int d = depth[i];
+                levels[d][cursor[d]++] = i;
+            }
+
+            _dependencyLevels = levels;
+            _dependencyLevelsDirty = false;
+        }
+
+        private int ComputeDepth(int i, int[] depth, Dictionary<BasisLocalBoneControl, int> indexOf)
+        {
+            int existing = depth[i];
+            if (existing == -2) return 0; // cycle: break at 0
+            if (existing >= 0) return existing;
+
+            BasisLocalBoneControl ctrl = Controls[i];
+            BasisLocalBoneControl target = ctrl.Target;
+            if (target == null || !indexOf.TryGetValue(target, out int targetIdx))
+            {
+                depth[i] = 0;
+                return 0;
+            }
+
+            depth[i] = -2; // cycle guard
+            int d = ComputeDepth(targetIdx, depth, indexOf) + 1;
+            depth[i] = d;
+            return d;
+        }
+
         /// <summary>
         /// Draws gizmos for all controls using the current avatar scale.
         /// </summary>
@@ -241,6 +385,7 @@ public void AddRange(BasisLocalBoneControl[] newControls, BasisBoneTrackedRole[]
             Controls = Controls.Concat(newControls).ToArray();
             trackedRoles = trackedRoles.Concat(newRoles).ToArray();
             ControlsLength = Controls.Length;
+            _dependencyLevelsDirty = true;
         }
 
         /// <summary>
@@ -422,6 +567,7 @@ public void CreateRotationalLock(BasisLocalBoneControl addToBone, BasisLocalBone
             addToBone.Target = target;
             addToBone.Offset = addToBone.TposeLocalScaled.position - target.TposeLocalScaled.position;
             addToBone.ScaledOffset = addToBone.Offset;
+            _dependencyLevelsDirty = true;
         }
 
         /// <summary>

Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalCameraDriver.cs

@@ -96,12 +96,13 @@ public class BasisLocalCameraDriver : MonoBehaviour
 
         /// <summary>
         /// World forward vector of the active camera instance, or zero if no instance exists.
+        /// Derived from the cached <see cref="Rotation"/> to avoid a native transform PInvoke per call.
         /// </summary>
         public static Vector3 Forward()
         {
             if (HasInstance)
             {
-                return Instance.transform.forward;
+                return Rotation * Vector3.forward;
             }
             else
             {
@@ -116,7 +117,7 @@ public static Vector3 Up()
         {
             if (HasInstance)
             {
-                return Instance.transform.up;
+                return Rotation * Vector3.up;
             }
             else
             {
@@ -131,7 +132,7 @@ public static Vector3 Right()
         {
             if (HasInstance)
             {
-                return Instance.transform.right;
+                return Rotation * Vector3.right;
             }
             else
             {