more work on dolly

Author: dooly123

Basis/Assets/AddressableAssetsData/AddressableAssetSettings.asset

@@ -15,7 +15,7 @@ MonoBehaviour:
   m_DefaultGroup: 37c75a6cf72db324eb01200602299fc8
   m_currentHash:
     serializedVersion: 2
-    Hash: 00000000000000000000000000000000
+    Hash: 65ced2d2c4a4fdc005e9b6d7fa8fe640
   m_ExtractTypeTreeData: 0
   m_OptimizeCatalogSize: 0
   m_BuildRemoteCatalog: 0

Basis/Assets/AddressableAssetsData/link.xml

@@ -81,10 +81,17 @@ internal void TickDollyTrack()
         DollyTrack.SyncMode = Modifiers.dolly.syncMode;
         DollyTrack.Refresh(scale, facing);
 
-        // Everyone else's tracks are drawn from the same frame as our own, so a shared track is
-        // never a frame behind the one it is being laid out beside.
+        // Claimed every frame rather than on the share dropdown, so a track that turns networked
+        // through a preset or a restored mode is shared on the same terms as one switched by hand.
+        if (Modifiers.dolly.syncMode == BasisCameraDollySync.LocalOnly)
+        {
+            BasisCameraDollyManager.ReleaseLocalTrack(DollyTrack);
+        }
+        else
+        {
+            BasisCameraDollyManager.ClaimLocalTrack(DollyTrack);
+        }
         BasisCameraDollyManager.Tick(Time.time);
-        BasisCameraDollyManager.TickMirrors(scale, facing);
     }
 
     internal void DisposeModifiers()
@@ -93,7 +100,7 @@ internal void DisposeModifiers()
         // to update it.
         if (DollyTrack != null)
         {
-            BasisCameraDollyManager.SetLocalTrack(null);
+            BasisCameraDollyManager.ReleaseLocalTrack(DollyTrack);
         }
         DollyTrack?.Dispose();
         DollyTrack = null;

Basis/Assets/AddressableAssetsData/link.xml.meta

