Merge pull request #25154 from peppy/taiko-beat-snap-grid

Add beat snap grid to osu!taiko editor

osu.Game.Rulesets.Catch/Edit/CatchBeatSnapGrid.cs

@@ -1,180 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
+using osu.Framework.Graphics.Containers;
-using osu.Framework.Allocation;
-using osu.Framework.Caching;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.UI.Scrolling;
-using osu.Game.Screens.Edit;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    /// <summary>
+    public partial class CatchBeatSnapGrid : BeatSnapGrid
-    /// A grid which displays coloured beat divisor lines in proximity to the selection or placement cursor.
-    /// </summary>
-    /// <remarks>
-    /// This class heavily borrows from osu!mania's implementation (ManiaBeatSnapGrid).
-    /// If further changes are to be made, they should also be applied there.
-    /// If the scale of the changes are large enough, abstracting may be a good path.
-    /// </remarks>
-    public partial class CatchBeatSnapGrid : Component
     {
-        private const double visible_range = 750;
+        protected override IEnumerable<Container> GetTargetContainers(HitObjectComposer composer) => new[]
-
-        /// <summary>
-        /// The range of time values of the current selection.
-        /// </summary>
-        public (double start, double end)? SelectionTimeRange
         {
-            set
+            ((CatchPlayfield)composer.Playfield).UnderlayElements
-            {
+        };
-                if (value == selectionTimeRange)
-                    return;
-
-                selectionTimeRange = value;
-                lineCache.Invalidate();
-            }
-        }
-
-        [Resolved]
-        private EditorBeatmap beatmap { get; set; } = null!;
-
-        [Resolved]
-        private OsuColour colours { get; set; } = null!;
-
-        [Resolved]
-        private BindableBeatDivisor beatDivisor { get; set; } = null!;
-
-        private readonly Cached lineCache = new Cached();
-
-        private (double start, double end)? selectionTimeRange;
-
-        private ScrollingHitObjectContainer lineContainer = null!;
-
-        [BackgroundDependencyLoader]
-        private void load(HitObjectComposer composer)
-        {
-            lineContainer = new ScrollingHitObjectContainer();
-
-            ((CatchPlayfield)composer.Playfield).UnderlayElements.Add(lineContainer);
-
-            beatDivisor.BindValueChanged(_ => createLines(), true);
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            if (!lineCache.IsValid)
-            {
-                lineCache.Validate();
-                createLines();
-            }
-        }
-
-        private readonly Stack<DrawableGridLine> availableLines = new Stack<DrawableGridLine>();
-
-        private void createLines()
-        {
-            foreach (var line in lineContainer.Objects.OfType<DrawableGridLine>())
-                availableLines.Push(line);
-
-            lineContainer.Clear();
-
-            if (selectionTimeRange == null)
-                return;
-
-            var range = selectionTimeRange.Value;
-
-            var timingPoint = beatmap.ControlPointInfo.TimingPointAt(range.start - visible_range);
-
-            double time = timingPoint.Time;
-            int beat = 0;
-
-            // progress time until in the visible range.
-            while (time < range.start - visible_range)
-            {
-                time += timingPoint.BeatLength / beatDivisor.Value;
-                beat++;
-            }
-
-            while (time < range.end + visible_range)
-            {
-                var nextTimingPoint = beatmap.ControlPointInfo.TimingPointAt(time);
-
-                // switch to the next timing point if we have reached it.
-                if (nextTimingPoint.Time > timingPoint.Time)
-                {
-                    beat = 0;
-                    time = nextTimingPoint.Time;
-                    timingPoint = nextTimingPoint;
-                }
-
-                Color4 colour = BindableBeatDivisor.GetColourFor(
-                    BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value), colours);
-
-                if (!availableLines.TryPop(out var line))
-                    line = new DrawableGridLine();
-
-                line.HitObject.StartTime = time;
-                line.Colour = colour;
-
-                lineContainer.Add(line);
-
-                beat++;
-                time += timingPoint.BeatLength / beatDivisor.Value;
-            }
-
-            // required to update ScrollingHitObjectContainer's cache.
-            lineContainer.UpdateSubTree();
-
-            foreach (var line in lineContainer.Objects.OfType<DrawableGridLine>())
-            {
-                time = line.HitObject.StartTime;
-
-                if (time >= range.start && time <= range.end)
-                    line.Alpha = 1;
-                else
-                {
-                    double timeSeparation = time < range.start ? range.start - time : time - range.end;
-                    line.Alpha = (float)Math.Max(0, 1 - timeSeparation / visible_range);
-                }
-            }
-        }
-
-        private partial class DrawableGridLine : DrawableHitObject
-        {
-            public DrawableGridLine()
-                : base(new HitObject())
-            {
-                RelativeSizeAxes = Axes.X;
-                Height = 2;
-
-                AddInternal(new Box { RelativeSizeAxes = Axes.Both });
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                Origin = Anchor.BottomLeft;
-                Anchor = Anchor.BottomLeft;
-            }
-
-            protected override void UpdateInitialTransforms()
-            {
-                // don't perform any fading – we are handling that ourselves.
-                LifetimeEnd = HitObject.StartTime + visible_range;
-            }
-        }
     }
 }

osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs

@@ -7,11 +7,9 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
@@ -32,10 +30,6 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         private CatchDistanceSnapGrid distanceSnapGrid = null!;
 
-        private InputManager inputManager = null!;
-
-        private CatchBeatSnapGrid beatSnapGrid = null!;
-
         private readonly BindableDouble timeRangeMultiplier = new BindableDouble(1)
         {
             MinValue = 1,
@@ -74,50 +68,28 @@ namespace osu.Game.Rulesets.Catch.Edit
                 Catcher.BASE_DASH_SPEED, -Catcher.BASE_DASH_SPEED,
                 Catcher.BASE_WALK_SPEED, -Catcher.BASE_WALK_SPEED,
             }));
-
-            AddInternal(beatSnapGrid = new CatchBeatSnapGrid());
         }
 
         protected override IEnumerable<TernaryButton> CreateTernaryButtons()
             => base.CreateTernaryButtons()
                    .Concat(DistanceSnapProvider.CreateTernaryButtons());
 
-        protected override void LoadComplete()
+        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
+            new DrawableCatchEditorRuleset(ruleset, beatmap, mods)
             {
-            base.LoadComplete();
+                TimeRangeMultiplier = { BindTarget = timeRangeMultiplier, }
+            };
 
-            inputManager = GetContainingInputManager();
+        protected override ComposeBlueprintContainer CreateBlueprintContainer() => new CatchBlueprintContainer(this);
-        }
 
-        protected override void UpdateAfterChildren()
+        protected override BeatSnapGrid CreateBeatSnapGrid() => new CatchBeatSnapGrid();
-        {
-            base.UpdateAfterChildren();
 
-            if (BlueprintContainer.CurrentTool is SelectTool)
+        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {
-                if (EditorBeatmap.SelectedHitObjects.Any())
+            new FruitCompositionTool(),
-                {
+            new JuiceStreamCompositionTool(),
-                    beatSnapGrid.SelectionTimeRange = (EditorBeatmap.SelectedHitObjects.Min(h => h.StartTime), EditorBeatmap.SelectedHitObjects.Max(h => h.GetEndTime()));
+            new BananaShowerCompositionTool()
-                }
+        };
-                else
-                    beatSnapGrid.SelectionTimeRange = null;
-            }
-            else
-            {
-                var result = FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position);
-                if (result.Time is double time)
-                    beatSnapGrid.SelectionTimeRange = (time, time);
-                else
-                    beatSnapGrid.SelectionTimeRange = null;
-            }
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            updateDistanceSnapGrid();
-        }
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
@@ -142,19 +114,6 @@ namespace osu.Game.Rulesets.Catch.Edit
         {
         }
 
-        protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
-            new DrawableCatchEditorRuleset(ruleset, beatmap, mods)
-            {
-                TimeRangeMultiplier = { BindTarget = timeRangeMultiplier, }
-            };
-
-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
-        {
-            new FruitCompositionTool(),
-            new JuiceStreamCompositionTool(),
-            new BananaShowerCompositionTool()
-        };
-
         public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
         {
             var result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
@@ -173,8 +132,6 @@ namespace osu.Game.Rulesets.Catch.Edit
             return result;
         }
 
