feat: animation API (work in progress)

CHANGELOG.md

@@ -9,6 +9,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - [#486] Add Simplified Chinese support
+- [#467] Added the `AnimatorServicesContext` and lots of supporting APIs for working with animator controllers.
+- [#472] [#474] Added the `DependsOnContext` attribute, for declaring dependencies between extension contexts.
+- [#473] Added `BuildContext.SetEnableUVDistributionRecalculation` to allow opting out from the automatic call to
+  `Mesh.RecalculateUVDistributionMetrics` on generated meshes.
+
 ### Fixed
 - [#487] Fixed a performance issue where all assets would potentially be loaded on reimport, taking a lot of time and
   memory in the process

Editor/API/AnimatorServices/AnimationIndex.cs

@@ -0,0 +1,230 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+
+namespace nadena.dev.ndmf.animator
+{
+    public sealed class AnimationIndex
+    {
+        private readonly Func<IEnumerable<VirtualNode>> _getRoots;
+        private readonly Func<long> _getInvalidationToken;
+
+        private long _lastInvalidationToken;
+
+        private readonly Action _invalidateAction;
+        private bool _isValid;
+
+        private bool IsValid => _isValid && _lastInvalidationToken == _getInvalidationToken();
+
+        private readonly Dictionary<string, HashSet<VirtualClip>> _objectPathToClip = new();
+        private readonly Dictionary<EditorCurveBinding, HashSet<VirtualClip>> _bindingToClip = new();
+        private readonly Dictionary<VirtualClip, HashSet<EditorCurveBinding>> _lastBindings = new();
+
+        internal AnimationIndex(
+            Func<IEnumerable<VirtualAnimatorController>> getRoots,
+            Func<long> getInvalidationToken)
+        {
+            _getRoots = getRoots;
+            _getInvalidationToken = getInvalidationToken;
+            _invalidateAction = () => _isValid = false;
+        }
+
+        public AnimationIndex(IEnumerable<VirtualNode> controllers)
+        {
+            _invalidateAction = () => _isValid = false;
+            var controllerList = new List<VirtualNode>(controllers);
+            _getRoots = () => controllerList;
+            _getInvalidationToken = () => _lastInvalidationToken;
+        }
+
+        public IEnumerable<VirtualClip> GetClipsForObjectPath(string objectPath)
+        {
+            if (!IsValid) RebuildCache();
+
+            if (_objectPathToClip.TryGetValue(objectPath, out var clips))
+            {
+                return clips;
+            }
+
+            return Enumerable.Empty<VirtualClip>();
+        }
+
+        public IEnumerable<VirtualClip> GetClipsForBinding(EditorCurveBinding binding)
+        {
+            if (!IsValid) RebuildCache();
+
+            if (_bindingToClip.TryGetValue(binding, out var clips))
+            {
+                return clips;
+            }
+
+            return Enumerable.Empty<VirtualClip>();
+        }
+
+        public void RewritePaths(Func<string, string?> rewriteRules)
+        {
+            if (!IsValid) RebuildCache();
+
+            var rewriteSet = _objectPathToClip.Values.SelectMany(s => s).Distinct();
+
+            RewritePaths(rewriteSet, rewriteRules);
+        }
+
+        public void RewritePaths(Dictionary<string, string?> rewriteRules)
+        {
+            if (!IsValid) RebuildCache();
+
+            HashSet<VirtualClip> rewriteSet = new();
+
+            foreach (var key in rewriteRules.Keys)
+            {
+                if (!_objectPathToClip.TryGetValue(key, out var clips)) continue;
+                rewriteSet.UnionWith(clips);
+            }
+
+            Func<string, string?> rewriteFunc = k =>
+            {
+                // Note: We don't use GetValueOrDefault here as we want to distinguish between null and missing keys
+                // ReSharper disable once CanSimplifyDictionaryTryGetValueWithGetValueOrDefault
+                if (rewriteRules.TryGetValue(k, out var v)) return v;
+                return k;
+            };
+
+            RewritePaths(rewriteSet, rewriteFunc);
+        }
+
+        private void RewritePaths(IEnumerable<VirtualClip> rewriteSet, Func<string, string?> rewriteFunc)
+        {
+            List<VirtualClip> recacheNeeded = new();
+
+            foreach (var clip in rewriteSet)
+            {
+                clip.EditPaths(rewriteFunc);
+                if (!_isValid)
+                {
+                    recacheNeeded.Add(clip);
+                }
+
+                _isValid = true;
+            }
+
+            foreach (var clip in recacheNeeded)
+            {
+                CacheClip(clip);
+            }
+        }
+
+        public void EditClipsByBinding(IEnumerable<EditorCurveBinding> binding, Action<VirtualClip> processClip)
+        {
+            if (!IsValid) RebuildCache();
+
+            var clips = binding.SelectMany(GetClipsForBinding).ToHashSet();
+            var toRecache = new List<VirtualClip>();
+            foreach (var clip in clips)
+            {
+                processClip(clip);
+                if (!_isValid)
+                {
+                    toRecache.Add(clip);
+                }
+
+                _isValid = true;
+            }
+
+            foreach (var clip in toRecache)
+            {
+                CacheClip(clip);
+            }
+        }
+
+        private void RebuildCache()
+        {
+            _objectPathToClip.Clear();
+            _bindingToClip.Clear();
+            _lastBindings.Clear();
+
+            foreach (var clip in EnumerateClips())
+            {
+                CacheClip(clip);
+            }
+
+            _isValid = true;
+        }
+
+        private void CacheClip(VirtualClip clip)
+        {
+            if (_lastBindings.TryGetValue(clip, out var lastBindings))
+            {
+                foreach (var binding in lastBindings)
+                {
+                    _bindingToClip[binding].Remove(clip);
+                    _objectPathToClip[binding.path].Remove(clip);
+                }
+            }
+            else
+            {
+                lastBindings = new HashSet<EditorCurveBinding>();
+                _lastBindings[clip] = lastBindings;
+            }
+
+            lastBindings.Clear();
+            lastBindings.UnionWith(clip.GetObjectCurveBindings());
+            lastBindings.UnionWith(clip.GetFloatCurveBindings());
+
+            foreach (var binding in lastBindings)
+            {
+                if (!_bindingToClip.TryGetValue(binding, out var clips))
+                {
+                    clips = new HashSet<VirtualClip>();
+                    _bindingToClip[binding] = clips;
+                }
+
+                clips.Add(clip);
+
+                if (!_objectPathToClip.TryGetValue(binding.path, out var pathClips))
+                {
+                    pathClips = new HashSet<VirtualClip>();
+                    _objectPathToClip[binding.path] = pathClips;
+                }
+
+                pathClips.Add(clip);
+            }
+        }
+
+        private IEnumerable<VirtualClip> EnumerateClips()
+        {
+            HashSet<object> visited = new();
+            Queue<VirtualNode> queue = new();
+
+            _lastInvalidationToken = _getInvalidationToken();
+            foreach (var controller in _getRoots())
+            {
+                queue.Enqueue(controller);
+            }
+
+            while (queue.Count > 0)
+            {
+                var node = queue.Dequeue();
+                node.RegisterCacheObserver(_invalidateAction);
+
+                if (!visited.Add(node))
+                {
+                    continue;
+                }
+
+                foreach (var child in node.EnumerateChildren())
+                {
+                    if (!visited.Contains(child)) queue.Enqueue(child);
+                }
+
+                if (node is VirtualClip clip)
+                {
+                    yield return clip;
+                }
+            }
+        }
+    }
+}

Editor/API/AnimatorServices/AnimatorServicesContext.cs

@@ -0,0 +1,58 @@
+#nullable enable
+
+using System;
+using JetBrains.Annotations;
+
+namespace nadena.dev.ndmf.animator
+{
+    /// <summary>
+    ///     Provides a number of NDMF services based on virtualizing animator controllers.
+    ///     While this context is active, NDMF will automatically track object renames, and apply them to all known
+    ///     animators. It will also keep animators cached in the VirtualControllerContext (which is also, as a convenience,
+    ///     available through this class).
+    ///     Note that any new objects created should be registered in the ObjectPathRemapper if they'll be used in animations;
+    ///     this ensures that subsequent movements will be tracked properly. Likewise, use ObjectPathRemapper to obtain
+    ///     (virtual) object paths for newly created objects.
+    /// </summary>
+    [DependsOnContext(typeof(VirtualControllerContext))]
+    [PublicAPI]
+    public sealed class AnimatorServicesContext : IExtensionContext
+    {
+        private VirtualControllerContext? _controllerContext;
+
+        public VirtualControllerContext ControllerContext => _controllerContext ??
+                                                             throw new InvalidOperationException(
+                                                                 "ControllerContext is not available outside of the AnimatorServicesContext");
+
+        private AnimationIndex? _animationIndex;
+
+        public AnimationIndex AnimationIndex => _animationIndex ??
+                                                throw new InvalidOperationException(
+                                                    "AnimationIndex is not available outside of the AnimatorServicesContext");
+
+        private ObjectPathRemapper? _objectPathRemapper;
+
+        public ObjectPathRemapper ObjectPathRemapper => _objectPathRemapper ??
+                                                        throw new InvalidOperationException(
+                                                            "ObjectPathRemapper is not available outside of the AnimatorServicesContext");
+
+        public void OnActivate(BuildContext context)
+        {
+            _controllerContext = context.Extension<VirtualControllerContext>();
+            _animationIndex = new AnimationIndex(
+                () => ControllerContext.GetAllControllers(),
+                () => ControllerContext.CacheInvalidationToken
+            );
+            _objectPathRemapper = new ObjectPathRemapper(context.AvatarRootTransform);
+        }
+
+        public void OnDeactivate(BuildContext context)
+        {
+            AnimationIndex.RewritePaths(ObjectPathRemapper.GetVirtualToRealPathMap());
+
+            _objectPathRemapper = null;
+            _animationIndex = null;
+            _controllerContext = null;
+        }
+    }
+}