@@ -513,7 +513,7 @@ private void BuildPositionGroup(RectTransform parent)
 
             _dollySpeedSlider = PanelSlider.CreateNew(content);
             _dollySpeedSlider.SetSliderSettings(PanelSlider.SliderSettings.Advanced(
-                BasisLocalization.Get("camera.dollySpeed"), -3f, 3f, false, 2, ValueDisplayMode.Raw));
+                BasisLocalization.Get("camera.dollySpeed"), -100f, 100f, false, 2, ValueDisplayMode.Raw));
             _dollySpeedSlider.Descriptor.SetDescription(BasisLocalization.Get("camera.dollySpeed.description"));
             _dollySpeedSlider.OnValueChanged = v =>
             {

Basis/Packages/com.basis.camera/Runtime/BasisHandHeldCameraModifiers.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+namespace Basis.Cinematics
+{
+    /// <summary>
+    /// Arms the shared dolly service for the session. It has to exist before any camera is taken out:
+    /// a track arriving from somebody else is handled whether or not this client has ever opened one.
+    /// </summary>
+    public static class BasisCameraDollyBootstrap
+    {
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
+        private static void Initialize()
+        {
+            BasisCameraDollyManager.Initialize();
+        }
+    }
+}

Basis/Packages/com.basis.camera/Runtime/BasisHandHeldCameraPanelProvider.Modifiers.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using Basis.Scripts.BasisSdk.Players;
+using Basis.Scripts.Drivers;
 using Basis.Scripts.Networking;
 using Basis.Scripts.Networking.NetworkedAvatar;
 using Basis.Network.Core;
@@ -54,6 +56,7 @@ public static class BasisCameraDollyManager
         private static float _nextKeyframe;
         private static int _lastSentCount = -1;
         private static BasisCameraDollySync _lastSentMode = BasisCameraDollySync.LocalOnly;
+        private static bool _mirrorTickRequested;
 
         // ---- Lifecycle -------------------------------------------------------------------
 
@@ -66,14 +69,24 @@ public static void Initialize()
             BasisNetworkPlayer.OnPlayerLeft += HandlePlayerLeft;
             BasisNetworkPlayer.OnPlayerJoined -= HandlePlayerJoined;
             BasisNetworkPlayer.OnPlayerJoined += HandlePlayerJoined;
+            BasisNetworkPlayer.OnLocalPlayerJoined -= HandleLocalPlayerJoined;
+            BasisNetworkPlayer.OnLocalPlayerJoined += HandleLocalPlayerJoined;
+            Application.quitting -= Shutdown;
+            Application.quitting += Shutdown;
 
-            ResolveNetworkId();
+            if (BasisNetworkConnection.LocalPlayerIsConnected)
+            {
+                HandleLocalPlayerJoined(null, null);
+            }
         }
 
         public static void Shutdown()
         {
             BasisNetworkPlayer.OnPlayerLeft -= HandlePlayerLeft;
             BasisNetworkPlayer.OnPlayerJoined -= HandlePlayerJoined;
+            BasisNetworkPlayer.OnLocalPlayerJoined -= HandleLocalPlayerJoined;
+            BasisNetworkPlayer.OnLocalPlayerLeft -= HandleLocalPlayerLeft;
+            Application.quitting -= Shutdown;
 
             if (HasNetworkID)
             {
@@ -87,9 +100,19 @@ public static void Shutdown()
             ClearAllMirrors();
         }
 
-        private static async void ResolveNetworkId()
+        /// <summary>
+        /// Resolving the shared identifier needs a live connection, so it waits for the local player
+        /// to be approved rather than running at load. The handler is re-armed per join because the
+        /// network lifecycle nulls the delegate on teardown.
+        /// </summary>
+        private static async void HandleLocalPlayerJoined(BasisNetworkPlayer networkPlayer, BasisLocalPlayer localPlayer)
         {
             if (HasNetworkID) return;
+            if (!BasisNetworkConnection.LocalPlayerIsConnected)
+            {
+                BasisDebug.LogError("Dolly manager cannot start; the local player is not connected.", LogTag);
+                return;
+            }
 
             BasisIdResolutionResult resolution = await BasisNetworkIdResolver.ResolveAsync(FixedNetworkIdentifier);
             if (!_initialized || HasNetworkID) return;
@@ -104,6 +127,27 @@ private static async void ResolveNetworkId()
             NetworkID = resolution.Id;
             HasNetworkID = true;
             BasisNetworkGenericMessages.RegisterDirectHandler(NetworkID, OnDirectNetworkMessage);
+
+            BasisNetworkPlayer.OnLocalPlayerLeft -= HandleLocalPlayerLeft;
+            BasisNetworkPlayer.OnLocalPlayerLeft += HandleLocalPlayerLeft;
+
+            _lastSentCount = -1;
+            _nextRoster = 0f;
+            _nextKeyframe = 0f;
+            BasisDebug.Log($"Dolly manager ready (network id {NetworkID}).", LogTag);
+        }
+
+        private static void HandleLocalPlayerLeft(BasisNetworkPlayer networkPlayer, BasisLocalPlayer localPlayer)
+        {
+            if (HasNetworkID)
+            {
+                BasisNetworkGenericMessages.UnregisterDirectHandler(NetworkID);
+            }
+            HasNetworkID = false;
+            NetworkID = 0;
+            _lastSentCount = -1;
+
+            ClearAllMirrors();
         }
 
         // ---- The local track --------------------------------------------------------------
@@ -126,6 +170,27 @@ public static void SetLocalTrack(BasisCameraDollyTrack track)
             _nextKeyframe = 0f;
         }
 
+        /// <summary>
+        /// Offers a track for sharing. A roster is keyed by the player who sent it, so a client
+        /// shares one track at a time; with several cameras out the first to ask keeps the slot
+        /// until it stops sharing, rather than the two of them withdrawing each other every frame.
+        /// </summary>
+        public static void ClaimLocalTrack(BasisCameraDollyTrack track)
+        {
+            if (track == null || ReferenceEquals(_local, track)) return;
+            if (_local != null && _local.SyncMode != BasisCameraDollySync.LocalOnly) return;
+
+            SetLocalTrack(track);
+        }
+
+        /// <summary>Gives the slot up, but only for the track actually holding it.</summary>
+        public static void ReleaseLocalTrack(BasisCameraDollyTrack track)
+        {
+            if (track == null || !ReferenceEquals(_local, track)) return;
+
+            SetLocalTrack(null);
+        }
+
         /// <summary>
         /// Sends the local track when it is due. Called from the camera's own frame, so a client
         /// with no camera out costs nothing at all.
@@ -145,7 +210,7 @@ public static void Tick(float time)
                 return;
             }
 
-            bool changed = _local.Count != _lastSentCount || _local.SyncMode != _lastSentMode;
+            bool changed = _local.Count != _lastSentCount || _local.SyncMode != _lastSentMode || LocalTrackIsHeld();
             bool due = changed ? time >= _nextRoster : time >= _nextKeyframe;
             if (!due) return;
 