-        protected override ComposeBlueprintContainer CreateBlueprintContainer() => new CatchBlueprintContainer(this);
-
         private PalpableCatchHitObject? getLastSnappableHitObject(double time)
         {
             var hitObject = EditorBeatmap.HitObjects.OfType<CatchHitObject>().LastOrDefault(h => h.GetEndTime() < time && !(h is BananaShower));
@@ -215,33 +172,12 @@ namespace osu.Game.Rulesets.Catch.Edit
                             return null;
                     }
 
-                    double timeAtCursor = ((CatchPlayfield)Playfield).TimeAtScreenSpacePosition(inputManager.CurrentState.Mouse.Position);
+                    double timeAtCursor = ((CatchPlayfield)Playfield).TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
                     return getLastSnappableHitObject(timeAtCursor);
 
                 default:
                     return null;
             }
         }
-
-        private void updateDistanceSnapGrid()
-        {
-            if (DistanceSnapProvider.DistanceSnapToggle.Value != TernaryState.True)
-            {
-                distanceSnapGrid.Hide();
-                return;
-            }
-
-            var sourceHitObject = getDistanceSnapGridSourceHitObject();
-
-            if (sourceHitObject == null)
-            {
-                distanceSnapGrid.Hide();
-                return;
-            }
-
-            distanceSnapGrid.Show();
-            distanceSnapGrid.StartTime = sourceHitObject.GetEndTime();
-            distanceSnapGrid.StartX = sourceHitObject.EffectiveX;
-        }
     }
 }

osu.Game.Rulesets.Mania/Edit/ManiaBeatSnapGrid.cs

@@ -1,206 +1,23 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Caching;
-using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Pooling;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.UI.Scrolling;
-using osu.Game.Screens.Edit;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    /// <summary>
+    public partial class ManiaBeatSnapGrid : BeatSnapGrid
-    /// A grid which displays coloured beat divisor lines in proximity to the selection or placement cursor.
-    /// </summary>
-    public partial class ManiaBeatSnapGrid : CompositeComponent
     {
-        private const double visible_range = 750;
+        protected override IEnumerable<Container> GetTargetContainers(HitObjectComposer composer)
-
-        /// <summary>
-        /// The range of time values of the current selection.
-        /// </summary>
-        public (double start, double end)? SelectionTimeRange
         {
-            set
+            return ((ManiaPlayfield)composer.Playfield)
-            {
+                   .Stages
-                if (value == selectionTimeRange)
+                   .SelectMany(stage => stage.Columns)
-                    return;
+                   .Select(column => column.UnderlayElements);
-
-                selectionTimeRange = value;
-                lineCache.Invalidate();
-            }
-        }
-
-        [Resolved]
-        private EditorBeatmap beatmap { get; set; } = null!;
-
-        [Resolved]
-        private OsuColour colours { get; set; } = null!;
-
-        [Resolved]
-        private BindableBeatDivisor beatDivisor { get; set; } = null!;
-
-        private readonly List<ScrollingHitObjectContainer> grids = new List<ScrollingHitObjectContainer>();
-
-        private readonly DrawablePool<DrawableGridLine> linesPool = new DrawablePool<DrawableGridLine>(50);
-
-        private readonly Cached lineCache = new Cached();
-
-        private (double start, double end)? selectionTimeRange;
-
-        [BackgroundDependencyLoader]
-        private void load(HitObjectComposer composer)
-        {
-            AddInternal(linesPool);
-
-            foreach (var stage in ((ManiaPlayfield)composer.Playfield).Stages)
-            {
-                foreach (var column in stage.Columns)
-                {
-                    var lineContainer = new ScrollingHitObjectContainer();
-
-                    grids.Add(lineContainer);
-                    column.UnderlayElements.Add(lineContainer);
-                }
-            }
-
-            beatDivisor.BindValueChanged(_ => createLines(), true);
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            if (!lineCache.IsValid)
-            {
-                lineCache.Validate();
-                createLines();
-            }
-        }
-
-        private void createLines()
-        {
-            foreach (var grid in grids)
-                grid.Clear();
-
-            if (selectionTimeRange == null)
-                return;
-
-            var range = selectionTimeRange.Value;
-
-            var timingPoint = beatmap.ControlPointInfo.TimingPointAt(range.start - visible_range);
-
-            double time = timingPoint.Time;
-            int beat = 0;
-
-            // progress time until in the visible range.
-            while (time < range.start - visible_range)
-            {
-                time += timingPoint.BeatLength / beatDivisor.Value;
-                beat++;
-            }
-
-            while (time < range.end + visible_range)
-            {
-                var nextTimingPoint = beatmap.ControlPointInfo.TimingPointAt(time);
-
-                // switch to the next timing point if we have reached it.
-                if (nextTimingPoint.Time > timingPoint.Time)
-                {
-                    beat = 0;
-                    time = nextTimingPoint.Time;
-                    timingPoint = nextTimingPoint;
-                }
-
-                Color4 colour = BindableBeatDivisor.GetColourFor(
-                    BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value), colours);
-
-                foreach (var grid in grids)
-                {
-                    var line = linesPool.Get();
-
-                    line.Apply(new HitObject
-                    {
-                        StartTime = time
-                    });
-
-                    line.Colour = colour;
-
-                    grid.Add(line);
-                }
-
-                beat++;
-                time += timingPoint.BeatLength / beatDivisor.Value;
-            }
-
-            foreach (var grid in grids)
-            {
-                // required to update ScrollingHitObjectContainer's cache.
-                grid.UpdateSubTree();
-
-                foreach (var line in grid.Objects.OfType<DrawableGridLine>())
-                {
-                    time = line.HitObject.StartTime;
-
-                    if (time >= range.start && time <= range.end)
-                        line.Alpha = 1;
-                    else
-                    {
-                        double timeSeparation = time < range.start ? range.start - time : time - range.end;
-                        line.Alpha = (float)Math.Max(0, 1 - timeSeparation / visible_range);
-                    }
-                }
-            }
-        }
-
-        private partial class DrawableGridLine : DrawableHitObject
-        {
-            [Resolved]
-            private IScrollingInfo scrollingInfo { get; set; } = null!;
-
-            private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
-
-            public DrawableGridLine()
-                : base(new HitObject())
-            {
-                RelativeSizeAxes = Axes.X;
-                Height = 2;
-
-                AddInternal(new Box { RelativeSizeAxes = Axes.Both });
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                direction.BindTo(scrollingInfo.Direction);
-                direction.BindValueChanged(onDirectionChanged, true);
-            }
-
-            private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
-            {
-                Origin = Anchor = direction.NewValue == ScrollingDirection.Up
-                    ? Anchor.TopLeft
-                    : Anchor.BottomLeft;
-            }
-
-            protected override void UpdateInitialTransforms()
-            {
-                // don't perform any fading – we are handling that ourselves.
-                LifetimeEnd = HitObject.StartTime + visible_range;
-            }
         }
     }
 }

osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs

@@ -5,15 +5,12 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
@@ -24,32 +21,12 @@ namespace osu.Game.Rulesets.Mania.Edit
     public partial class ManiaHitObjectComposer : ScrollingHitObjectComposer<ManiaHitObject>
     {
         private DrawableManiaEditorRuleset drawableRuleset;
-        private ManiaBeatSnapGrid beatSnapGrid;
-        private InputManager inputManager;
 
         public ManiaHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
         {
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            AddInternal(beatSnapGrid = new ManiaBeatSnapGrid());
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            inputManager = GetContainingInputManager();
-        }
-
-        private DependencyContainer dependencies;
-
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-            => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-
         public new ManiaPlayfield Playfield => ((ManiaPlayfield)drawableRuleset.Playfield);
 
         public IScrollingInfo ScrollingInfo => drawableRuleset.ScrollingInfo;
@@ -57,48 +34,20 @@ namespace osu.Game.Rulesets.Mania.Edit
         protected override Playfield PlayfieldAtScreenSpacePosition(Vector2 screenSpacePosition) =>
             Playfield.GetColumnByPosition(screenSpacePosition);
 
-        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
+        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods) =>
-        {
             drawableRuleset = new DrawableManiaEditorRuleset(ruleset, beatmap, mods);
 
-            // This is the earliest we can cache the scrolling info to ourselves, before masks are added to the hierarchy and inject it
-            dependencies.CacheAs(drawableRuleset.ScrollingInfo);
-
-            return drawableRuleset;
-        }
-
         protected override ComposeBlueprintContainer CreateBlueprintContainer()
             => new ManiaBlueprintContainer(this);
 
+        protected override BeatSnapGrid CreateBeatSnapGrid() => new ManiaBeatSnapGrid();
+
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {
             new NoteCompositionTool(),
             new HoldNoteCompositionTool()
         };
 
