Change ObjectInspector to work via object selection

PerformanceCalculatorGUI/Components/ExtendedUserModSelectOverlay.cs

@@ -9,8 +9,6 @@ namespace PerformanceCalculatorGUI.Components
 {
     public partial class ExtendedUserModSelectOverlay : UserModSelectOverlay
     {
-        protected override bool ShowModEffects => false;
-
         public ExtendedUserModSelectOverlay()
             : base(OverlayColourScheme.Blue)
         {

PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchObjectInspectorRuleset.cs

@@ -0,0 +1,163 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Beatmaps;
+using osu.Game.Input.Bindings;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+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;
+
+        [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();
+            ((CatchObjectInspectorPlayfield)Playfield).SelectedObject.BindValueChanged(
+                value => difficultyValuesContainer.CurrentDifficultyHitObject.Value = difficultyHitObjects.FirstOrDefault(x => x.BaseObject.StartTime == value.NewValue?.StartTime));
+        }
+
+        public override bool PropagatePositionalInputSubTree => true;
+
+        public override bool PropagateNonPositionalInputSubTree => false;
+
+        public override bool AllowBackwardsSeeks => true;
+
+        protected override PassThroughInputManager CreateInputManager() => new CatchObjectInspectorInputManager(Ruleset.RulesetInfo);
+
+        protected override Playfield CreatePlayfield() => new CatchObjectInspectorPlayfield(Beatmap.Difficulty);
+
+        private partial class CatchObjectInspectorInputManager : CatchInputManager
+        {
+            public CatchObjectInspectorInputManager(RulesetInfo ruleset) : base(ruleset)
+            {
+            }
+
+            protected override KeyBindingContainer<CatchAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            => new EmptyKeyBindingContainer(ruleset, variant, unique);
+
+            private partial class EmptyKeyBindingContainer : RulesetKeyBindingContainer
+            {
+                public EmptyKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique) : base(ruleset, variant, unique)
+                {
+                }
+
+                protected override void ReloadMappings(IQueryable<RealmKeyBinding> realmKeyBindings)
+                {
+                    base.ReloadMappings(realmKeyBindings);
+                    KeyBindings = Enumerable.Empty<IKeyBinding>();
+                }
+            }
+        }
+
+        private partial class CatchObjectInspectorPlayfield : CatchEditorPlayfield
+        {
+            public readonly Bindable<CatchHitObject> SelectedObject = new();
+
+            private List<CatchSelectableHitObject> selectables = new();
+            public CatchObjectInspectorPlayfield(IBeatmapDifficultyInfo difficulty)
+                : base(difficulty)
+            {
+                DisplayJudgements.Value = false;
+            }
+
+            private DrawablePool<CatchSelectableHitObject> selectablesPool;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AddInternal(selectablesPool = new DrawablePool<CatchSelectableHitObject>(1, 200));
+            }
+
+            protected override void OnHitObjectAdded(HitObject hitObject)
+            {
+                base.OnHitObjectAdded(hitObject);
+
+                // Potential room for pooling here
+                switch (hitObject)
+                {
+                    case Fruit fruit:
+                    {
+                        var newSelectable = selectablesPool.Get(a => a.UpdateFromHitObject((CatchHitObject)hitObject));
+                        HitObjectContainer.Add(newSelectable);
+                        selectables.Add(newSelectable);
+                        break;
+                    }
+                    case JuiceStream juiceStream:
+                    {
+                        foreach (var nested in juiceStream.NestedHitObjects)
+                        {
+                            if (nested is TinyDroplet)
+                                continue;
+
+                            var newSelectable = selectablesPool.Get(a => a.UpdateFromHitObject((CatchHitObject)nested));
+                            HitObjectContainer.Add(newSelectable);
+                            selectables.Add(newSelectable);
+                        }
+                        break;
+                    }
+                }
+            }
+
+            protected override GameplayCursorContainer CreateCursor() => null;
+            public override bool HandlePositionalInput => true;
+
+            protected override bool OnClick(ClickEvent e)
+            {
+                if (e.Button == MouseButton.Right)
+                    return false;
+
+                CatchSelectableHitObject newSelectedObject = null;
+
+                // This search can be long if list of objects is very big. Potential for optimization
+                foreach (var selectable in selectables)
+                {
+                    if (selectable.IsSelected)
+                    {
+                        selectable.Deselect();
+                        continue;
+                    }
+
+                    if (!selectable.IsHovered)
+                        continue;
+
+                    if (newSelectedObject != null)
+                        continue;
+
+                    selectable.Select();
+                    newSelectedObject = selectable;
+                }
+
+                SelectedObject.Value = newSelectedObject?.HitObject;
+                return true;
+            }
+        }
+    }
+}

PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchSelectableHitObject.cs

@@ -0,0 +1,105 @@
+#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;
+
+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;
+        public CatchSelectableHitObject()
+            : base(new CatchDummyHitObject())
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddInternal(outline = new HitCirclePiece());
+            UpdateState();
+        }
+
+        public void UpdateFromHitObject(CatchHitObject hitObject)
+        {
+            Deselect();
+            HitObject.StartTime = hitObject.StartTime;
+            X = hitObject.EffectiveX;
+            outline.Scale = new Vector2(hitObject.Scale);
+
+            if (hitObject is Droplet)
+                outline.Scale *= 0.5f;
+        }
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+            UpdateState();
+        }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => outline.ReceivePositionalInputAt(screenSpacePos);
+
+        private class CatchDummyHitObject : CatchHitObject
+        {
+            public CatchDummyHitObject()
+            {
+            }
+        }
+
+        #region Selection Logic
+        public override bool HandlePositionalInput => ShouldBeAlive || IsPresent;
+
+        private SelectionState state;
+
+        public SelectionState State
+        {
+            get => state;
+            set
+            {
+                if (state == value)
+                    return;
+
+                state = value;
+
+                if (IsLoaded)
+                    UpdateState();
+            }
+        }
+
+        public void UpdateState()
+        {
+            switch (state)
+            {
+                case SelectionState.Selected:
+                    OnSelected();
+                    break;
+
+                case SelectionState.NotSelected:
+                    OnDeselected();
+                    break;
+            }
+        }
+
+        protected void OnDeselected()
+        {
+            foreach (var d in InternalChildren)
+                d.Hide();
+        }
+
+        protected void OnSelected()
+        {
+            foreach (var d in InternalChildren)
+                d.Show();
+        }
+        public void Select() => State = SelectionState.Selected;
+        public void Deselect() => State = SelectionState.NotSelected;
+        public bool IsSelected => State == SelectionState.Selected;
+
+        #endregion
+    }
+}

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/ObjectInspectionPanel.cs

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using PerformanceCalculatorGUI.Components.TextBoxes;
+
+namespace PerformanceCalculatorGUI.Screens.ObjectInspection
+{
+    public partial class ObjectInspectionPanel : Container
+    {
+        private OsuTextFlowContainer textFlow;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddInternal(new Container
+            {
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                AutoSizeAxes = Axes.Both,
+                Masking = true,
+                CornerRadius = ExtendedLabelledTextBox.CORNER_RADIUS,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.95f,
+                        Colour = OsuColour.Gray(0.1f)
+                    },
+                    textFlow = new OsuTextFlowContainer
+                    {
+                        Padding = new MarginPadding(5f),
+                        AutoSizeAxes = Axes.Both,
+                    }
+                }
+            });
+        }
+
+        public void AddParagraph(string text, int fontSize = 10)
+        {
+            textFlow.AddParagraph(text, p => p.Font = OsuFont.GetFont(size: fontSize - 3));
+        }
+    }
+}

PerformanceCalculatorGUI/Screens/ObjectInspection/ObjectInspector.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using NuGet.Packaging.Rules;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -24,6 +25,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
 {