@@ -156,6 +221,20 @@ public static void Tick(float time)
             _lastSentMode = _local.SyncMode;
         }
 
+        /// <summary>
+        /// Whether a point is in somebody's hand. A drag moves points without changing the count, so
+        /// without this a track being laid out would only reach the others at the keyframe rate.
+        /// </summary>
+        private static bool LocalTrackIsHeld()
+        {
+            for (int Index = 0; Index < _local.Count; Index++)
+            {
+                BasisCameraDollyWaypoint waypoint = _local.GetWaypoint(Index);
+                if (waypoint != null && waypoint.IsGrabbed) return true;
+            }
+            return false;
+        }
+
         private static void BroadcastRoster(ushort[] recipients)
         {
             int count = Mathf.Min(_local.Count, BasisCameraDollyPacket.MaxPoints);
@@ -172,7 +251,7 @@ private static void BroadcastRoster(ushort[] recipients)
             }
 
             EnsureBuffer(BasisCameraDollyPacket.RosterSize(count));
-            int written = BasisCameraDollyPacket.WriteRoster(_sendBuffer, _local.SyncMode, _scratch, count);
+            int written = BasisCameraDollyPacket.WriteRoster(_sendBuffer, _local.SyncMode, _local.Looped, _scratch, count);
             if (written > 0) Send(written, DeliveryMethod.ReliableOrdered, recipients);
         }
 
@@ -182,7 +261,7 @@ private static void BroadcastWithdrawal()
             if (!HasNetworkID) return;
 
             EnsureBuffer(BasisCameraDollyPacket.RosterSize(0));
-            int written = BasisCameraDollyPacket.WriteRoster(_sendBuffer, BasisCameraDollySync.LocalOnly, _scratch, 0);
+            int written = BasisCameraDollyPacket.WriteRoster(_sendBuffer, BasisCameraDollySync.LocalOnly, false, _scratch, 0);
             if (written > 0) Send(written, DeliveryMethod.ReliableOrdered, null);
         }
 
@@ -234,7 +313,7 @@ private static void OnDirectNetworkMessage(ushort playerId, byte[] buffer, Deliv
         private static void ApplyRoster(ushort playerId, byte[] buffer, int length)
         {
             if (!BasisCameraDollyPacket.TryReadRoster(buffer, length, _scratch,
-                out BasisCameraDollySync mode, out int count))
+                out BasisCameraDollySync mode, out bool looped, out int count))
             {
                 return;
             }
@@ -249,8 +328,9 @@ private static void ApplyRoster(ushort playerId, byte[] buffer, int length)
             {
                 mirror = new BasisCameraDollyMirror(playerId);
                 _mirrors[playerId] = mirror;
+                UpdateMirrorTickRequest();
             }
-            mirror.Apply(mode, _scratch, count);
+            mirror.Apply(mode, looped, _scratch, count);
         }
 
         private static void ApplyPointMove(ushort playerId, byte[] buffer, int length)
@@ -318,6 +398,7 @@ private static void DropMirror(ushort playerId)
             {
                 mirror.Dispose();
                 _mirrors.Remove(playerId);
+                UpdateMirrorTickRequest();
             }
         }
 
@@ -328,11 +409,41 @@ private static void ClearAllMirrors()
                 pair.Value.Dispose();
             }
             _mirrors.Clear();
+            UpdateMirrorTickRequest();
         }
 