-        protected override void UpdateAfterChildren()
-        {
-            base.UpdateAfterChildren();
-
-            if (BlueprintContainer.CurrentTool is SelectTool)
-            {
-                if (EditorBeatmap.SelectedHitObjects.Any())
-                {
-                    beatSnapGrid.SelectionTimeRange = (EditorBeatmap.SelectedHitObjects.Min(h => h.StartTime), EditorBeatmap.SelectedHitObjects.Max(h => h.GetEndTime()));
-                }
-                else
-                    beatSnapGrid.SelectionTimeRange = null;
-            }
-            else
-            {
-                var result = FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position);
-                if (result.Time is double time)
-                    beatSnapGrid.SelectionTimeRange = (time, time);
-                else
-                    beatSnapGrid.SelectionTimeRange = null;
-            }
-        }
-
         public override string ConvertSelectionToString()
             => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<ManiaHitObject>().OrderBy(h => h.StartTime).Select(h => $"{h.StartTime}|{h.Column}"));
     }

osu.Game.Rulesets.Taiko/Edit/TaikoBeatSnapGrid.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Screens.Edit.Compose.Components;
+
+namespace osu.Game.Rulesets.Taiko.Edit
+{
+    public partial class TaikoBeatSnapGrid : BeatSnapGrid
+    {
+        protected override IEnumerable<Container> GetTargetContainers(HitObjectComposer composer) => new[]
+        {
+            ((TaikoPlayfield)composer.Playfield).UnderlayElements
+        };
+    }
+}

osu.Game.Rulesets.Taiko/Edit/TaikoHitObjectComposer.cs

@@ -33,5 +33,7 @@ namespace osu.Game.Rulesets.Taiko.Edit
 
         protected override ComposeBlueprintContainer CreateBlueprintContainer()
             => new TaikoBlueprintContainer(this);
+
+        protected override BeatSnapGrid CreateBeatSnapGrid() => new TaikoBeatSnapGrid();
     }
 }

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -40,6 +40,8 @@ namespace osu.Game.Rulesets.Taiko.UI
         /// </summary>
         public Bindable<bool> ClassicHitTargetPosition = new BindableBool();
 
+        public Container UnderlayElements { get; private set; } = null!;
+
         private Container<HitExplosion> hitExplosionContainer;
         private Container<KiaiHitExplosion> kiaiExplosionContainer;
         private JudgementContainer<DrawableTaikoJudgement> judgementContainer;
@@ -130,7 +132,14 @@ namespace osu.Game.Rulesets.Taiko.UI
                         {
                             Name = "Bar line content",
                             RelativeSizeAxes = Axes.Both,
-                            Child = barLinePlayfield = new BarLinePlayfield(),
+                            Children = new Drawable[]
+                            {
+                                UnderlayElements = new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                },
+                                barLinePlayfield = new BarLinePlayfield(),
+                            }
                         },
                         hitObjectContent = new Container
                         {

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Edit
 
         protected readonly Container LayerBelowRuleset = new Container { RelativeSizeAxes = Axes.Both };
 
-        private InputManager inputManager;
+        protected InputManager InputManager { get; private set; }
 
         private EditorRadioButtonCollection toolboxCollection;
 
@@ -119,9 +119,12 @@ namespace osu.Game.Rulesets.Edit
                 return;
             }
 
+            if (DrawableRuleset is IDrawableScrollingRuleset scrollingRuleset)
+                dependencies.CacheAs(scrollingRuleset.ScrollingInfo);
+
             dependencies.CacheAs(Playfield);
 
-            InternalChildren = new Drawable[]
+            InternalChildren = new[]
             {
                 PlayfieldContentContainer = new Container
                 {
@@ -201,7 +204,7 @@ namespace osu.Game.Rulesets.Edit
                             },
                         }
                     }
-                }
+                },
             };
 
             toolboxCollection.Items = CompositionTools
