2020-01-27 16:34:25 +08:00
|
|
|
// 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.
|
|
|
|
|
2020-10-09 14:38:58 +08:00
|
|
|
using System;
|
2020-01-27 16:34:25 +08:00
|
|
|
using System.Linq;
|
|
|
|
using osu.Framework.Allocation;
|
|
|
|
using osu.Framework.Bindables;
|
2020-10-09 14:57:31 +08:00
|
|
|
using osu.Framework.Caching;
|
2020-01-27 16:34:25 +08:00
|
|
|
using osu.Framework.Graphics;
|
|
|
|
using osu.Game.Beatmaps;
|
|
|
|
using osu.Game.Graphics;
|
|
|
|
using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
|
|
|
|
using osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations;
|
|
|
|
|
|
|
|
namespace osu.Game.Screens.Edit.Compose.Components.Timeline
|
|
|
|
{
|
2020-10-09 14:38:58 +08:00
|
|
|
public class TimelineTickDisplay : TimelinePart<PointVisualisation>
|
2020-01-27 16:34:25 +08:00
|
|
|
{
|
|
|
|
[Resolved]
|
|
|
|
private EditorBeatmap beatmap { get; set; }
|
|
|
|
|
|
|
|
[Resolved]
|
|
|
|
private Bindable<WorkingBeatmap> working { get; set; }
|
|
|
|
|
|
|
|
[Resolved]
|
|
|
|
private BindableBeatDivisor beatDivisor { get; set; }
|
|
|
|
|
2020-12-02 03:08:31 +08:00
|
|
|
[Resolved(CanBeNull = true)]
|
2020-12-01 15:44:08 +08:00
|
|
|
private IEditorChangeHandler changeHandler { get; set; }
|
|
|
|
|
2020-01-27 16:34:25 +08:00
|
|
|
[Resolved]
|
|
|
|
private OsuColour colours { get; set; }
|
|
|
|
|
2021-04-13 15:25:43 +08:00
|
|
|
private static readonly int highest_divisor = BindableBeatDivisor.VALID_DIVISORS.Last();
|
|
|
|
|
2020-01-27 17:07:46 +08:00
|
|
|
public TimelineTickDisplay()
|
2020-01-27 16:34:25 +08:00
|
|
|
{
|
|
|
|
RelativeSizeAxes = Axes.Both;
|
|
|
|
}
|
|
|
|
|
2020-10-09 14:57:31 +08:00
|
|
|
private readonly Cached tickCache = new Cached();
|
|
|
|
|
|
|
|
[BackgroundDependencyLoader]
|
|
|
|
private void load()
|
|
|
|
{
|
2020-12-01 15:44:08 +08:00
|
|
|
beatDivisor.BindValueChanged(_ => invalidateTicks());
|
|
|
|
|
2020-12-02 03:08:31 +08:00
|
|
|
if (changeHandler != null)
|
|
|
|
// currently this is the best way to handle any kind of timing changes.
|
|
|
|
changeHandler.OnStateChange += invalidateTicks;
|
2020-12-01 15:44:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
private void invalidateTicks()
|
|
|
|
{
|
|
|
|
tickCache.Invalidate();
|
2020-10-09 14:57:31 +08:00
|
|
|
}
|
|
|
|
|
2020-10-09 15:46:54 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The visible time/position range of the timeline.
|
|
|
|
/// </summary>
|
2020-10-09 14:57:31 +08:00
|
|
|
private (float min, float max) visibleRange = (float.MinValue, float.MaxValue);
|
|
|
|
|
2020-10-09 15:46:54 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The next time/position value to the left of the display when tick regeneration needs to be run.
|
|
|
|
/// </summary>
|
|
|
|
private float? nextMinTick;
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// The next time/position value to the right of the display when tick regeneration needs to be run.
|
|
|
|
/// </summary>
|
|
|
|
private float? nextMaxTick;
|
|
|
|
|
2020-10-09 14:38:58 +08:00
|
|
|
[Resolved(canBeNull: true)]
|
|
|
|
private Timeline timeline { get; set; }
|
2020-01-27 16:34:25 +08:00
|
|
|
|
2020-10-09 14:38:58 +08:00
|
|
|
protected override void Update()
|
2020-01-27 16:34:25 +08:00
|
|
|
{
|
2020-10-09 14:38:58 +08:00
|
|
|
base.Update();
|
|
|
|
|
|
|
|
if (timeline != null)
|
|
|
|
{
|
2020-10-09 14:57:31 +08:00
|
|
|
var newRange = (
|
2021-04-13 15:25:43 +08:00
|
|
|
(ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopLeft).X - PointVisualisation.MAX_WIDTH * 2) / DrawWidth * Content.RelativeChildSize.X,
|
|
|
|
(ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopRight).X + PointVisualisation.MAX_WIDTH * 2) / DrawWidth * Content.RelativeChildSize.X);
|
2020-10-09 14:57:31 +08:00
|
|
|
|
|
|
|
if (visibleRange != newRange)
|
2020-10-09 15:46:54 +08:00
|
|
|
{
|
|
|
|
visibleRange = newRange;
|
2020-10-09 14:57:31 +08:00
|
|
|
|
2020-10-09 15:46:54 +08:00
|
|
|
// actual regeneration only needs to occur if we've passed one of the known next min/max tick boundaries.
|
|
|
|
if (nextMinTick == null || nextMaxTick == null || (visibleRange.min < nextMinTick || visibleRange.max > nextMaxTick))
|
|
|
|
tickCache.Invalidate();
|
|
|
|
}
|
2020-10-09 14:38:58 +08:00
|
|
|
}
|
2020-01-27 16:34:25 +08:00
|
|
|
|
2020-10-09 14:57:31 +08:00
|
|
|
if (!tickCache.IsValid)
|
|
|
|
createTicks();
|
|
|
|
}
|
|
|
|
|
|
|
|
private void createTicks()
|
|
|
|
{
|
|
|
|
int drawableIndex = 0;
|
2020-10-09 15:46:54 +08:00
|
|
|
|
|
|
|
nextMinTick = null;
|
|
|
|
nextMaxTick = null;
|
2020-10-09 14:57:31 +08:00
|
|
|
|
2020-01-27 16:34:25 +08:00
|
|
|
for (var i = 0; i < beatmap.ControlPointInfo.TimingPoints.Count; i++)
|
|
|
|
{
|
|
|
|
var point = beatmap.ControlPointInfo.TimingPoints[i];
|
2020-02-01 01:05:26 +08:00
|
|
|
var until = i + 1 < beatmap.ControlPointInfo.TimingPoints.Count ? beatmap.ControlPointInfo.TimingPoints[i + 1].Time : working.Value.Track.Length;
|
2020-01-27 16:34:25 +08:00
|
|
|
|
|
|
|
int beat = 0;
|
|
|
|
|
|
|
|
for (double t = point.Time; t < until; t += point.BeatLength / beatDivisor.Value)
|
|
|
|
{
|
2020-10-09 15:46:54 +08:00
|
|
|
float xPos = (float)t;
|
|
|
|
|
|
|
|
if (t < visibleRange.min)
|
|
|
|
nextMinTick = xPos;
|
|
|
|
else if (t > visibleRange.max)
|
|
|
|
nextMaxTick ??= xPos;
|
|
|
|
else
|
2020-01-27 16:34:25 +08:00
|
|
|
{
|
2020-10-09 15:46:54 +08:00
|
|
|
// if this is the first beat in the beatmap, there is no next min tick
|
|
|
|
if (beat == 0 && i == 0)
|
|
|
|
nextMinTick = float.MinValue;
|
|
|
|
|
2021-03-19 18:45:00 +08:00
|
|
|
int indexInBar = beat % ((int)point.TimeSignature * beatDivisor.Value);
|
2020-01-27 16:34:25 +08:00
|
|
|
|
2020-10-09 15:46:54 +08:00
|
|
|
var divisor = BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value);
|
|
|
|
var colour = BindableBeatDivisor.GetColourFor(divisor, colours);
|
|
|
|
|
|
|
|
// even though "bar lines" take up the full vertical space, we render them in two pieces because it allows for less anchor/origin churn.
|
2021-04-13 15:25:43 +08:00
|
|
|
|
|
|
|
var line = getNextUsableLine();
|
|
|
|
line.X = xPos;
|
|
|
|
line.Width = PointVisualisation.MAX_WIDTH * getWidth(indexInBar, divisor);
|
|
|
|
line.Colour = colour;
|
2020-01-27 16:34:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
beat++;
|
|
|
|
}
|
|
|
|
}
|
2020-10-09 14:38:58 +08:00
|
|
|
|
|
|
|
int usedDrawables = drawableIndex;
|
|
|
|
|
|
|
|
// save a few drawables beyond the currently used for edge cases.
|
|
|
|
while (drawableIndex < Math.Min(usedDrawables + 16, Count))
|
|
|
|
Children[drawableIndex++].Hide();
|
|
|
|
|
|
|
|
// expire any excess
|
|
|
|
while (drawableIndex < Count)
|
|
|
|
Children[drawableIndex++].Expire();
|
|
|
|
|
2020-10-09 14:57:31 +08:00
|
|
|
tickCache.Validate();
|
|
|
|
|
2021-04-13 15:25:43 +08:00
|
|
|
Drawable getNextUsableLine()
|
2020-10-09 14:38:58 +08:00
|
|
|
{
|
|
|
|
PointVisualisation point;
|
|
|
|
if (drawableIndex >= Count)
|
|
|
|
Add(point = new PointVisualisation());
|
|
|
|
else
|
2020-10-09 15:46:54 +08:00
|
|
|
point = Children[drawableIndex];
|
2020-10-09 14:38:58 +08:00
|
|
|
|
2020-10-09 15:46:54 +08:00
|
|
|
drawableIndex++;
|
2020-10-09 14:38:58 +08:00
|
|
|
point.Show();
|
|
|
|
|
|
|
|
return point;
|
|
|
|
}
|
2020-01-27 16:34:25 +08:00
|
|
|
}
|
2020-12-01 15:44:08 +08:00
|
|
|
|
2021-04-13 15:25:43 +08:00
|
|
|
private static float getWidth(int indexInBar, int divisor)
|
|
|
|
{
|
|
|
|
if (indexInBar == 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
switch (divisor)
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
return 0.6f;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
case 4:
|
|
|
|
return 0.5f;
|
|
|
|
|
|
|
|
case 6:
|
|
|
|
case 8:
|
|
|
|
return 0.4f;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return 0.3f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-01 15:44:08 +08:00
|
|
|
protected override void Dispose(bool isDisposing)
|
|
|
|
{
|
|
|
|
base.Dispose(isDisposing);
|
|
|
|
|
|
|
|
if (changeHandler != null)
|
|
|
|
changeHandler.OnStateChange -= invalidateTicks;
|
|
|
|
}
|
2020-01-27 16:34:25 +08:00
|
|
|
}
|
|
|
|
}
|