-        /// <summary>Refreshes every mirrored track's markers. Driven from the camera's frame.</summary>
-        public static void TickMirrors(float scale, Quaternion labelFacing)
+        /// <summary>
+        /// Somebody else's track has to draw on a client that has no camera of its own out — seeing
+        /// where a shot is being laid out is the point of sharing it — so the frame clock drives the
+        /// mirrors rather than the handheld camera. The request is held only while there is a track
+        /// to draw, so a client with none costs nothing.
+        /// </summary>
+        private static void UpdateMirrorTickRequest()
         {
+            bool wanted = _mirrors.Count > 0;
+            if (wanted == _mirrorTickRequested) return;
+
+            _mirrorTickRequested = wanted;
+            if (wanted)
+            {
+                BasisFrameClock.OnTick += TickMirrors;
+                BasisFrameClock.AddRequest();
+            }
+            else
+            {
+                BasisFrameClock.OnTick -= TickMirrors;
+                BasisFrameClock.RemoveRequest();
+            }
+        }
+
+        /// <summary>Refreshes every mirrored track's markers.</summary>
+        public static void TickMirrors()
+        {
+            float scale = BasisHeightDriver.AvatarToDefaultRatioScaledWithAvatarScale;
+            Quaternion labelFacing = BasisLocalCameraDriver.HasInstance && BasisLocalCameraDriver.CameraInstance != null
+                ? BasisLocalCameraDriver.CameraInstance.transform.rotation
+                : Quaternion.identity;
+
             foreach (KeyValuePair<ushort, BasisCameraDollyMirror> pair in _mirrors)
             {
                 pair.Value.Refresh(scale, labelFacing);

Basis/Packages/com.basis.camera/Runtime/Cinematic/BasisCameraDollyBootstrap.cs

@@ -40,12 +40,13 @@ public BasisCameraDollyMirror(ushort owner)
 
         /// <summary>
         /// Brings the shown track in line with what the author sent: the same count, the same
-        /// places, and the same rule about whether it can be touched.
+        /// places, the same path through them, and the same rule about whether it can be touched.
         /// </summary>
-        public void Apply(BasisCameraDollySync mode, BasisCameraDollyPacket.Point[] points, int count)
+        public void Apply(BasisCameraDollySync mode, bool looped, BasisCameraDollyPacket.Point[] points, int count)
         {
             _mode = mode;
             _track.SyncMode = mode;
+            _track.Looped = looped;
 
             count = Mathf.Clamp(count, 0, BasisCameraDollyPacket.MaxPoints);
 

Basis/Packages/com.basis.camera/Runtime/Cinematic/BasisCameraDollyBootstrap.cs.meta

@@ -37,8 +37,15 @@ public static class BasisCameraDollyPacket
 
         private const int HeaderSize = 1;
         private const int OwnerSize = 2;
-        private const int PointSize = 28;                       // position (12) + rotation (16)
-        private const int RosterHeader = HeaderSize + 1 + 1;    // type, mode, count
+        private const int PointSize = 28;                           // position (12) + rotation (16)
+        private const int RosterHeader = HeaderSize + 1 + 1 + 1;    // type, mode, count, flags
+
+        /// <summary>
+        /// The track closes back on itself. It belongs with the points rather than beside them: it
+        /// decides whether the last waypoint joins the first, so a mirror without it draws a
+        /// different path from the one the author is looking at.
+        /// </summary>
+        private const byte RosterFlagLooped = 1 << 0;
         private const int MoveSize = HeaderSize + OwnerSize + 1 + PointSize;
         private const int ClaimSize = HeaderSize + OwnerSize + 1 + 1;
 
@@ -62,7 +69,7 @@ public struct Point
         /// callers size with <see cref="RosterSize"/>, so 0 means a caller bug rather than a
         /// runtime condition to handle.
         /// </summary>
-        public static int WriteRoster(byte[] buffer, BasisCameraDollySync mode, Point[] points, int count)
+        public static int WriteRoster(byte[] buffer, BasisCameraDollySync mode, bool looped, Point[] points, int count)
         {
             count = Mathf.Clamp(count, 0, MaxPoints);
             if (points == null) count = 0;
@@ -73,6 +80,7 @@ public static int WriteRoster(byte[] buffer, BasisCameraDollySync mode, Point[]
             buffer[offset++] = (byte)BasisCameraDollyPacketType.Roster;
             buffer[offset++] = (byte)mode;
             buffer[offset++] = (byte)count;
+            buffer[offset++] = looped ? RosterFlagLooped : (byte)0;
 
             for (int Index = 0; Index < count; Index++)
             {
@@ -129,9 +137,10 @@ public static bool TryReadType(byte[] buffer, int length, out BasisCameraDollyPa
         /// False when the packet is truncated or names a mode this build does not have.
         /// </summary>
         public static bool TryReadRoster(byte[] buffer, int length, Point[] points,
-            out BasisCameraDollySync mode, out int count)
+            out BasisCameraDollySync mode, out bool looped, out int count)
         {
             mode = BasisCameraDollySync.LocalOnly;
+            looped = false;
             count = 0;
 
             if (!TryReadType(buffer, length, out BasisCameraDollyPacketType type) ||
@@ -147,6 +156,7 @@ public static bool TryReadRoster(byte[] buffer, int length, Point[] points,
             if (length < RosterSize(declared)) return false;
 
             mode = (BasisCameraDollySync)buffer[1];
+            looped = (buffer[3] & RosterFlagLooped) != 0;
             count = declared;
 
             int offset = RosterHeader;