1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 16:22:57 +08:00
osu-lazer/osu.Game/Graphics/Containers/ScalingContainer.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

266 lines
10 KiB
C#
Raw Normal View History

// 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.
2019-01-04 12:29:37 +08:00
using osu.Framework.Allocation;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
2019-01-04 12:29:37 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Primitives;
using osu.Framework.Layout;
using osu.Framework.Platform;
using osu.Framework.Screens;
2019-01-04 12:29:37 +08:00
using osu.Game.Configuration;
using osu.Game.Screens;
using osu.Game.Screens.Backgrounds;
2019-01-04 12:29:37 +08:00
using osuTK;
namespace osu.Game.Graphics.Containers
{
/// <summary>
/// Handles user-defined scaling, allowing application at multiple levels defined by <see cref="ScalingMode"/>.
/// </summary>
public class ScalingContainer : Container
{
private const float duration = 500;
2019-01-04 12:29:37 +08:00
private Bindable<float> sizeX;
private Bindable<float> sizeY;
private Bindable<float> posX;
private Bindable<float> posY;
private Bindable<MarginPadding> safeAreaPadding;
2019-01-04 14:28:35 +08:00
private readonly ScalingMode? targetMode;
2019-01-04 12:29:37 +08:00
private Bindable<ScalingMode> scalingMode;
private readonly Container content;
protected override Container<Drawable> Content => content;
public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
2019-01-04 12:29:37 +08:00
private readonly Container sizableContainer;
private BackgroundScreenStack backgroundStack;
2019-01-04 12:29:37 +08:00
2022-03-02 19:33:28 +08:00
private RectangleF? customRect;
private bool customRectIsRelativePosition;
/// <summary>
/// Set a custom position and scale which overrides any user specification.
/// </summary>
/// <param name="rect">A rectangle with positional and sizing information for this container to conform to. <c>null</c> will clear the custom rect and revert to user settings.</param>
/// <param name="relativePosition">Whether the position portion of the provided rect is in relative coordinate space or not.</param>
2022-03-02 19:33:28 +08:00
public void SetCustomRect(RectangleF? rect, bool relativePosition = false)
{
2022-03-02 19:33:28 +08:00
customRect = rect;
customRectIsRelativePosition = relativePosition;
if (IsLoaded) Scheduler.AddOnce(updateSize);
}
private const float corner_radius = 10;
2019-01-04 12:29:37 +08:00
/// <summary>
/// Create a new instance.
/// </summary>
2019-01-04 14:28:35 +08:00
/// <param name="targetMode">The mode which this container should be handling. Handles all modes if null.</param>
public ScalingContainer(ScalingMode? targetMode = null)
2019-01-04 12:29:37 +08:00
{
this.targetMode = targetMode;
RelativeSizeAxes = Axes.Both;
InternalChild = sizableContainer = new SizeableAlwaysInputContainer(targetMode == ScalingMode.Everything)
2019-01-04 12:29:37 +08:00
{
RelativeSizeAxes = Axes.Both,
RelativePositionAxes = Axes.Both,
CornerRadius = corner_radius,
Child = content = new ScalingDrawSizePreservingFillContainer(targetMode != ScalingMode.Gameplay)
2019-01-04 12:29:37 +08:00
};
}
public class ScalingDrawSizePreservingFillContainer : DrawSizePreservingFillContainer
{
private readonly bool applyUIScale;
private Bindable<float> uiScale;
protected float CurrentScale { get; private set; } = 1;
public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
public ScalingDrawSizePreservingFillContainer(bool applyUIScale)
{
this.applyUIScale = applyUIScale;
}
[BackgroundDependencyLoader]
private void load(OsuConfigManager osuConfig)
{
if (applyUIScale)
{
uiScale = osuConfig.GetBindable<float>(OsuSetting.UIScale);
uiScale.BindValueChanged(args => this.TransformTo(nameof(CurrentScale), args.NewValue, duration, Easing.OutQuart), true);
}
}
protected override void Update()
{
Scale = new Vector2(CurrentScale);
Size = new Vector2(1 / CurrentScale);
base.Update();
}
}
2019-01-04 12:29:37 +08:00
[BackgroundDependencyLoader]
private void load(OsuConfigManager config, ISafeArea safeArea)
2019-01-04 12:29:37 +08:00
{
scalingMode = config.GetBindable<ScalingMode>(OsuSetting.Scaling);
scalingMode.ValueChanged += _ => Scheduler.AddOnce(updateSize);
2019-01-04 12:29:37 +08:00
sizeX = config.GetBindable<float>(OsuSetting.ScalingSizeX);
sizeX.ValueChanged += _ => Scheduler.AddOnce(updateSize);
2019-01-04 12:29:37 +08:00
sizeY = config.GetBindable<float>(OsuSetting.ScalingSizeY);
sizeY.ValueChanged += _ => Scheduler.AddOnce(updateSize);
2019-01-04 12:29:37 +08:00
posX = config.GetBindable<float>(OsuSetting.ScalingPositionX);
posX.ValueChanged += _ => Scheduler.AddOnce(updateSize);
2019-01-04 12:29:37 +08:00
posY = config.GetBindable<float>(OsuSetting.ScalingPositionY);
posY.ValueChanged += _ => Scheduler.AddOnce(updateSize);
safeAreaPadding = safeArea.SafeAreaPadding.GetBoundCopy();
safeAreaPadding.BindValueChanged(_ => Scheduler.AddOnce(updateSize));
2019-01-04 12:29:37 +08:00
}
protected override void LoadComplete()
{
base.LoadComplete();
updateSize();
2019-01-04 14:28:35 +08:00
sizableContainer.FinishTransforms();
2019-01-04 12:29:37 +08:00
}
2019-02-21 17:56:34 +08:00
private bool requiresBackgroundVisible => (scalingMode.Value == ScalingMode.Everything || scalingMode.Value == ScalingMode.ExcludeOverlays) && (sizeX.Value != 1 || sizeY.Value != 1);
2019-01-04 12:29:37 +08:00
private void updateSize()
{
if (targetMode == ScalingMode.Everything)
{
// the top level scaling container manages the background to be displayed while scaling.
if (requiresBackgroundVisible)
{
if (backgroundStack == null)
{
AddInternal(backgroundStack = new BackgroundScreenStack
2019-01-04 12:29:37 +08:00
{
Colour = OsuColour.Gray(0.1f),
Alpha = 0,
Depth = float.MaxValue
});
2019-03-25 12:38:50 +08:00
backgroundStack.Push(new ScalingBackgroundScreen());
}
2022-03-02 19:25:34 +08:00
backgroundStack.FadeIn(duration);
2019-01-04 12:29:37 +08:00
}
else
2022-03-02 19:25:34 +08:00
backgroundStack?.FadeOut(duration);
2019-01-04 12:29:37 +08:00
}
2022-03-02 19:33:28 +08:00
RectangleF targetRect = new RectangleF(Vector2.Zero, Vector2.One);
2022-03-02 19:33:28 +08:00
if (customRect != null)
{
2022-03-02 19:33:28 +08:00
sizableContainer.RelativePositionAxes = customRectIsRelativePosition ? Axes.Both : Axes.None;
2022-03-02 19:33:28 +08:00
targetRect = customRect.Value;
}
else if (targetMode == null || scalingMode.Value == targetMode)
{
sizableContainer.RelativePositionAxes = Axes.Both;
Vector2 scale = new Vector2(sizeX.Value, sizeY.Value);
Vector2 pos = new Vector2(posX.Value, posY.Value) * (Vector2.One - scale);
2022-03-02 19:33:28 +08:00
targetRect = new RectangleF(pos, scale);
}
2019-01-04 12:29:37 +08:00
2022-03-02 19:33:28 +08:00
bool requiresMasking = targetRect.Size != Vector2.One
// For the top level scaling container, for now we apply masking if safe areas are in use.
// In the future this can likely be removed as more of the actual UI supports overflowing into the safe areas.
|| (targetMode == ScalingMode.Everything && safeAreaPadding.Value.Total != Vector2.Zero);
2019-01-04 12:29:37 +08:00
if (requiresMasking)
sizableContainer.Masking = true;
2022-03-02 19:33:28 +08:00
sizableContainer.MoveTo(targetRect.Location, duration, Easing.OutQuart);
sizableContainer.ResizeTo(targetRect.Size, duration, Easing.OutQuart);
2022-03-02 19:25:34 +08:00
// Of note, this will not work great in the case of nested ScalingContainers where multiple are applying corner radius.
// Masking and corner radius should likely only be applied at one point in the full game stack to fix this.
// An example of how this can occur is when the skin editor is visible and the game screen scaling is set to "Everything".
2022-03-02 19:25:34 +08:00
sizableContainer.TransformTo(nameof(CornerRadius), requiresMasking ? corner_radius : 0, duration, requiresMasking ? Easing.OutQuart : Easing.None)
.OnComplete(_ => { sizableContainer.Masking = requiresMasking; });
2019-01-04 12:29:37 +08:00
}
2019-03-25 12:38:50 +08:00
private class ScalingBackgroundScreen : BackgroundScreenDefault
{
protected override bool AllowStoryboardBackground => false;
public override void OnEntering(ScreenTransitionEvent e)
{
this.FadeInFromZero(4000, Easing.OutQuint);
}
}
private class SizeableAlwaysInputContainer : Container
{
[Resolved]
private GameHost host { get; set; }
[Resolved]
private ISafeArea safeArea { get; set; }
private readonly bool confineHostCursor;
private readonly LayoutValue cursorRectCache = new LayoutValue(Invalidation.RequiredParentSizeToFit);
public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
/// <summary>
/// Container used for sizing/positioning purposes in <see cref="ScalingContainer"/>. Always receives mouse input.
/// </summary>
/// <param name="confineHostCursor">Whether to confine the host cursor to the draw area of this container.</param>
/// <remarks>Cursor confinement will abide by the <see cref="OsuSetting.ConfineMouseMode"/> setting.</remarks>
public SizeableAlwaysInputContainer(bool confineHostCursor)
{
RelativeSizeAxes = Axes.Both;
this.confineHostCursor = confineHostCursor;
if (confineHostCursor)
AddLayout(cursorRectCache);
}
protected override void Update()
{
base.Update();
if (confineHostCursor && !cursorRectCache.IsValid)
{
updateHostCursorConfineRect();
cursorRectCache.Validate();
}
}
private void updateHostCursorConfineRect()
{
if (host.Window == null) return;
bool coversWholeScreen = Size == Vector2.One && safeArea.SafeAreaPadding.Value.Total == Vector2.Zero;
host.Window.CursorConfineRect = coversWholeScreen ? (RectangleF?)null : ToScreenSpace(DrawRectangle).AABBFloat;
}
}
2019-01-04 12:29:37 +08:00
}
}