v2.2.0 (#17)

Author: hkmt-mmy

Packages/AudioConductor/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v2.2.0 - 2026/05/19
+
+- New Features
+  - Open AudioClip property inspector from TrackInspector
+
+- Fix Issues
+  - Fix CueSheet assets not found when asset cache was initialized as empty
+
 ## v2.1.1 - 2026/05/14
 
 - Fix Issues

Packages/AudioConductor/Editor/Core/Tools/CueSheetEditor/Presenters/TrackInspectorPresenter.cs

@@ -9,6 +9,7 @@
 using AudioConductor.Editor.Core.Tools.CueSheetEditor.Models.Interfaces;
 using AudioConductor.Editor.Core.Tools.CueSheetEditor.Views;
 using AudioConductor.Editor.Foundation.TinyRx;
+using UnityEditor;
 using UnityEngine.Assertions;
 
 namespace AudioConductor.Editor.Core.Tools.CueSheetEditor.Presenters
@@ -74,6 +75,9 @@ private void Bind()
             model.AudioClipObservable
                 .Subscribe(_view.SetSampleRange)
                 .DisposeWith(_bindDisposable);
+            model.AudioClipObservable
+                .Subscribe(value => _view.SetOpenAudioClipInspectorButtonEnabled(value.Value != null))
+                .DisposeWith(_bindDisposable);
             model.VolumeObservable
                 .Subscribe(_view.SetVolume)
                 .DisposeWith(_bindDisposable);
@@ -168,6 +172,14 @@ private void SetupViewEventHandlers()
             _view.AnalyzeClickedAsObservable
                 .Subscribe(_ => model.AnalyzeWaveChunk())
                 .DisposeWith(_viewEventDisposable);
+            _view.OpenAudioClipInspectorClickedAsObservable
+                .Subscribe(_ =>
+                {
+                    var clip = model.AudioClip;
+                    if (clip is not null)
+                        EditorUtility.OpenPropertyEditor(clip);
+                })
+                .DisposeWith(_viewEventDisposable);
             _view.PlayRequestedAsObservable
                 .Subscribe(sample => { _view.SetController(model.PlayClip(sample)); })
                 .DisposeWith(_viewEventDisposable);

Packages/AudioConductor/Editor/Core/Tools/CueSheetEditor/Views/TrackInspectorView.cs

@@ -36,6 +36,8 @@ internal sealed partial class TrackInspectorView : VisualElement, IDisposable
 
         private readonly Subject<string> _nameChangedSubject = new();
         private readonly TextField _nameField;
+        private readonly Button _openAudioClipInspectorButton;
+        private readonly Subject<Empty> _openAudioClipInspectorClickedSubject = new();
         private readonly Button _pauseButton;
         private readonly Subject<float> _pitchChangedSubject = new();
         private readonly SliderAndFloatField _pitchField;
@@ -81,6 +83,9 @@ public TrackInspectorView()
             _isLoopField = this.Q<Toggle>("Loop");
             _loopStartSampleField = this.Q<SliderAndIntegerField>("LoopStartSample");
             _analyzeButton = this.Q<Button>("Analyze");
+            _openAudioClipInspectorButton = this.Q<Button>("OpenAudioClipInspector");
+            _openAudioClipInspectorButton.style.backgroundImage =
+                new StyleBackground((Texture2D)EditorGUIUtility.IconContent("d_UnityEditor.InspectorWindow").image);
             _playButton = this.Q<Button>("Play");
             _pauseButton = this.Q<Button>("Pause");
             _pauseButton.style.backgroundImage =
@@ -118,6 +123,7 @@ public TrackInspectorView()
         internal IObservable<bool> IsLoopChangedAsObservable => _isLoopChangedSubject;
         internal IObservable<int> LoopStartSampleChangedAsObservable => _loopStartSampleChangedSubject;
         internal IObservable<Empty> AnalyzeClickedAsObservable => _analyzeClickedSubject;
+        internal IObservable<Empty> OpenAudioClipInspectorClickedAsObservable => _openAudioClipInspectorClickedSubject;
         internal IObservable<int?> PlayRequestedAsObservable => _playRequestedSubject;
 
         public void Dispose()
@@ -193,6 +199,7 @@ private void SetupEventHandlers()
             _isLoopField.RegisterValueChangedCallback(OnIsLoopChanged);
             _loopStartSampleField.RegisterValueChangedCallback(OnLoopStartSampleChanged);
             _analyzeButton.RegisterCallback<ClickEvent>(OnAnalyzeButtonClicked);
+            _openAudioClipInspectorButton.RegisterCallback<ClickEvent>(OnOpenAudioClipInspectorButtonClicked);
             _playButton.RegisterCallback<ClickEvent>(OnPlayButtonClicked);
             _pauseButton.RegisterCallback<ClickEvent>(OnPauseButtonClicked);
             _stopButton.RegisterCallback<ClickEvent>(OnStopButtonClicked);
@@ -203,6 +210,7 @@ private void CleanupEventHandlers()
             _stopButton.UnregisterCallback<ClickEvent>(OnStopButtonClicked);
             _pauseButton.UnregisterCallback<ClickEvent>(OnPauseButtonClicked);
             _playButton.UnregisterCallback<ClickEvent>(OnPlayButtonClicked);
+            _openAudioClipInspectorButton.UnregisterCallback<ClickEvent>(OnOpenAudioClipInspectorButtonClicked);
             _analyzeButton.UnregisterCallback<ClickEvent>(OnAnalyzeButtonClicked);
             _loopStartSampleField.UnregisterValueChangedCallback(OnLoopStartSampleChanged);
             _isLoopField.UnregisterValueChangedCallback(OnIsLoopChanged);
@@ -347,6 +355,11 @@ internal void SetLoopStartSample(MixedValue<int> value)
             _loopStartSampleField.showMixedValue = value.HasMultipleDifferentValues;
         }
 