@@ -232,7 +235,7 @@ namespace osu.Game.Rulesets.Edit
         {
             base.LoadComplete();
 
-            inputManager = GetContainingInputManager();
+            InputManager = GetContainingInputManager();
 
             hasTiming = EditorBeatmap.HasTiming.GetBoundCopy();
             hasTiming.BindValueChanged(timing =>
@@ -270,7 +273,7 @@ namespace osu.Game.Rulesets.Edit
 
         public override IEnumerable<DrawableHitObject> HitObjects => drawableRulesetWrapper.Playfield.AllHitObjects;
 
-        public override bool CursorInPlacementArea => drawableRulesetWrapper.Playfield.ReceivePositionalInputAt(inputManager.CurrentState.Mouse.Position);
+        public override bool CursorInPlacementArea => drawableRulesetWrapper.Playfield.ReceivePositionalInputAt(InputManager.CurrentState.Mouse.Position);
 
         /// <summary>
         /// Defines all available composition tools, listed on the left side of the editor screen as button controls.

osu.Game/Rulesets/Edit/ScrollingHitObjectComposer.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -8,9 +9,11 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Components.TernaryButtons;
+using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
 namespace osu.Game.Rulesets.Edit
@@ -21,6 +24,13 @@ namespace osu.Game.Rulesets.Edit
         private readonly Bindable<TernaryState> showSpeedChanges = new Bindable<TernaryState>();
         private Bindable<bool> configShowSpeedChanges = null!;
 
+        private BeatSnapGrid? beatSnapGrid;
+
+        /// <summary>
+        /// Construct an optional beat snap grid.
+        /// </summary>
+        protected virtual BeatSnapGrid? CreateBeatSnapGrid() => null;
+
         protected ScrollingHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
         {
@@ -57,6 +67,42 @@ namespace osu.Game.Rulesets.Edit
                     configShowSpeedChanges.Value = enabled;
                 }, true);
             }
+
+            beatSnapGrid = CreateBeatSnapGrid();
+
+            if (beatSnapGrid != null)
+                AddInternal(beatSnapGrid);
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            updateBeatSnapGrid();
+        }
+
+        private void updateBeatSnapGrid()
+        {
+            if (beatSnapGrid == null)
+                return;
+
+            if (BlueprintContainer.CurrentTool is SelectTool)
+            {
+                if (EditorBeatmap.SelectedHitObjects.Any())
+                {
+                    beatSnapGrid.SelectionTimeRange = (EditorBeatmap.SelectedHitObjects.Min(h => h.StartTime), EditorBeatmap.SelectedHitObjects.Max(h => h.GetEndTime()));
+                }
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
+            else
+            {
+                var result = FindSnappedPositionAndTime(InputManager.CurrentState.Mouse.Position);
+                if (result.Time is double time)
+                    beatSnapGrid.SelectionTimeRange = (time, time);
+                else
+                    beatSnapGrid.SelectionTimeRange = null;
+            }
         }
     }
 }

osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs

@@ -81,7 +81,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected readonly SortedList<MultiplierControlPoint> ControlPoints = new SortedList<MultiplierControlPoint>(Comparer<MultiplierControlPoint>.Default);
 
-        protected IScrollingInfo ScrollingInfo => scrollingInfo;
+        public IScrollingInfo ScrollingInfo => scrollingInfo;
 
         [Cached(Type = typeof(IScrollingInfo))]
         private readonly LocalScrollingInfo scrollingInfo;

osu.Game/Rulesets/UI/Scrolling/IDrawableScrollingRuleset.cs

@@ -11,5 +11,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
     public interface IDrawableScrollingRuleset
     {
         ScrollVisualisationMethod VisualisationMethod { get; }
+
+        IScrollingInfo ScrollingInfo { get; }
     }
 }

osu.Game/Screens/Edit/Compose/Components/BeatSnapGrid.cs

