Change ObjectInspector to work via object selection

PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchObjectInspectorRuleset.cs

@@ -0,0 +1,115 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Input.Events;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Catch.Edit;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.UI;
+using osuTK.Input;
+
+namespace PerformanceCalculatorGUI.Screens.ObjectInspection.Catch
+{
+    public partial class CatchObjectInspectorRuleset : DrawableCatchEditorRuleset
+    {
+        private readonly CatchDifficultyHitObject[] difficultyHitObjects;
+        private CatchObjectInspectorPlayfield inspectorPlayfield;
+
+        [Resolved]
+        private ObjectDifficultyValuesContainer difficultyValuesContainer { get; set; }
+
+        public CatchObjectInspectorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods, ExtendedCatchDifficultyCalculator difficultyCalculator, double clockRate)
+            : base(ruleset, beatmap, mods)
+        {
+            difficultyHitObjects = difficultyCalculator.GetDifficultyHitObjects(beatmap, clockRate)
+                                                       .Cast<CatchDifficultyHitObject>().ToArray();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            inspectorPlayfield.SelectedObject.BindValueChanged(value =>
+            {
+                difficultyValuesContainer.CurrentDifficultyHitObject.Value = difficultyHitObjects.FirstOrDefault(x => x.BaseObject.StartTime == value.NewValue?.HitObject.StartTime);
+            });
+        }
+
+        public override bool PropagatePositionalInputSubTree => true;
+
+        public override bool PropagateNonPositionalInputSubTree => false;
+
+        public override bool AllowBackwardsSeeks => true;
+
+        protected override Playfield CreatePlayfield() => inspectorPlayfield = new CatchObjectInspectorPlayfield(Beatmap.Difficulty);
+
+        private partial class CatchObjectInspectorPlayfield : CatchEditorPlayfield
+        {
+            public readonly Bindable<CatchSelectableHitObject?> SelectedObject = new Bindable<CatchSelectableHitObject?>();
+
+            public CatchObjectInspectorPlayfield(IBeatmapDifficultyInfo difficulty)
+                : base(difficulty)
+            {
+                DisplayJudgements.Value = false;
+            }
+
+            protected override void OnHitObjectAdded(HitObject hitObject)
+            {
+                base.OnHitObjectAdded(hitObject);
+
+                // Potential room for pooling here?
+                switch (hitObject)
+                {
+                    case Fruit fruit:
+                    {
+                        HitObjectContainer.Add(new CatchSelectableHitObject(fruit)
+                        {
+                            PlayfieldSelectedObject = { BindTarget = SelectedObject }
+                        });
+
+                        break;
+                    }
+
+                    case JuiceStream juiceStream:
+                    {
+                        foreach (var nested in juiceStream.NestedHitObjects)
+                        {
+                            if (nested is TinyDroplet)
+                                continue;
+
+                            HitObjectContainer.Add(new CatchSelectableHitObject((CatchHitObject)nested)
+                            {
+                                PlayfieldSelectedObject = { BindTarget = SelectedObject }
+                            });
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            protected override GameplayCursorContainer CreateCursor() => null!;
+
+            protected override bool OnClick(ClickEvent e)
+            {
+                if (e.Button == MouseButton.Left)
+                {
+                    SelectedObject.Value?.Deselect();
+                    SelectedObject.Value = null;
+                }
+
+                return false;
+            }
+        }
+    }
+}

PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchSelectableHitObject.cs

@@ -0,0 +1,87 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using osu.Framework.Allocation;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.Objects;
+using osuTK;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
+using osu.Framework.Input.Events;
+using osuTK.Input;
+using osu.Framework.Bindables;
+
+namespace PerformanceCalculatorGUI.Screens.ObjectInspection.Catch
+{
+    public partial class CatchSelectableHitObject : DrawableCatchHitObject
+    {
+        // This is HitCirclePiece instead of FruitOutline because FruitOutline doesn't register input for some reason
+        private HitCirclePiece outline = null!;
+        private SelectionState state;
+
+        public readonly Bindable<CatchSelectableHitObject?> PlayfieldSelectedObject = new Bindable<CatchSelectableHitObject?>();
+
+        public CatchSelectableHitObject(CatchHitObject hitObject)
+            : base(hitObject)
+        {
+            X = hitObject.EffectiveX;
+            state = SelectionState.NotSelected;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddInternal(outline = new HitCirclePiece
+            {
+                Alpha = 0,
+                Scale = HitObject is Droplet ? new Vector2(HitObject.Scale) * 0.5f : new Vector2(HitObject.Scale)
+            });
+
+            PlayfieldSelectedObject.BindValueChanged(x =>
+            {
+                if (x.NewValue != this)
+                {
+                    Deselect();
+                }
+            });
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            if (e.Button != MouseButton.Left)
+                return false;
+
+            if (!IsHovered)
+                return false;
+
+            if (state == SelectionState.Selected)
+            {
+                Deselect();
+                PlayfieldSelectedObject.Value = null;
+
+                return true;
+            }
+
+            state = SelectionState.Selected;
+            outline.Show();
+            PlayfieldSelectedObject.Value = this;
+
+            return true;
+        }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => outline.ReceivePositionalInputAt(screenSpacePos);
+
+        public override bool HandlePositionalInput => ShouldBeAlive || IsPresent;
+
+        public void Deselect()
+        {
+            if (IsLoaded)
+            {
+                state = SelectionState.NotSelected;
+                outline.Hide();
+            }
+        }
+    }
+}

PerformanceCalculatorGUI/Screens/ObjectInspection/ObjectDifficultyValuesContainer.cs

@@ -94,6 +94,7 @@ private void updateValues(DifficultyHitObject hitObject)
             }
 
             hitObjectTypeText.Text = hitObject.BaseObject.GetType().Name;
+            flowContainer.Add(new ObjectInspectorDifficultyValue("Start Time", hitObject.StartTime));
 
             switch (hitObject)
             {

PerformanceCalculatorGUI/Screens/ObjectInspection/ObjectInspector.cs

@@ -24,6 +24,9 @@
 using osu.Game.Screens.Edit.Components;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osuTK.Input;
+using PerformanceCalculatorGUI.Screens.ObjectInspection.Catch;
+using PerformanceCalculatorGUI.Screens.ObjectInspection.Osu;
+using PerformanceCalculatorGUI.Screens.ObjectInspection.Taiko;
 
 namespace PerformanceCalculatorGUI.Screens.ObjectInspection
 {

PerformanceCalculatorGUI/Screens/ObjectInspection/OsuObjectInspectorRuleset.cs → PerformanceCalculatorGUI/Screens/ObjectInspection/Osu/OsuObjectInspectorRuleset.cs

@@ -12,33 +12,35 @@
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 
-namespace PerformanceCalculatorGUI.Screens.ObjectInspection
+namespace PerformanceCalculatorGUI.Screens.ObjectInspection.Osu
 {
     public partial class OsuObjectInspectorRuleset : DrawableOsuEditorRuleset
     {
         private readonly OsuDifficultyHitObject[] difficultyHitObjects;
 
         [Resolved]
-        private ObjectDifficultyValuesContainer objectDifficultyValuesContainer { get; set; }
+        private ObjectDifficultyValuesContainer difficultyValuesContainer { get; set; }
 
         public OsuObjectInspectorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods, ExtendedOsuDifficultyCalculator difficultyCalculator, double clockRate)
             : base(ruleset, beatmap, mods)
         {
             difficultyHitObjects = difficultyCalculator.GetDifficultyHitObjects(beatmap, clockRate).Cast<OsuDifficultyHitObject>().ToArray();
         }
 
-        protected override void Update()
+        protected override void LoadComplete()
         {
-            base.Update();
-            objectDifficultyValuesContainer.CurrentDifficultyHitObject.Value = difficultyHitObjects.LastOrDefault(x => x.StartTime <= Clock.CurrentTime);
+            base.LoadComplete();
+            KeyBindingInputManager.AllowGameplayInputs = false;
+            ((OsuObjectInspectorPlayfield)Playfield).Pool.SelectedObject.BindValueChanged(value =>
+                difficultyValuesContainer.CurrentDifficultyHitObject.Value = difficultyHitObjects.FirstOrDefault(x => x.BaseObject == value.NewValue));
         }
 
-        public override bool PropagatePositionalInputSubTree => false;
-
+        public override bool PropagatePositionalInputSubTree => true;
         public override bool PropagateNonPositionalInputSubTree => false;
 
         public override bool AllowBackwardsSeeks => true;
@@ -48,15 +50,42 @@ protected override void Update()
         private partial class OsuObjectInspectorPlayfield : OsuPlayfield
         {
             private readonly IReadOnlyList<OsuDifficultyHitObject> difficultyHitObjects;
-            protected override GameplayCursorContainer CreateCursor() => null;
+
+            public OsuSelectableObjectPool Pool { get; private set; }
 
             public OsuObjectInspectorPlayfield(IReadOnlyList<OsuDifficultyHitObject> difficultyHitObjects)
             {
                 this.difficultyHitObjects = difficultyHitObjects;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AddInternal(Pool = new OsuSelectableObjectPool { RelativeSizeAxes = Axes.Both });
                 HitPolicy = new AnyOrderHitPolicy();
                 DisplayJudgements.Value = false;
             }
 
+            protected override GameplayCursorContainer CreateCursor() => null;
+
+            protected override void OnHitObjectAdded(HitObject hitObject)
+            {
+                base.OnHitObjectAdded(hitObject);
+
+                if (hitObject is Spinner) return;
+
+                Pool.AddSelectableObject((OsuHitObject)hitObject);
+            }
+
+            protected override void OnHitObjectRemoved(HitObject hitObject)
+            {
+                base.OnHitObjectRemoved(hitObject);
+
+                if (hitObject is Spinner) return;
+
+                Pool.RemoveSelectableObject((OsuHitObject)hitObject);
+            }
+
             protected override void OnNewDrawableHitObject(DrawableHitObject d)
             {
                 base.OnNewDrawableHitObject(d);