+        internal void SetOpenAudioClipInspectorButtonEnabled(bool enabled)
+        {
+            _openAudioClipInspectorButton.SetEnabled(enabled);
+        }
+
         internal void SetSampleRange(MixedValue<AudioClip?> value)
         {
             var audioClip = value.Value;
@@ -453,6 +466,11 @@ private void OnAnalyzeButtonClicked(ClickEvent _)
             _analyzeClickedSubject.OnNext(Empty.Default);
         }
 
+        private void OnOpenAudioClipInspectorButtonClicked(ClickEvent _)
+        {
+            _openAudioClipInspectorClickedSubject.OnNext(Empty.Default);
+        }
+
         private void OnPlayButtonClicked(ClickEvent _)
         {
             _playRequestedSubject.OnNext(null);

Packages/AudioConductor/Editor/Core/Tools/Shared/CueSheetAssetRepository.cs

@@ -21,7 +21,7 @@ internal sealed class CueSheetAssetRepository : ScriptableSingleton<CueSheetAsse
         /// </summary>
         public CueSheetAsset[] GetAll()
         {
-            if (_all is null)
+            if (_all is null || _all.Length == 0)
                 _all = LoadAll();
             return _all;
         }

Packages/AudioConductor/Editor/PackageResources/Uxml/TrackInspector.uxml

@@ -1,7 +1,10 @@
 <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
     <ui:TextField picking-mode="Ignore" label="Track Name" value="filler text" name="Name" is-delayed="true" />
     <AudioConductor.Editor.Core.Tools.Shared.ColorDefinePopupField label="Color" />
-    <uie:ObjectField label="Audio Clip" allow-scene-objects="false" type="UnityEngine.AudioClip, UnityEngine.AudioModule" name="AudioClip" />
+    <ui:VisualElement style="flex-direction: row; align-items: flex-end;">
+        <uie:ObjectField label="Audio Clip" allow-scene-objects="false" type="UnityEngine.AudioClip, UnityEngine.AudioModule" name="AudioClip" style="flex: 1;" />
+        <ui:Button name="OpenAudioClipInspector" style="width: 18px; height: 18px; padding: 0; margin-left: 2px; margin-bottom: 1px;" />
+    </ui:VisualElement>
     <AudioConductor.Editor.Core.Tools.Shared.SliderAndFloatField label="Volume" value="1" high-value="1" name="Volume" />
     <AudioConductor.Editor.Core.Tools.Shared.SliderAndFloatField label="Volume Range" high-value="1" name="VolumeRange" />
     <AudioConductor.Editor.Core.Tools.Shared.SliderAndFloatField label="Pitch" high-value="3" value="1" low-value="0.01" name="Pitch" />

Packages/AudioConductor/Runtime/Core/Conductor.Playback.cs

@@ -347,65 +347,40 @@ private bool CanPlay(uint cueSheetId, Cue cue, Track track)
                 return true;
 
             // Single pass: count playing states and track oldest per scope at once.
-            int cueCount = 0, sheetCount = 0, catCount = 0, globalCount = 0;
-            int cueMin = int.MaxValue, sheetMin = int.MaxValue, catMin = int.MaxValue, globalMin = int.MaxValue;
-            Playback? cueOldest = null, sheetOldest = null, catOldest = null, globalOldest = null;
+            var ctx = new ThrottleContext(cueSheetId, cue);
 
             foreach (var p in _managedPlaybacks.Values)
-                ThrottleResolver.AccumulateAllScopes(p.Core, cueSheetId, cue, cue.categoryId,
-                    ref cueCount, ref cueMin, ref cueOldest,
-                    ref sheetCount, ref sheetMin, ref sheetOldest,
-                    ref catCount, ref catMin, ref catOldest,
-                    ref globalCount, ref globalMin, ref globalOldest);
+                ctx.Accumulate(p.Core);
 
             foreach (var s in _oneShotPlaybacks)
-                ThrottleResolver.AccumulateAllScopes(s.Core, cueSheetId, cue, cue.categoryId,
-                    ref cueCount, ref cueMin, ref cueOldest,
-                    ref sheetCount, ref sheetMin, ref sheetOldest,
-                    ref catCount, ref catMin, ref catOldest,
-                    ref globalCount, ref globalMin, ref globalOldest);
+                ctx.Accumulate(s.Core);
 
 #if UNITY_EDITOR
             // Invariant: counts must not exceed their respective limits.
             // Violated only if throttle limits are mutated while players are active (unsupported).
-            Debug.Assert(cueThrottleLimit <= 0 || cueCount <= cueThrottleLimit,
+            Debug.Assert(cueThrottleLimit <= 0 || ctx.CueCount <= cueThrottleLimit,
                 "cue count exceeds throttle limit");
-            Debug.Assert(sheetThrottleLimit <= 0 || sheetCount <= sheetThrottleLimit,
+            Debug.Assert(sheetThrottleLimit <= 0 || ctx.SheetCount <= sheetThrottleLimit,
                 "sheet count exceeds throttle limit");
-            Debug.Assert(catThrottleLimit <= 0 || catCount <= catThrottleLimit,
+            Debug.Assert(catThrottleLimit <= 0 || ctx.CategoryCount <= catThrottleLimit,
                 "category count exceeds throttle limit");
-            Debug.Assert(globalThrottleLimit <= 0 || globalCount <= globalThrottleLimit,
+            Debug.Assert(globalThrottleLimit <= 0 || ctx.GlobalCount <= globalThrottleLimit,
                 "global count exceeds throttle limit");
 #endif
 
             // Phase 1: Resolve eviction candidates per scope without executing.
-            // AdjustCountsAfterEviction updates local counts so subsequent scopes
-            // see the effect of prior evictions. Actual stop is deferred to Phase 2
-            // to ensure no side effects when a later scope rejects the play.
-            if (!ThrottleResolver.ResolveThrottle(cueThrottleType, cueThrottleLimit,
-                    cueCount, cueMin, track.priority, cueOldest,
-                    out var cueEviction))
+            // Resolve* updates counts so subsequent scopes see the effect of prior evictions.
+            // Actual stop is deferred to Phase 2 to ensure no side effects when a later scope rejects.
+            if (!ctx.ResolveCue(cueThrottleType, cueThrottleLimit, track.priority, out var cueEviction))
                 return false;
-            ThrottleResolver.AdjustCountsAfterEviction(cueEviction, cueSheetId, cue, cue.categoryId,
-                ref cueCount, ref sheetCount, ref catCount, ref globalCount);
 
-            if (!ThrottleResolver.ResolveThrottle(sheetThrottleType, sheetThrottleLimit,
-                    sheetCount, sheetMin, track.priority, sheetOldest,
-                    out var sheetEviction))
+            if (!ctx.ResolveSheet(sheetThrottleType, sheetThrottleLimit, track.priority, out var sheetEviction))
                 return false;
-            ThrottleResolver.AdjustCountsAfterEviction(sheetEviction, cueSheetId, cue, cue.categoryId,
-                ref cueCount, ref sheetCount, ref catCount, ref globalCount);
 
-            if (!ThrottleResolver.ResolveThrottle(catThrottleType, catThrottleLimit,
-                    catCount, catMin, track.priority, catOldest,
-                    out var catEviction))
+            if (!ctx.ResolveCategory(catThrottleType, catThrottleLimit, track.priority, out var catEviction))
                 return false;
-            ThrottleResolver.AdjustCountsAfterEviction(catEviction, cueSheetId, cue, cue.categoryId,
-                ref cueCount, ref sheetCount, ref catCount, ref globalCount);
 
-            if (!ThrottleResolver.ResolveThrottle(globalThrottleType, globalThrottleLimit,
-                    globalCount, globalMin, track.priority, globalOldest,
-                    out var globalEviction))
+            if (!ctx.ResolveGlobal(globalThrottleType, globalThrottleLimit, track.priority, out var globalEviction))
                 return false;
 
             // Phase 2: All scopes passed — execute deferred evictions.

Packages/AudioConductor/Runtime/Core/ThrottleContext.cs

@@ -0,0 +1,108 @@
+// --------------------------------------------------------------
+// Copyright 2026 CyberAgent, Inc.
+// --------------------------------------------------------------
+
+#nullable enable
+
+using AudioConductor.Core.Enums;
+using AudioConductor.Core.Models;
+using static AudioConductor.Core.Conductor;
+
+namespace AudioConductor.Core
+{
+    internal ref struct ThrottleContext
+    {
+        private readonly uint _targetCueSheetId;
+        private readonly Cue _targetCue;
+        private readonly int _targetCategoryId;
+
+        private ThrottleScopeState _cue;
+        private ThrottleScopeState _sheet;
+        private ThrottleScopeState _category;
+        private ThrottleScopeState _global;
+
+        internal int CueCount => _cue.Count;
+        internal int SheetCount => _sheet.Count;
+        internal int CategoryCount => _category.Count;
+        internal int GlobalCount => _global.Count;
+
+        internal ThrottleContext(uint cueSheetId, Cue cue)
+        {
+            _targetCueSheetId = cueSheetId;
+            _targetCue = cue;
+            _targetCategoryId = cue.categoryId;
+            _cue = default;
+            _sheet = default;
+            _category = default;
+            _global = default;
+        }
+
+        internal void Accumulate(in Playback p)
+        {
+            if (p.Player.State == PlayerState.Stopped)
+                return;
+            _global.Accumulate(in p);
+            if (BelongsToSheet(in p)) _sheet.Accumulate(in p);
+            if (BelongsToCue(in p)) _cue.Accumulate(in p);
+            if (BelongsToCategory(in p)) _category.Accumulate(in p);
+        }
+
+        internal void AdjustAfterEviction(Playback? eviction)
+        {
+            if (!eviction.HasValue)
+                return;
+            var e = eviction.Value;
+            _global.Decrement();
+            if (BelongsToSheet(in e)) _sheet.Decrement();
+            if (BelongsToCue(in e)) _cue.Decrement();
+            if (BelongsToCategory(in e)) _category.Decrement();
+        }
+
+        internal bool ResolveCue(ThrottleType type, int limit, int incomingPriority, out Playback? eviction)
+        {
+            if (!_cue.Resolve(type, limit, incomingPriority, out eviction))
+                return false;
+            AdjustAfterEviction(eviction);
+            return true;
+        }
+
+        internal bool ResolveSheet(ThrottleType type, int limit, int incomingPriority, out Playback? eviction)
+        {
+            if (!_sheet.Resolve(type, limit, incomingPriority, out eviction))
+                return false;
+            AdjustAfterEviction(eviction);
+            return true;
+        }
+
+        internal bool ResolveCategory(ThrottleType type, int limit, int incomingPriority, out Playback? eviction)
+        {
+            if (!_category.Resolve(type, limit, incomingPriority, out eviction))
+                return false;
+            AdjustAfterEviction(eviction);
+            return true;
+        }
+
+        internal bool ResolveGlobal(ThrottleType type, int limit, int incomingPriority, out Playback? eviction)
+        {
+            if (!_global.Resolve(type, limit, incomingPriority, out eviction))
+                return false;
+            AdjustAfterEviction(eviction);
+            return true;
+        }
+
+        private readonly bool BelongsToSheet(in Playback p)
+        {
+            return p.CueSheetId == _targetCueSheetId;
+        }
+
+        private readonly bool BelongsToCue(in Playback p)
+        {
+            return p.Cue == _targetCue;
+        }
+
+        private readonly bool BelongsToCategory(in Playback p)
+        {
+            return p.Cue.categoryId == _targetCategoryId;
+        }
+    }
+}