@@ -0,0 +1,213 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    /// <summary>
+    /// A grid which displays coloured beat divisor lines in proximity to the selection or placement cursor.
+    /// </summary>
+    public abstract partial class BeatSnapGrid : CompositeComponent
+    {
+        private const double visible_range = 750;
+
+        /// <summary>
+        /// The range of time values of the current selection.
+        /// </summary>
+        public (double start, double end)? SelectionTimeRange
+        {
+            set
+            {
+                if (value == selectionTimeRange)
+                    return;
+
+                selectionTimeRange = value;
+                lineCache.Invalidate();
+            }
+        }
+
+        [Resolved]
+        private EditorBeatmap beatmap { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [Resolved]
+        private BindableBeatDivisor beatDivisor { get; set; } = null!;
+
+        private readonly List<ScrollingHitObjectContainer> grids = new List<ScrollingHitObjectContainer>();
+
+        private readonly DrawablePool<DrawableGridLine> linesPool = new DrawablePool<DrawableGridLine>(50);
+
+        private readonly Cached lineCache = new Cached();
+
+        private (double start, double end)? selectionTimeRange;
+
+        [BackgroundDependencyLoader]
+        private void load(HitObjectComposer composer)
+        {
+            AddInternal(linesPool);
+
+            foreach (var target in GetTargetContainers(composer))
+            {
+                var lineContainer = new ScrollingHitObjectContainer();
+
+                grids.Add(lineContainer);
+                target.Add(lineContainer);
+            }
+
+            beatDivisor.BindValueChanged(_ => createLines(), true);
+        }
+
+        protected abstract IEnumerable<Container> GetTargetContainers(HitObjectComposer composer);
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!lineCache.IsValid)
+            {
+                lineCache.Validate();
+                createLines();
+            }
+        }
+
+        private void createLines()
+        {
+            foreach (var grid in grids)
+                grid.Clear();
+
+            if (selectionTimeRange == null)
+                return;
+
+            var range = selectionTimeRange.Value;
+
+            var timingPoint = beatmap.ControlPointInfo.TimingPointAt(range.start - visible_range);
+
+            double time = timingPoint.Time;
+            int beat = 0;
+
+            // progress time until in the visible range.
+            while (time < range.start - visible_range)
+            {
+                time += timingPoint.BeatLength / beatDivisor.Value;
+                beat++;
+            }
+
+            while (time < range.end + visible_range)
+            {
+                var nextTimingPoint = beatmap.ControlPointInfo.TimingPointAt(time);
+
+                // switch to the next timing point if we have reached it.
+                if (nextTimingPoint.Time > timingPoint.Time)
+                {
+                    beat = 0;
+                    time = nextTimingPoint.Time;
+                    timingPoint = nextTimingPoint;
+                }
+
+                Color4 colour = BindableBeatDivisor.GetColourFor(
+                    BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value), colours);
+
+                foreach (var grid in grids)
+                {
+                    var line = linesPool.Get();
+
+                    line.Apply(new HitObject
+                    {
+                        StartTime = time
+                    });
+
+                    line.Colour = colour;
+
+                    grid.Add(line);
+                }
+
+                beat++;
+                time += timingPoint.BeatLength / beatDivisor.Value;
+            }
+
+            foreach (var grid in grids)
+            {
+                // required to update ScrollingHitObjectContainer's cache.
+                grid.UpdateSubTree();
+
+                foreach (var line in grid.Objects.OfType<DrawableGridLine>())
+                {
+                    time = line.HitObject.StartTime;
+
+                    if (time >= range.start && time <= range.end)
+                        line.Alpha = 1;
+                    else
+                    {
+                        double timeSeparation = time < range.start ? range.start - time : time - range.end;
+                        line.Alpha = (float)Math.Max(0, 1 - timeSeparation / visible_range);
+                    }
+                }
+            }
+        }
+
+        private partial class DrawableGridLine : DrawableHitObject
+        {
+            [Resolved]
+            private IScrollingInfo scrollingInfo { get; set; } = null!;
+
+            private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+            public DrawableGridLine()
+                : base(new HitObject())
+            {
+                AddInternal(new Box { RelativeSizeAxes = Axes.Both });
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                direction.BindTo(scrollingInfo.Direction);
+                direction.BindValueChanged(onDirectionChanged, true);
+            }
+
+            private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+            {
+                Origin = Anchor = direction.NewValue == ScrollingDirection.Up
+                    ? Anchor.TopLeft
+                    : Anchor.BottomLeft;
+
+                bool isHorizontal = direction.NewValue == ScrollingDirection.Left || direction.NewValue == ScrollingDirection.Right;
+
+                if (isHorizontal)
+                {
+                    RelativeSizeAxes = Axes.Y;
+                    Width = 2;
+                }
+                else
+                {
+                    RelativeSizeAxes = Axes.X;
+                    Height = 2;
+                }
+            }
+
+            protected override void UpdateInitialTransforms()
+            {
+                // don't perform any fading – we are handling that ourselves.
+                LifetimeEnd = HitObject.StartTime + visible_range;
+            }
+        }
+    }
+}