Revert agnostic based approach and base on wrap mode instead

osu.Framework/Graphics/OpenGL/Textures/TextureGLAtlas.cs

···
 
             var data = upload.Data;
 
-            uploadCornerPadding(data, middleBounds, actualPadding);
-            uploadHorizontalPadding(data, middleBounds, actualPadding);
-            uploadVerticalPadding(data, middleBounds, actualPadding);
+            uploadCornerPadding(data, middleBounds, actualPadding, wrapModeS != WrapMode.None && wrapModeT != WrapMode.None);
+            uploadHorizontalPadding(data, middleBounds, actualPadding, wrapModeS != WrapMode.None);
+            uploadVerticalPadding(data, middleBounds, actualPadding, wrapModeT != WrapMode.None);
 
             // Upload the middle part of the texture
             // For a texture atlas, we don't care about opacity, so we avoid
···
             base.SetData(upload, wrapModeS, wrapModeT, Opacity.Mixed);
         }
 
-        private void uploadVerticalPadding(ReadOnlySpan<Rgba32> upload, RectangleI middleBounds, int actualPadding)
+        private void uploadVerticalPadding(ReadOnlySpan<Rgba32> upload, RectangleI middleBounds, int actualPadding, bool fillOpaque)
         {
             RectangleI[] sideBoundsArray =
             {
···
                             Rgba32 pixel = upload[index + x];
                             allTransparent &= checkEdgeRGB(pixel);
 
-                            transferBorderPixel(ref data[y * sideBounds.Width + x], pixel);
+                            transferBorderPixel(ref data[y * sideBounds.Width + x], pixel, fillOpaque);
                         }
                     }
 
···
             }
         }
 
-        private void uploadHorizontalPadding(ReadOnlySpan<Rgba32> upload, RectangleI middleBounds, int actualPadding)
+        private void uploadHorizontalPadding(ReadOnlySpan<Rgba32> upload, RectangleI middleBounds, int actualPadding, bool fillOpaque)
         {
             RectangleI[] sideBoundsArray =
             {
···
 
                             allTransparent &= checkEdgeRGB(pixel);
 
-                            transferBorderPixel(ref data[y * sideBounds.Width + x], pixel);
+                            transferBorderPixel(ref data[y * sideBounds.Width + x], pixel, fillOpaque);
                         }
                     }
 
···
             }
         }
 
-        private void uploadCornerPadding(ReadOnlySpan<Rgba32> upload, RectangleI middleBounds, int actualPadding)
+        private void uploadCornerPadding(ReadOnlySpan<Rgba32> upload, RectangleI middleBounds, int actualPadding, bool fillOpaque)
         {
             RectangleI[] cornerBoundsArray =
             {
···
                     var data = cornerUpload.RawData;
 
                     for (int j = 0; j < nCornerPixels; ++j)
-                        transferBorderPixel(ref data[j], pixel);
+                        transferBorderPixel(ref data[j], pixel, fillOpaque);
 
                     // For a texture atlas, we don't care about opacity, so we avoid
                     // any computations related to it by assuming it to be mixed.
···
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void transferBorderPixel(ref Rgba32 dest, Rgba32 source)
+        private void transferBorderPixel(ref Rgba32 dest, Rgba32 source, bool fillOpaque)
         {
             dest.R = source.R;
             dest.G = source.G;
             dest.B = source.B;
-            // in the case the adjacent pixel is solid, we presume that it should interpolate to itself (creating a hard edge).
-            // in the case of pixels with transparency it makes more sense to interpolate to nothing.
-            dest.A = source.A < 255 ? (byte)0 : source.A;
+            dest.A = fillOpaque ? source.A : (byte)0;
         }
 
         /// <summary>