Fix inflation amount being added to the box

[kennytram]

Resolving #25049

Bug that's occurring in the current 'master' branch of osu:

After my fix:

Hotreload:
'hotreload gif'

My thought process:
Based on my understanding of the intended behavior, we want the pink box to be inflated by a constant value of SkinSelectionHandler.INFLATE_SIZE. However, it seems the amount of inflation increases as we scale the element to a larger size.

In my attempt to address this issue, I initially tried to look for a way to perform the inflation operation in screen space rather than local space (as @bdach suggested). However, I encountered a problem: the inflate function only works for RectangleF (and RectangleI) class objects. After converting the rectangle to a Quad using ToScreenSpace, there are no ToSpace operation in Drawable that can convert it back to a rectangle.

I decided to take a different approach by using rotation matrix after offsetting the initial position by SkinSelectionHandler.INFLATE_SIZE. This approach helps us obtain the new box.position value.

With my current code, the pink box is slightly larger than the element by a small, constant value and it doesn't get relatively larger when scaled. In my eyes, this is an appropriate fix to meet the intended behavior.

Let me know if there are any issues with my approach to solving this problem.

[bdach]

I suppose this works, but I still yearn for a simpler solution than this...

Something like the below appears to work as well.

diff --git a/osu.Game/Overlays/SkinEditor/SkinBlueprint.cs b/osu.Game/Overlays/SkinEditor/SkinBlueprint.cs
index 01cd3d97e0..8c1b104b6d 100644
--- a/osu.Game/Overlays/SkinEditor/SkinBlueprint.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinBlueprint.cs
@@ -136,9 +136,12 @@ protected override void Update()
         {
             base.Update();
 
+            Vector2 screenSpaceFactor = Vector2.Divide(drawable.DrawSize, drawable.ScreenSpaceDrawQuad.Size);
+            if (float.IsNaN(screenSpaceFactor.X)) screenSpaceFactor.X = 1;
+            if (float.IsNaN(screenSpaceFactor.Y)) screenSpaceFactor.Y = 1;
             drawableQuad = drawable.ToScreenSpace(
                 drawable.DrawRectangle
-                        .Inflate(SkinSelectionHandler.INFLATE_SIZE));
+                        .Inflate(SkinSelectionHandler.INFLATE_SIZE * screenSpaceFactor));
 
             var localSpaceQuad = ToLocalSpace(drawableQuad);
 

The idea here is if you can conjure up a scale factor that converts screen-space pixels to drawable-space units, then you can apply that factor to get screen-space pixels out of any drawable-space quad.

I prefer my version because contrary to this change, it (a) handles less edge cases and (b) makes less implicit assumptions (i.e. this version of the change assumes it can safely use drawable.Rotation, but that's the local rotation of the drawable, that potentially does not accommodate for the drawable being nested in something else that also rotates, at which point it will be wrong). But I'll wait for a second check.

[Tom94]

I'd recommend getting the scale factor directly from the matrix (similar to how Sprite handles inflation) via

Vector2 scale = drawable.DrawInfo.MatrixInverse.ExtractScale().Xy;