com.wallstop-studios.unity-helpers 2.0.0-rc75.9 → 2.0.0-rc76.1

package/Editor/Sprites/AnimationViewerWindow.cs

@@ -0,0 +1,1521 @@
+// ReSharper disable HeapView.CanAvoidClosure
+namespace WallstopStudios.UnityHelpers.Editor.Sprites
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using Core.Extension;
+    using Core.Helper;
+    using UnityEditor;
+    using UnityEditor.UIElements;
+    using UnityEngine;
+    using UnityEngine.UIElements;
+    using UI;
+    using Object = UnityEngine.Object;
+
+    public sealed class AnimationViewerWindow : EditorWindow
+    {
+        private const string PackageId = "com.wallstop-studios.unity-helpers";
+        private const float DragThresholdSqrMagnitude = 10f * 10f;
+        private const int InvalidPointerId = -1;
+
+        private sealed class EditorLayerData
+        {
+            public AnimationClip SourceClip { get; }
+            public List<Sprite> Sprites { get; }
+            public string ClipName => SourceClip != null ? SourceClip.name : "Unnamed Layer";
+            public float OriginalClipFps { get; }
+            public string BindingPath { get; }
+
+            public EditorLayerData(AnimationClip clip)
+            {
+                SourceClip = clip;
+                Sprites = clip.GetSpritesFromClip()?.ToList();
+                OriginalClipFps =
+                    clip.frameRate > 0 ? clip.frameRate : AnimatedSpriteLayer.FrameRate;
+
+                BindingPath = string.Empty;
+                if (SourceClip != null)
+                {
+                    foreach (
+                        EditorCurveBinding binding in AnimationUtility.GetObjectReferenceCurveBindings(
+                            SourceClip
+                        )
+                    )
+                    {
+                        if (
+                            binding.type == typeof(SpriteRenderer)
+                            && binding.propertyName == "m_Sprite"
+                        )
+                        {
+                            BindingPath = binding.path;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        [MenuItem("Tools/Wallstop Studios/Unity Helpers/Sprite Animation Editor")]
+        public static void ShowWindow()
+        {
+            AnimationViewerWindow wnd = GetWindow<AnimationViewerWindow>();
+            wnd.titleContent = new GUIContent("2D Animation Viewer");
+            wnd.minSize = new Vector2(750, 500);
+        }
+
+        private VisualTreeAsset _visualTree;
+        private StyleSheet _styleSheet;
+
+        private ObjectField _addAnimationClipField;
+        private Button _browseAndAddButton;
+        private FloatField _fpsField;
+        private Button _applyFpsButton;
+        private Button _saveClipButton;
+        private VisualElement _loadedClipsContainer;
+        private VisualElement _previewPanelHost;
+        private LayeredImage _animationPreview;
+        private VisualElement _framesContainer;
+        private Label _fpsDebugLabel;
+        private Label _framesPanelTitle;
+        private MultiFileSelectorElement _fileSelector;
+
+        private readonly List<EditorLayerData> _loadedEditorLayers = new();
+
+        private EditorLayerData _activeEditorLayer;
+        private float _currentPreviewFps = AnimatedSpriteLayer.FrameRate;
+
+        private VisualElement _draggedFrameElement;
+        private int _draggedFrameOriginalDataIndex;
+        private VisualElement _frameDropPlaceholder;
+
+        private VisualElement _draggedLoadedClipElement;
+        private int _draggedLoadedClipOriginalIndex;
+        private VisualElement _loadedClipDropPlaceholder;
+
+        private bool _isClipDragPending;
+        private Vector3 _clipDragStartPosition;
+        private VisualElement _clipDragPendingElement;
+        private int _clipDragPendingOriginalIndex;
+
+        public void CreateGUI()
+        {
+            VisualElement root = rootVisualElement;
+
+            TryLoadStyleSheets();
+
+            if (_visualTree == null)
+            {
+                root.Add(new Label("Error: AnimationViewer.uxml not found."));
+                return;
+            }
+            if (_styleSheet != null)
+            {
+                root.styleSheets.Add(_styleSheet);
+            }
+
+            _visualTree.CloneTree(root);
+
+            _addAnimationClipField = root.Q<ObjectField>("addAnimationClipField");
+            _browseAndAddButton = root.Q<Button>("browseAndAddButton");
+            _fpsField = root.Q<FloatField>("fpsField");
+            _applyFpsButton = root.Q<Button>("applyFpsButton");
+            _saveClipButton = root.Q<Button>("saveClipButton");
+            _loadedClipsContainer = root.Q<VisualElement>("loadedClipsContainer");
+            _previewPanelHost = root.Q<VisualElement>("preview-panel");
+            _framesContainer = root.Q<VisualElement>("framesContainer");
+            _fpsDebugLabel = root.Q<Label>("fpsDebugLabel");
+            _framesPanelTitle = root.Q<Label>("framesPanelTitle");
+
+            _previewPanelHost.AddToClassList("animation-preview-container");
+
+            _fpsField.value = _currentPreviewFps;
+            _saveClipButton.SetEnabled(false);
+
+            _addAnimationClipField.RegisterValueChangedCallback(OnAddAnimationClipFieldChanged);
+            _browseAndAddButton.text = "Add Selected Clips from Project";
+            _browseAndAddButton.clicked -= OnBrowseAndAddClicked;
+            if (_browseAndAddButton != null)
+            {
+                _browseAndAddButton.text = "Browse Clips (Multi)...";
+                _browseAndAddButton.clicked -= OnAddSelectedClipsFromProjectClicked;
+                _browseAndAddButton.clicked += ToggleMultiFileSelector;
+            }
+            else
+            {
+                this.LogError(
+                    $"'browseAndAddButton' not found in UXML. Multi-file browser cannot be triggered."
+                );
+            }
+            _applyFpsButton.clicked += OnApplyFpsToPreviewClicked;
+            _saveClipButton.clicked += OnSaveClipClicked;
+
+            _frameDropPlaceholder = new VisualElement();
+            _frameDropPlaceholder.AddToClassList("drop-placeholder");
+            _frameDropPlaceholder.style.height = 5;
+            _frameDropPlaceholder.style.visibility = Visibility.Hidden;
+
+            _framesContainer.RegisterCallback<DragUpdatedEvent>(OnFramesContainerDragUpdated);
+            _framesContainer.RegisterCallback<DragPerformEvent>(OnFramesContainerDragPerform);
+            _framesContainer.RegisterCallback<DragLeaveEvent>(OnFramesContainerDragLeave);
+
+            _loadedClipDropPlaceholder = new VisualElement();
+            _loadedClipDropPlaceholder.AddToClassList("drop-placeholder");
+            _loadedClipDropPlaceholder.style.height = 5;
+            _loadedClipDropPlaceholder.style.visibility = Visibility.Hidden;
+
+            _loadedClipsContainer.RegisterCallback<DragUpdatedEvent>(
+                OnLoadedClipsContainerDragUpdated
+            );
+            _loadedClipsContainer.RegisterCallback<DragPerformEvent>(
+                OnLoadedClipsContainerDragPerform
+            );
+            _loadedClipsContainer.RegisterCallback<DragLeaveEvent>(OnLoadedClipsContainerDragLeave);
+
+            UpdateFramesPanelTitle();
+            RebuildLoadedClipsUI();
+            RecreatePreviewImage();
+        }
+
+        private void Update()
+        {
+            _animationPreview?.Update();
+        }
+
+        private void TryLoadStyleSheets()
+        {
+            string packageRoot = DirectoryHelper.FindPackageRootPath(
+                DirectoryHelper.GetCallerScriptDirectory()
+            );
+            if (!string.IsNullOrWhiteSpace(packageRoot))
+            {
+                if (
+                    packageRoot.StartsWith("Packages", StringComparison.OrdinalIgnoreCase)
+                    && !packageRoot.Contains(PackageId, StringComparison.OrdinalIgnoreCase)
+                )
+                {
+                    int helpersIndex = packageRoot.LastIndexOf(
+                        "UnityHelpers",
+                        StringComparison.Ordinal
+                    );
+                    if (0 <= helpersIndex)
+                    {
+                        packageRoot = packageRoot[..helpersIndex];
+                        packageRoot += PackageId;
+                    }
+                }
+
+                char pathSeparator = Path.DirectorySeparatorChar;
+                string styleSheetPath =
+                    $"{packageRoot}{pathSeparator}Editor{pathSeparator}Styles{pathSeparator}AnimationViewer.uss";
+                string unityRelativeStyleSheetPath = DirectoryHelper.AbsoluteToUnityRelativePath(
+                    styleSheetPath
+                );
+                unityRelativeStyleSheetPath = unityRelativeStyleSheetPath.SanitizePath();
+
+                const string packageCache = "PackageCache/";
+                int packageCacheIndex;
+                if (!string.IsNullOrWhiteSpace(unityRelativeStyleSheetPath))
+                {
+                    _styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(
+                        unityRelativeStyleSheetPath
+                    );
+                }
+
+                if (_styleSheet == null && !string.IsNullOrWhiteSpace(unityRelativeStyleSheetPath))
+                {
+                    packageCacheIndex = unityRelativeStyleSheetPath.IndexOf(
+                        packageCache,
+                        StringComparison.OrdinalIgnoreCase
+                    );
+                    if (0 <= packageCacheIndex)
+                    {
+                        unityRelativeStyleSheetPath = unityRelativeStyleSheetPath[
+                            (packageCacheIndex + packageCache.Length)..
+                        ];
+                        int forwardIndex = unityRelativeStyleSheetPath.IndexOf(
+                            "/",
+                            StringComparison.Ordinal
+                        );
+                        if (0 <= forwardIndex)
+                        {
+                            unityRelativeStyleSheetPath = unityRelativeStyleSheetPath.Substring(
+                                forwardIndex
+                            );
+                            unityRelativeStyleSheetPath =
+                                "Packages/" + PackageId + "/" + unityRelativeStyleSheetPath;
+                        }
+                        else
+                        {
+                            unityRelativeStyleSheetPath = "Packages/" + unityRelativeStyleSheetPath;
+                        }
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(unityRelativeStyleSheetPath))
+                    {
+                        _styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(
+                            unityRelativeStyleSheetPath
+                        );
+                        if (_styleSheet == null)
+                        {
+                            this.LogError(
+                                $"Failed to load Animation Viewer style sheet (package root: '{packageRoot}'), relative path '{unityRelativeStyleSheetPath}'."
+                            );
+                        }
+                    }
+                    else
+                    {
+                        this.LogError(
+                            $"Failed to convert absolute path '{styleSheetPath}' to Unity relative path."
+                        );
+                    }
+                }
+
+                string visualTreePath =
+                    $"{packageRoot}{pathSeparator}Editor{pathSeparator}Styles{pathSeparator}AnimationViewer.uxml";
+                string unityRelativeVisualTreePath = DirectoryHelper.AbsoluteToUnityRelativePath(
+                    visualTreePath
+                );
+
+                _visualTree = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(
+                    unityRelativeVisualTreePath
+                );
+                if (_visualTree == null)
+                {
+                    packageCacheIndex = unityRelativeVisualTreePath.IndexOf(
+                        packageCache,
+                        StringComparison.OrdinalIgnoreCase
+                    );
+                    if (0 <= packageCacheIndex)
+                    {
+                        unityRelativeVisualTreePath = unityRelativeVisualTreePath[
+                            (packageCacheIndex + packageCache.Length)..
+                        ];
+                        int forwardIndex = unityRelativeVisualTreePath.IndexOf(
+                            "/",
+                            StringComparison.Ordinal
+                        );
+                        if (0 <= forwardIndex)
+                        {
+                            unityRelativeVisualTreePath = unityRelativeVisualTreePath.Substring(
+                                forwardIndex
+                            );
+                            unityRelativeVisualTreePath =
+                                "Packages/" + PackageId + "/" + unityRelativeVisualTreePath;
+                        }
+                        else
+                        {
+                            unityRelativeVisualTreePath = "Packages/" + unityRelativeVisualTreePath;
+                        }
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(unityRelativeVisualTreePath))
+                    {
+                        _visualTree = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(
+                            unityRelativeVisualTreePath
+                        );
+                    }
+                }
+            }
+            else
+            {
+                this.LogError(
+                    $"Failed to find Animation Viewer style sheet (package root: '{packageRoot}')."
+                );
+            }
+        }
+
+        private void ToggleMultiFileSelector()
+        {
+            VisualElement root = rootVisualElement;
+            if (_fileSelector == null)
+            {
+                _fileSelector = new MultiFileSelectorElement(
+                    ProjectAnimationSettings.Instance.lastAnimationPath,
+                    new[] { ".anim" }
+                );
+                _fileSelector.OnFilesSelected += HandleFilesSelectedFromCustomBrowser;
+                _fileSelector.OnCancelled += HideMultiFileSelector;
+                root.Add(_fileSelector);
+                if (root.childCount > 1)
+                {
+                    _fileSelector.PlaceInFront(root.Children().FirstOrDefault());
+                }
+            }
+            else if (_fileSelector.parent == null)
+            {
+                _fileSelector.ResetAndShow(ProjectAnimationSettings.Instance.lastAnimationPath);
+                root.Add(_fileSelector);
+                if (root.childCount > 1)
+                {
+                    _fileSelector.PlaceInFront(root.Children().FirstOrDefault());
+                }
+            }
+            else
+            {
+                HideMultiFileSelector();
+            }
+        }
+
+        private void HideMultiFileSelector()
+        {
+            if (_fileSelector is { parent: not null })
+            {
+                _fileSelector.parent.Remove(_fileSelector);
+            }
+        }
+
+        private void HandleFilesSelectedFromCustomBrowser(List<string> selectedFullPaths)
+        {
+            HideMultiFileSelector();
+
+            if (selectedFullPaths == null || selectedFullPaths.Count == 0)
+            {
+                return;
+            }
+
+            int clipsAddedCount = 0;
+            string lastValidDirectory = null;
+
+            foreach (string fullPath in selectedFullPaths)
+            {
+                string assetPath = fullPath.SanitizePath();
+                if (!assetPath.StartsWith("Assets", StringComparison.OrdinalIgnoreCase))
+                {
+                    if (
+                        assetPath.StartsWith(
+                            Application.dataPath,
+                            StringComparison.OrdinalIgnoreCase
+                        )
+                    )
+                    {
+                        assetPath = "Assets" + assetPath.Substring(Application.dataPath.Length);
+                    }
+                    else
+                    {
+                        this.LogWarn(
+                            $"Selected file '{fullPath}' is outside the project's Assets folder or path is not project-relative. Skipping."
+                        );
+                        continue;
+                    }
+                }
+
+                AnimationClip clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(assetPath);
+                if (clip != null)
+                {
+                    if (_loadedEditorLayers.All(layer => layer.SourceClip != clip))
+                    {
+                        AddEditorLayer(clip);
+                        clipsAddedCount++;
+                        lastValidDirectory = Path.GetDirectoryName(assetPath);
+                    }
+                    else
+                    {
+                        this.LogWarn($"Clip '{clip.name}' already loaded. Skipping.");
+                    }
+                }
+                else
+                {
+                    this.LogWarn($"Could not load AnimationClip from: {assetPath}");
+                }
+            }
+
+            if (clipsAddedCount > 0)
+            {
+                this.Log($"Added {clipsAddedCount} clip(s).");
+                if (!string.IsNullOrWhiteSpace(lastValidDirectory))
+                {
+                    ProjectAnimationSettings.Instance.lastAnimationPath = lastValidDirectory;
+                    ProjectAnimationSettings.Instance.Save();
+                }
+            }
+        }
+
+        private void OnAddAnimationClipFieldChanged(ChangeEvent<Object> evt)
+        {
+            AnimationClip clip = evt.newValue as AnimationClip;
+            if (clip != null)
+            {
+                AddEditorLayer(clip);
+                _addAnimationClipField.SetValueWithoutNotify(null);
+            }
+        }
+
+        private void OnAddSelectedClipsFromProjectClicked()
+        {
+            Object[] selectedObjects = Selection.GetFiltered(
+                typeof(AnimationClip),
+                SelectionMode.Assets
+            );
+
+            if (selectedObjects == null || selectedObjects.Length == 0)
+            {
+                EditorUtility.DisplayDialog(
+                    "No Clips Selected",
+                    "Please select one or more AnimationClip assets in the Project window first.",
+                    "OK"
+                );
+                return;
+            }
+
+            int clipsAddedCount = 0;
+            foreach (Object obj in selectedObjects)
+            {
+                if (obj is AnimationClip clip)
+                {
+                    bool alreadyExists = _loadedEditorLayers.Any(layer => layer.SourceClip == clip);
+                    if (!alreadyExists)
+                    {
+                        AddEditorLayer(clip);
+                        clipsAddedCount++;
+                    }
+                    else
+                    {
+                        this.LogWarn($"Clip '{clip.name}' is already loaded. Skipping.");
+                    }
+                }
+            }
+
+            if (clipsAddedCount > 0)
+            {
+                this.Log($"Added {clipsAddedCount} new AnimationClip(s) to the viewer.");
+            }
+            else if (selectedObjects.Length > 0)
+            {
+                this.Log($"All selected AnimationClips were already loaded.");
+            }
+        }
+
+        private void OnBrowseAndAddClicked()
+        {
+            string path = EditorUtility.OpenFilePanelWithFilters(
+                "Select Animation Clip to Add",
+                ProjectAnimationSettings.Instance.lastAnimationPath,
+                new[] { "Animation Clip", "anim" }
+            );
+
+            if (!string.IsNullOrWhiteSpace(path))
+            {
+                if (path.StartsWith(Application.dataPath))
+                {
+                    path = "Assets" + path.Substring(Application.dataPath.Length);
+                }
+
+                ProjectAnimationSettings.Instance.lastAnimationPath = Path.GetDirectoryName(path);
+                ProjectAnimationSettings.Instance.Save();
+
+                AnimationClip clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(path);
+                if (clip != null)
+                {
+                    AddEditorLayer(clip);
+                }
+            }
+        }
+
+        private void AddEditorLayer(AnimationClip clip)
+        {
+            if (clip == null || _loadedEditorLayers.Any(layer => layer.SourceClip == clip))
+            {
+                this.LogWarn($"Clip '{clip?.name}' is null or already loaded.");
+                return;
+            }
+
+            EditorLayerData newEditorLayer = new(clip);
+            _loadedEditorLayers.Add(newEditorLayer);
+
+            if (_activeEditorLayer == null && newEditorLayer.Sprites.Count > 0)
+            {
+                SetActiveEditorLayer(newEditorLayer);
+            }
+            else if (_activeEditorLayer == null)
+            {
+                SetActiveEditorLayer(newEditorLayer);
+            }
+
+            RebuildLoadedClipsUI();
+            RecreatePreviewImage();
+        }
+
+        private void RemoveEditorLayer(EditorLayerData layerToRemove)
+        {
+            if (layerToRemove == null)
+            {
+                return;
+            }
+
+            _loadedEditorLayers.Remove(layerToRemove);
+
+            if (_activeEditorLayer == layerToRemove)
+            {
+                SetActiveEditorLayer(_loadedEditorLayers.FirstOrDefault());
+            }
+
+            RebuildLoadedClipsUI();
+            RecreatePreviewImage();
+        }
+
+        private void SetActiveEditorLayer(EditorLayerData layer)
+        {
+            _activeEditorLayer = layer;
+            _framesContainer.Clear();
+            _fpsDebugLabel.text = "Detected FPS Info (Active Clip):";
+
+            if (_activeEditorLayer != null)
+            {
+                UpdateFpsDebugLabelForActiveLayer();
+                _saveClipButton.SetEnabled(_activeEditorLayer.SourceClip != null);
+            }
+            else
+            {
+                _saveClipButton.SetEnabled(false);
+            }
+
+            RebuildFramesListUI();
+            RebuildLoadedClipsUI();
+            UpdateFramesPanelTitle();
+        }
+
+        private void UpdateFramesPanelTitle()
+        {
+            _framesPanelTitle.text =
+                _activeEditorLayer != null
+                    ? $"Frames (Editing: {_activeEditorLayer.ClipName})"
+                    : "Frames (No Active Clip Selected)";
+        }
+
+        private void RebuildLoadedClipsUI()
+        {
+            _loadedClipsContainer.Clear();
+            if (_loadedClipDropPlaceholder.parent == _loadedClipsContainer)
+            {
+                _loadedClipsContainer.Remove(_loadedClipDropPlaceholder);
+            }
+
+            for (int i = 0; i < _loadedEditorLayers.Count; i++)
+            {
+                EditorLayerData editorLayer = _loadedEditorLayers[i];
+
+                VisualElement itemElement = new();
+                itemElement.AddToClassList("loaded-clip-item");
+                if (editorLayer == _activeEditorLayer)
+                {
+                    itemElement.AddToClassList("loaded-clip-item--active");
+                }
+                itemElement.userData = i;
+
+                Label label = new(editorLayer.ClipName);
+                itemElement.Add(label);
+
+                Button removeButton = new(() => RemoveEditorLayer(editorLayer)) { text = "X" };
+                itemElement.Add(removeButton);
+
+                itemElement.RegisterCallback<PointerDownEvent>(evt =>
+                {
+                    if (evt.button == 0 && _draggedLoadedClipElement == null)
+                    {
+                        SetActiveEditorLayer(editorLayer);
+                    }
+                });
+
+                int currentIndex = i;
+                itemElement.RegisterCallback<PointerDownEvent>(evt =>
+                    OnLoadedClipItemPointerDownSetup(evt, itemElement, currentIndex)
+                );
+                itemElement.RegisterCallback<PointerMoveEvent>(OnLoadedClipItemPointerMove);
+                itemElement.RegisterCallback<PointerUpEvent>(evt =>
+                    OnLoadedClipItemPointerUpForClick(evt, itemElement, currentIndex)
+                );
+
+                _loadedClipsContainer.Add(itemElement);
+            }
+        }
+
+        private void OnLoadedClipItemPointerDownSetup(
+            PointerDownEvent evt,
+            VisualElement clipElement,
+            int originalListIndex
+        )
+        {
+            if (evt.button != 0 || _draggedLoadedClipElement != null || _isClipDragPending)
+            {
+                return;
+            }
+
+            _isClipDragPending = true;
+            _clipDragPendingElement = clipElement;
+            _clipDragPendingOriginalIndex = originalListIndex;
+            _clipDragStartPosition = evt.position;
+
+            clipElement.CapturePointer(evt.pointerId);
+
+            evt.StopPropagation();
+        }
+
+        private void OnLoadedClipItemPointerMove(PointerMoveEvent evt)
+        {
+            if (!_isClipDragPending)
+            {
+                return;
+            }
+
+            float diffSqrMagnitude = (evt.position - _clipDragStartPosition).sqrMagnitude;
+
+            if (diffSqrMagnitude >= DragThresholdSqrMagnitude)
+            {
+                _draggedLoadedClipElement = _clipDragPendingElement;
+                _draggedLoadedClipOriginalIndex = _clipDragPendingOriginalIndex;
+
+                _draggedLoadedClipElement.AddToClassList("frame-item-dragged");
+
+                DragAndDrop.PrepareStartDrag();
+                DragAndDrop.SetGenericData(
+                    "DraggedLoadedClipIndex",
+                    _draggedLoadedClipOriginalIndex
+                );
+                Object dragContextObject =
+                    _loadedEditorLayers[_draggedLoadedClipOriginalIndex]?.SourceClip
+                    ?? (Object)CreateInstance<ScriptableObject>();
+                DragAndDrop.objectReferences = new[] { dragContextObject };
+                DragAndDrop.StartDrag(
+                    _loadedEditorLayers[_draggedLoadedClipOriginalIndex].ClipName
+                        ?? "Dragging Layer"
+                );
+
+                _isClipDragPending = false;
+            }
+        }
+
+        private void OnLoadedClipItemPointerUpForClick(
+            PointerUpEvent evt,
+            VisualElement clipElement,
+            int listIndex
+        )
+        {
+            if (evt.button != 0)
+            {
+                return;
+            }
+
+            if (clipElement.HasPointerCapture(evt.pointerId))
+            {
+                clipElement.ReleasePointer(evt.pointerId);
+            }
+            if (_isClipDragPending)
+            {
+                if (listIndex >= 0 && listIndex < _loadedEditorLayers.Count)
+                {
+                    SetActiveEditorLayer(_loadedEditorLayers[listIndex]);
+                }
+                _isClipDragPending = false;
+                _clipDragPendingElement = null;
+                evt.StopPropagation();
+            }
+            else if (_draggedLoadedClipElement == _clipDragPendingElement)
+            {
+                if (DragAndDrop.GetGenericData("DraggedLoadedClipIndex") != null)
+                {
+                    CleanupLoadedClipDragState(evt.pointerId);
+                }
+                evt.StopPropagation();
+            }
+
+            _isClipDragPending = false;
+            _clipDragPendingElement = null;
+        }
+
+        private void OnDraggedLoadedClipItemPointerUp(PointerUpEvent evt)
+        {
+            if (_draggedLoadedClipElement == null || evt.currentTarget != _draggedLoadedClipElement)
+            {
+                return;
+            }
+
+            if (
+                DragAndDrop.GetGenericData("DraggedLoadedClipIndex") != null
+                || _draggedLoadedClipElement != null
+                    && _draggedLoadedClipElement.HasPointerCapture(evt.pointerId)
+            )
+            {
+                CleanupLoadedClipDragState(evt.pointerId);
+            }
+
+            evt.StopPropagation();
+        }
+
+        private void OnLoadedClipsContainerDragUpdated(DragUpdatedEvent evt)
+        {
+            object draggedIndexData = DragAndDrop.GetGenericData("DraggedLoadedClipIndex");
+            if (draggedIndexData != null && _draggedLoadedClipElement != null)
+            {
+                DragAndDrop.visualMode = DragAndDropVisualMode.Move;
+                float mouseY = evt.localMousePosition.y;
+                int newVisualIndex = -1;
+
+                if (_loadedClipDropPlaceholder.parent == _loadedClipsContainer)
+                {
+                    _loadedClipsContainer.Remove(_loadedClipDropPlaceholder);
+                }
+
+                for (int i = 0; i < _loadedClipsContainer.childCount; i++)
+                {
+                    VisualElement child = _loadedClipsContainer[i];
+                    if (child == _draggedLoadedClipElement)
+                    {
+                        continue;
+                    }
+
+                    float childMidY = child.layout.yMin + child.layout.height / 2f;
+                    if (mouseY < childMidY)
+                    {
+                        newVisualIndex = i;
+                        break;
+                    }
+                }
+                if (
+                    newVisualIndex < 0
+                    && _loadedClipsContainer.childCount > 0
+                    && _draggedLoadedClipElement
+                        != _loadedClipsContainer.ElementAt(_loadedClipsContainer.childCount - 1)
+                )
+                {
+                    newVisualIndex = _loadedClipsContainer.childCount;
+                }
+
+                if (0 <= newVisualIndex)
+                {
+                    _loadedClipsContainer.Insert(newVisualIndex, _loadedClipDropPlaceholder);
+                    _loadedClipDropPlaceholder.style.visibility = Visibility.Visible;
+                }
+                else if (_loadedClipsContainer.childCount == 0 && _draggedLoadedClipElement != null)
+                {
+                    _loadedClipsContainer.Add(_loadedClipDropPlaceholder);
+                    _loadedClipDropPlaceholder.style.visibility = Visibility.Visible;
+                }
+                else
+                {
+                    if (_loadedClipDropPlaceholder.parent == _loadedClipsContainer)
+                    {
+                        _loadedClipsContainer.Remove(_loadedClipDropPlaceholder);
+                    }
+
+                    _loadedClipDropPlaceholder.style.visibility = Visibility.Hidden;
+                }
+            }
+            else
+            {
+                DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
+            }
+            evt.StopPropagation();
+        }
+
+        private void OnLoadedClipsContainerDragPerform(DragPerformEvent evt)
+        {
+            object draggedIndexData = DragAndDrop.GetGenericData("DraggedLoadedClipIndex");
+            if (draggedIndexData != null && _draggedLoadedClipElement != null)
+            {
+                int originalListIndex = (int)draggedIndexData;
+
+                if (originalListIndex < 0 || originalListIndex >= _loadedEditorLayers.Count)
+                {
+                    this.LogError(
+                        $"DragPerform (LoadedClips): Stale or invalid dragged index. Aborting drop."
+                    );
+                    CleanupLoadedClipDragState(InvalidPointerId);
+                    evt.StopPropagation();
+                    return;
+                }
+
+                EditorLayerData movedLayer = _loadedEditorLayers[originalListIndex];
+                _loadedEditorLayers.RemoveAt(originalListIndex);
+
+                int placeholderVisualIndex = _loadedClipsContainer.IndexOf(
+                    _loadedClipDropPlaceholder
+                );
+                int targetListIndex;
+
+                if (0 <= placeholderVisualIndex)
+                {
+                    int itemsBeforePlaceholder = -1;
+                    for (int i = 0; i < placeholderVisualIndex; i++)
+                    {
+                        if (_loadedClipsContainer[i] != _loadedClipDropPlaceholder)
+                        {
+                            itemsBeforePlaceholder++;
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    targetListIndex = itemsBeforePlaceholder;
+                }
+                else
+                {
+                    targetListIndex = _loadedEditorLayers.Count;
+                }
+                targetListIndex = Mathf.Clamp(targetListIndex, 0, _loadedEditorLayers.Count);
+                _loadedEditorLayers.Insert(targetListIndex, movedLayer);
+
+                DragAndDrop.AcceptDrag();
+                CleanupLoadedClipDragState(InvalidPointerId);
+
+                RebuildLoadedClipsUI();
+                RecreatePreviewImage();
+            }
+            else
+            {
+                if (DragAndDrop.GetGenericData("DraggedLoadedClipIndex") != null)
+                {
+                    CleanupLoadedClipDragState(InvalidPointerId);
+                }
+            }
+            evt.StopPropagation();
+        }
+
+        private void OnLoadedClipsContainerDragLeave(DragLeaveEvent evt)
+        {
+            if (evt.target == _loadedClipsContainer)
+            {
+                if (_loadedClipDropPlaceholder.parent == _loadedClipsContainer)
+                {
+                    _loadedClipsContainer.Remove(_loadedClipDropPlaceholder);
+                }
+
+                if (_loadedClipDropPlaceholder != null)
+                {
+                    _loadedClipDropPlaceholder.style.visibility = Visibility.Hidden;
+                }
+            }
+        }
+
+        private void CleanupLoadedClipDragState(int pointerIdToRelease)
+        {
+            if (_draggedLoadedClipElement != null)
+            {
+                if (
+                    pointerIdToRelease != InvalidPointerId
+                    && _draggedLoadedClipElement.HasPointerCapture(pointerIdToRelease)
+                )
+                {
+                    _draggedLoadedClipElement.ReleasePointer(pointerIdToRelease);
+                }
+
+                _draggedLoadedClipElement.UnregisterCallback<PointerUpEvent>(
+                    OnDraggedLoadedClipItemPointerUp
+                );
+
+                _draggedLoadedClipElement.RemoveFromClassList("frame-item-dragged");
+                _draggedLoadedClipElement = null;
+            }
+            _draggedLoadedClipOriginalIndex = -1;
+
+            _isClipDragPending = false;
+            if (_clipDragPendingElement != null)
+            {
+                if (
+                    pointerIdToRelease != InvalidPointerId
+                    && _clipDragPendingElement.HasPointerCapture(pointerIdToRelease)
+                )
+                {
+                    _clipDragPendingElement.ReleasePointer(pointerIdToRelease);
+                }
+
+                _clipDragPendingElement = null;
+            }
+
+            if (_loadedClipDropPlaceholder != null)
+            {
+                if (_loadedClipDropPlaceholder.parent == _loadedClipsContainer)
+                {
+                    _loadedClipsContainer.Remove(_loadedClipDropPlaceholder);
+                }
+
+                _loadedClipDropPlaceholder.style.visibility = Visibility.Hidden;
+            }
+            DragAndDrop.SetGenericData("DraggedLoadedClipIndex", null);
+        }
+
+        private void RecreatePreviewImage()
+        {
+            if (_animationPreview != null)
+            {
+                if (_animationPreview.parent == _previewPanelHost)
+                {
+                    _previewPanelHost.Remove(_animationPreview);
+                }
+
+                _animationPreview = null;
+            }
+
+            if (_previewPanelHost == null)
+            {
+                return;
+            }
+
+            List<AnimatedSpriteLayer> animatedSpriteLayers = new();
+            if (_loadedEditorLayers.Count > 0)
+            {
+                foreach (EditorLayerData editorLayer in _loadedEditorLayers)
+                {
+                    animatedSpriteLayers.Add(new AnimatedSpriteLayer(editorLayer.Sprites));
+                }
+            }
+
+            _animationPreview = new LayeredImage(
+                animatedSpriteLayers,
+                Color.clear,
+                _currentPreviewFps,
+                updatesSelf: false
+            )
+            {
+                name = "animationPreviewElement",
+            };
+
+            _previewPanelHost.Add(_animationPreview);
+        }
+
+        private void OnFramesContainerDragUpdated(DragUpdatedEvent evt)
+        {
+            object draggedIndexData = DragAndDrop.GetGenericData("DraggedFrameDataIndex");
+            if (draggedIndexData != null && _draggedFrameElement != null)
+            {
+                DragAndDrop.visualMode = DragAndDropVisualMode.Move;
+                float mouseY = evt.localMousePosition.y;
+                int newVisualIndex = -1;
+
+                if (_frameDropPlaceholder.parent == _framesContainer)
+                {
+                    _framesContainer.Remove(_frameDropPlaceholder);
+                }
+
+                for (int i = 0; i < _framesContainer.childCount; i++)
+                {
+                    VisualElement child = _framesContainer[i];
+                    if (child == _draggedFrameElement)
+                    {
+                        continue;
+                    }
+
+                    float childMidY = child.layout.yMin + child.layout.height / 2f;
+                    if (mouseY < childMidY)
+                    {
+                        newVisualIndex = i;
+                        break;
+                    }
+                }
+                if (
+                    newVisualIndex < 0
+                    && _framesContainer.childCount > 0
+                    && _draggedFrameElement
+                        != _framesContainer.ElementAt(_framesContainer.childCount - 1)
+                )
+                {
+                    newVisualIndex = _framesContainer.childCount;
+                }
+
+                if (0 <= newVisualIndex)
+                {
+                    _framesContainer.Insert(newVisualIndex, _frameDropPlaceholder);
+                    _frameDropPlaceholder.style.visibility = Visibility.Visible;
+                }
+                else if (_framesContainer.childCount == 0 && _draggedFrameElement != null)
+                {
+                    _framesContainer.Add(_frameDropPlaceholder);
+                    _frameDropPlaceholder.style.visibility = Visibility.Visible;
+                }
+                else
+                {
+                    if (_frameDropPlaceholder.parent == _framesContainer)
+                    {
+                        _framesContainer.Remove(_frameDropPlaceholder);
+                    }
+
+                    _frameDropPlaceholder.style.visibility = Visibility.Hidden;
+                }
+            }
+            else
+            {
+                DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
+            }
+            evt.StopPropagation();
+        }
+
+        private void OnFramesContainerDragPerform(DragPerformEvent evt)
+        {
+            object draggedIndexData = DragAndDrop.GetGenericData("DraggedFrameDataIndex");
+            if (
+                draggedIndexData != null
+                && _draggedFrameElement != null
+                && _activeEditorLayer != null
+            )
+            {
+                int originalDataIndex = (int)draggedIndexData;
+
+                if (originalDataIndex < 0 || originalDataIndex >= _activeEditorLayer.Sprites.Count)
+                {
+                    this.LogError(
+                        $"DragPerform (Frames): Stale or invalid dragged index. Aborting drop."
+                    );
+                    CleanupFrameDragState(InvalidPointerId);
+                    evt.StopPropagation();
+                    return;
+                }
+
+                Sprite movedSprite = _activeEditorLayer.Sprites[originalDataIndex];
+                _activeEditorLayer.Sprites.RemoveAt(originalDataIndex);
+
+                int placeholderVisualIndex = _framesContainer.IndexOf(_frameDropPlaceholder);
+                int targetDataIndex;
+
+                if (0 <= placeholderVisualIndex)
+                {
+                    int itemsBeforePlaceholder = 0;
+                    for (int i = 0; i < placeholderVisualIndex; i++)
+                    {
+                        if (
+                            _framesContainer[i] != _draggedFrameElement
+                            && _framesContainer[i] != _frameDropPlaceholder
+                        )
+                        {
+                            itemsBeforePlaceholder++;
+                        }
+                    }
+                    targetDataIndex = itemsBeforePlaceholder;
+                }
+                else
+                {
+                    targetDataIndex = _activeEditorLayer.Sprites.Count;
+                }
+                targetDataIndex = Mathf.Clamp(targetDataIndex, 0, _activeEditorLayer.Sprites.Count);
+                _activeEditorLayer.Sprites.Insert(targetDataIndex, movedSprite);
+
+                DragAndDrop.AcceptDrag();
+                CleanupFrameDragState(InvalidPointerId);
+
+                RebuildFramesListUI();
+                RecreatePreviewImage();
+            }
+            else
+            {
+                if (DragAndDrop.GetGenericData("DraggedFrameDataIndex") != null)
+                {
+                    CleanupFrameDragState(InvalidPointerId);
+                }
+            }
+            evt.StopPropagation();
+        }
+
+        private void OnFramesContainerDragLeave(DragLeaveEvent evt)
+        {
+            if (evt.target == _framesContainer)
+            {
+                if (_frameDropPlaceholder.parent == _framesContainer)
+                {
+                    _framesContainer.Remove(_frameDropPlaceholder);
+                }
+
+                if (_frameDropPlaceholder != null)
+                {
+                    _frameDropPlaceholder.style.visibility = Visibility.Hidden;
+                }
+            }
+
+            CleanupFrameDragState(InvalidPointerId);
+        }
+
+        private void CleanupFrameDragState(int pointerIdToRelease)
+        {
+            this.Log($"Cleaning up frame drag state with pointer {pointerIdToRelease}");
+            if (_draggedFrameElement != null)
+            {
+                if (
+                    pointerIdToRelease != InvalidPointerId
+                    && _draggedFrameElement.HasPointerCapture(pointerIdToRelease)
+                )
+                {
+                    _draggedFrameElement.ReleasePointer(pointerIdToRelease);
+                }
+
+                _draggedFrameElement.UnregisterCallback<PointerUpEvent>(
+                    OnDraggedFrameItemPointerUp
+                );
+                _draggedFrameElement.RemoveFromClassList("frame-item-dragged");
+                _draggedFrameElement = null;
+            }
+            _draggedFrameOriginalDataIndex = -1;
+
+            if (_frameDropPlaceholder != null)
+            {
+                if (_frameDropPlaceholder.parent == _framesContainer)
+                {
+                    _framesContainer.Remove(_frameDropPlaceholder);
+                }
+
+                _frameDropPlaceholder.style.visibility = Visibility.Hidden;
+            }
+            DragAndDrop.SetGenericData("DraggedFrameDataIndex", null);
+        }
+
+        private void UpdateFpsDebugLabelForActiveLayer()
+        {
+            if (_activeEditorLayer == null)
+            {
+                _fpsDebugLabel.text = "Detected FPS Info: No active clip.";
+                return;
+            }
+
+            _fpsDebugLabel.text =
+                $"Active Clip FPS (Original): {FormatFps(_activeEditorLayer.OriginalClipFps)}fps. Preview uses global FPS.";
+        }
+
+        private static string FormatFps(float fps)
+        {
+            return fps.ToString("F1");
+        }
+
+        private void RebuildFramesListUI()
+        {
+            _framesContainer.Clear();
+
+            if (_frameDropPlaceholder != null && _frameDropPlaceholder.parent == _framesContainer)
+            {
+                _framesContainer.Remove(_frameDropPlaceholder);
+            }
+
+            if (_activeEditorLayer?.Sprites == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < _activeEditorLayer.Sprites.Count; i++)
+            {
+                Sprite sprite = _activeEditorLayer.Sprites[i];
+
+                VisualElement frameElement = new();
+                frameElement.AddToClassList("frame-item");
+
+                Image frameImage = new() { sprite = sprite, scaleMode = ScaleMode.ScaleToFit };
+                frameImage.AddToClassList("frame-image");
+                frameElement.Add(frameImage);
+
+                VisualElement frameInfo = new();
+                frameInfo.AddToClassList("frame-info");
+                frameInfo.Add(new Label($"Frame: {i + 1}"));
+                frameInfo.Add(new Label($"Sprite: {(sprite != null ? sprite.name : "(None)")}"));
+                frameElement.Add(frameInfo);
+
+                IntegerField indexField = new(null) { value = i + 1 };
+                indexField.AddToClassList("frame-index-field");
+                frameElement.Add(indexField);
+
+                VisualElement orderFieldContainer = new()
+                {
+                    style =
+                    {
+                        flexDirection = FlexDirection.Row,
+                        alignItems = Align.Center,
+                        marginLeft = StyleKeyword.Auto,
+                    },
+                };
+
+                Label orderLabel = new("Order:") { style = { marginRight = 3 } };
+                orderFieldContainer.Add(orderLabel);
+                orderFieldContainer.Add(indexField);
+                frameElement.Add(orderFieldContainer);
+
+                int currentDataIndex = i;
+                frameElement.RegisterCallback<PointerDownEvent>(evt =>
+                    OnFrameItemPointerDown(evt, frameElement, currentDataIndex)
+                );
+
+                indexField.userData = currentDataIndex;
+
+                indexField.RegisterCallback<FocusInEvent>(_ =>
+                {
+                    CleanupFrameDragState(InvalidPointerId);
+                    CleanupLoadedClipDragState(InvalidPointerId);
+                });
+
+                indexField.RegisterCallback<FocusOutEvent>(_ =>
+                    OnFrameIndexFieldChanged(indexField)
+                );
+                indexField.RegisterCallback<KeyDownEvent>(evt =>
+                {
+                    if (evt.keyCode is KeyCode.Return or KeyCode.KeypadEnter)
+                    {
+                        OnFrameIndexFieldChanged(indexField);
+                        indexField.Blur();
+                    }
+                });
+
+                _framesContainer.Add(frameElement);
+            }
+        }
+
+        private void OnFrameIndexFieldChanged(IntegerField field)
+        {
+            CleanupFrameDragState(InvalidPointerId);
+            CleanupLoadedClipDragState(InvalidPointerId);
+            if (_activeEditorLayer?.Sprites == null)
+            {
+                return;
+            }
+
+            int originalDataIndex = (int)field.userData;
+            int newUiIndex = field.value;
+            int newRequestedDataIndex = newUiIndex - 1;
+            int newClampedDataIndex = Mathf.Clamp(
+                newRequestedDataIndex,
+                0,
+                _activeEditorLayer.Sprites.Count - 1
+            );
+
+            if (newClampedDataIndex != originalDataIndex)
+            {
+                if (originalDataIndex < 0 || originalDataIndex >= _activeEditorLayer.Sprites.Count)
+                {
+                    this.LogWarn(
+                        $"Original index {originalDataIndex} out of bounds. Rebuilding UI to correct."
+                    );
+                    RebuildFramesListUI();
+                    return;
+                }
+                Sprite spriteToMove = _activeEditorLayer.Sprites[originalDataIndex];
+                _activeEditorLayer.Sprites.RemoveAt(originalDataIndex);
+                _activeEditorLayer.Sprites.Insert(newClampedDataIndex, spriteToMove);
+                RebuildFramesListUI();
+                RecreatePreviewImage();
+            }
+            else if (newUiIndex - 1 != newClampedDataIndex)
+            {
+                RebuildFramesListUI();
+            }
+        }
+
+        private void OnFrameItemPointerDown(
+            PointerDownEvent evt,
+            VisualElement frameElement,
+            int originalDataIndex
+        )
+        {
+            if (evt.button != 0 || _draggedFrameElement != null)
+            {
+                return;
+            }
+
+            if (
+                _activeEditorLayer == null
+                || originalDataIndex < 0
+                || originalDataIndex >= _activeEditorLayer.Sprites.Count
+            )
+            {
+                this.LogError(
+                    $"OnFrameItemPointerDown: Invalid originalDataIndex ({originalDataIndex}) or no active layer. Sprite count: {_activeEditorLayer?.Sprites?.Count ?? -1}"
+                );
+                return;
+            }
+
+            _draggedFrameElement = frameElement;
+            _draggedFrameOriginalDataIndex = originalDataIndex;
+
+            try
+            {
+                _draggedFrameElement.RegisterCallback<PointerUpEvent>(OnDraggedFrameItemPointerUp);
+                _draggedFrameElement.AddToClassList("frame-item-dragged");
+
+                DragAndDrop.PrepareStartDrag();
+                DragAndDrop.SetGenericData("DraggedFrameDataIndex", _draggedFrameOriginalDataIndex);
+
+                Object dragContextObject =
+                    _activeEditorLayer.SourceClip ?? (Object)CreateInstance<ScriptableObject>();
+                if (dragContextObject == null)
+                {
+                    this.LogError($"Failed to create dragContextObject for frame drag.");
+
+                    _draggedFrameElement.ReleasePointer(evt.pointerId);
+                    _draggedFrameElement.UnregisterCallback<PointerUpEvent>(
+                        OnDraggedFrameItemPointerUp
+                    );
+                    _draggedFrameElement.RemoveFromClassList("frame-item-dragged");
+                    _draggedFrameElement = null;
+                    return;
+                }
+                DragAndDrop.objectReferences = new[] { dragContextObject };
+
+                Sprite spriteBeingDragged = _activeEditorLayer.Sprites[originalDataIndex];
+                string dragTitle;
+                if (spriteBeingDragged != null)
+                {
+                    dragTitle = !string.IsNullOrWhiteSpace(spriteBeingDragged.name)
+                        ? spriteBeingDragged.name
+                        : $"Unnamed Sprite Frame {originalDataIndex + 1}";
+                }
+                else
+                {
+                    dragTitle = $"Empty Frame {originalDataIndex + 1}";
+                }
+
+                if (string.IsNullOrWhiteSpace(dragTitle))
+                {
+                    dragTitle = "Dragging Frame";
+                }
+
+                DragAndDrop.StartDrag(dragTitle);
+            }
+            catch (Exception e)
+            {
+                this.LogError(
+                    $"Exception during OnFrameItemPointerDown before StartDrag: {e.Message}\n{e.StackTrace}"
+                );
+
+                if (_draggedFrameElement != null)
+                {
+                    if (_draggedFrameElement.HasPointerCapture(evt.pointerId))
+                    {
+                        _draggedFrameElement.ReleasePointer(evt.pointerId);
+                    }
+
+                    _draggedFrameElement.UnregisterCallback<PointerUpEvent>(
+                        OnDraggedFrameItemPointerUp
+                    );
+                    _draggedFrameElement.RemoveFromClassList("frame-item-dragged");
+                    _draggedFrameElement = null;
+                }
+                _draggedFrameOriginalDataIndex = -1;
+            }
+        }
+
+        private void OnDraggedFrameItemPointerUp(PointerUpEvent evt)
+        {
+            if (_draggedFrameElement == null || evt.currentTarget != _draggedFrameElement)
+            {
+                return;
+            }
+
+            if (DragAndDrop.GetGenericData("DraggedFrameDataIndex") != null)
+            {
+                CleanupFrameDragState(evt.pointerId);
+            }
+            else if (
+                _draggedFrameElement != null
+                && _draggedFrameElement.HasPointerCapture(evt.pointerId)
+            )
+            {
+                _draggedFrameElement.ReleasePointer(evt.pointerId);
+                _draggedFrameElement.UnregisterCallback<PointerUpEvent>(
+                    OnDraggedFrameItemPointerUp
+                );
+                _draggedFrameElement.RemoveFromClassList("frame-item-dragged");
+                _draggedFrameElement = null;
+            }
+            evt.StopPropagation();
+        }
+
+        private void OnApplyFpsToPreviewClicked()
+        {
+            _currentPreviewFps = Mathf.Max(0.1f, _fpsField.value);
+            _fpsField.SetValueWithoutNotify(_currentPreviewFps);
+            if (_animationPreview != null)
+            {
+                _animationPreview.Fps = _currentPreviewFps;
+            }
+        }
+
+        private void OnSaveClipClicked()
+        {
+            if (_activeEditorLayer == null || _activeEditorLayer.SourceClip == null)
+            {
+                this.LogError($"No active animation clip to save.");
+                return;
+            }
+
+            AnimationClip clipToSave = _activeEditorLayer.SourceClip;
+            string bindingPath = _activeEditorLayer.BindingPath;
+
+            EditorCurveBinding spriteBinding = default;
+            bool bindingFound = false;
+            EditorCurveBinding[] allBindings = AnimationUtility.GetObjectReferenceCurveBindings(
+                clipToSave
+            );
+
+            foreach (EditorCurveBinding b in allBindings)
+            {
+                if (
+                    b.type == typeof(SpriteRenderer)
+                    && b.propertyName == "m_Sprite"
+                    && (string.IsNullOrWhiteSpace(bindingPath) || b.path == bindingPath)
+                )
+                {
+                    spriteBinding = b;
+                    bindingFound = true;
+                    break;
+                }
+            }
+
+            if (!bindingFound)
+            {
+                foreach (EditorCurveBinding b in allBindings)
+                {
+                    if (b.type == typeof(SpriteRenderer) && b.propertyName == "m_Sprite")
+                    {
+                        spriteBinding = b;
+                        bindingFound = true;
+                        this.LogWarn(
+                            $"Saving to first available m_Sprite binding on '{clipToSave.name}' as specific path '{bindingPath}' was not found or empty."
+                        );
+                        break;
+                    }
+                }
+            }
+
+            if (!bindingFound)
+            {
+                this.LogError(
+                    $"Cannot save '{clipToSave.name}': No SpriteRenderer m_Sprite binding found (Path Hint: '{bindingPath}'). Clip might be empty or not a sprite animation."
+                );
+                return;
+            }
+
+            List<Sprite> spritesToSave = _activeEditorLayer.Sprites;
+            ObjectReferenceKeyframe[] newKeyframes = new ObjectReferenceKeyframe[
+                spritesToSave.Count
+            ];
+            float timePerFrame = _currentPreviewFps > 0 ? 1.0f / _currentPreviewFps : 0f;
+
+            for (int i = 0; i < spritesToSave.Count; i++)
+            {
+                newKeyframes[i] = new ObjectReferenceKeyframe
+                {
+                    time = i * timePerFrame,
+                    value = spritesToSave[i],
+                };
+            }
+
+            Undo.RecordObject(clipToSave, "Modify Animation Clip Frames");
+            AnimationUtility.SetObjectReferenceCurve(clipToSave, spriteBinding, newKeyframes);
+            clipToSave.frameRate = _currentPreviewFps;
+
+            EditorUtility.SetDirty(clipToSave);
+            AssetDatabase.SaveAssets();
+
+            this.Log(
+                $"Animation clip '{clipToSave.name}' saved with {spritesToSave.Count} frames at {_currentPreviewFps} FPS."
+            );
+        }
+
+        private void OnDisable()
+        {
+            CleanupFrameDragState(InvalidPointerId);
+            CleanupLoadedClipDragState(InvalidPointerId);
+
+            if (_animationPreview != null && _animationPreview.parent == _previewPanelHost)
+            {
+                _previewPanelHost.Remove(_animationPreview);
+            }
+            _animationPreview = null;
+        }
+    }
+#endif
+}