Decompose PremultipliedColour structure into RGBA fields

Author: frenzibyte

osu.Framework/Graphics/Colour/PremultipliedColour.cs

@@ -3,42 +3,62 @@
 
 using System;
 using osuTK.Graphics;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace osu.Framework.Graphics.Colour
 {
     /// <summary>
-    /// Represents a <see cref="Color4"/> provided in premultiplied-alpha form.
+    /// Represents a structure for containing a "premultiplied colour".
     /// </summary>
     public readonly struct PremultipliedColour : IEquatable<PremultipliedColour>
     {
         /// <summary>
-        /// The <see cref="Color4"/> after alpha multiplication.
+        /// The red component of this colour multiplied by the value of <see cref="Occlusion"/>.
         /// </summary>
-        public readonly Color4 Premultiplied;
+        public readonly float PremultipliedR;
 
-        private PremultipliedColour(Color4 premultiplied)
-        {
-            Premultiplied = premultiplied;
-        }
+        /// <summary>
+        /// The green component of this colour multiplied by the value of <see cref="Occlusion"/>.
+        /// </summary>
+        public readonly float PremultipliedG;
 
         /// <summary>
-        /// Creates a <see cref="PremultipliedColour"/> from a straight-alpha colour.
+        /// The blue component of this colour multiplied by the value of <see cref="Occlusion"/>.
         /// </summary>
-        /// <param name="colour">The straight-alpha colour.</param>
-        public static PremultipliedColour FromStraight(Color4 colour)
+        public readonly float PremultipliedB;
+
+        /// <summary>
+        /// The alpha component of this colour, often referred to as "occlusion" instead of "opacity" in the context of premultiplied colours.
+        /// </summary>
+        public readonly float Occlusion;
+
+        public PremultipliedColour(float premultipliedR, float premultipliedG, float premultipliedB, float occlusion)
         {
-            colour.R *= colour.A;
-            colour.G *= colour.A;
-            colour.B *= colour.A;
-            return new PremultipliedColour(colour);
+            PremultipliedR = premultipliedR;
+            PremultipliedG = premultipliedG;
+            PremultipliedB = premultipliedB;
+            Occlusion = occlusion;
         }
 
         /// <summary>
-        /// Creates a <see cref="PremultipliedColour"/> from a premultiplied-alpha colour.
+        /// Creates a <see cref="Rgba32"/> containing the premultiplied components of this colour.
         /// </summary>
-        /// <param name="colour">The premultiplied-alpha colour.</param>
-        public static PremultipliedColour FromPremultiplied(Color4 colour) => new PremultipliedColour(colour);
+        public Rgba32 ToPremultipliedRgba32() => new Rgba32(PremultipliedR, PremultipliedG, PremultipliedB, Occlusion);
+
+        /// <summary>
+        /// Creates a <see cref="PremultipliedColour"/> from a straight-alpha colour.
+        /// </summary>
+        /// <param name="colour">The straight-alpha colour.</param>
+        public static PremultipliedColour FromStraight(Color4 colour) => new PremultipliedColour(
+            colour.R * colour.A,
+            colour.G * colour.A,
+            colour.B * colour.A,
+            colour.A);
 
-        public bool Equals(PremultipliedColour other) => Premultiplied.Equals(other.Premultiplied);
+        public bool Equals(PremultipliedColour other)
+            => PremultipliedR == other.PremultipliedR &&
+               PremultipliedG == other.PremultipliedG &&
+               PremultipliedB == other.PremultipliedB &&
+               Occlusion == other.Occlusion;
     }
 }

osu.Framework/Graphics/OpenGL/GLRenderer.cs

@@ -239,7 +239,7 @@ protected override void DeleteFrameBufferImplementation(IFrameBuffer frameBuffer
         protected override void ClearImplementation(ClearInfo clearInfo)
         {
             if (!clearInfo.Colour.Equals(CurrentClearInfo.Colour))
-                GL.ClearColor(clearInfo.Colour.Premultiplied);
+                GL.ClearColor(new Color4(clearInfo.Colour.PremultipliedR, clearInfo.Colour.PremultipliedG, clearInfo.Colour.PremultipliedB, clearInfo.Colour.Occlusion));
 
             if (clearInfo.Depth != CurrentClearInfo.Depth)
             {

osu.Framework/Graphics/Shaders/Types/UniformColour.cs

@@ -3,7 +3,6 @@
 
 using System.Runtime.InteropServices;
 using osu.Framework.Graphics.Colour;
-using osuTK.Graphics;
 
 namespace osu.Framework.Graphics.Shaders.Types
 {
@@ -16,16 +15,16 @@ public record struct UniformColour
         public UniformVector4 Value;
 
         public static implicit operator PremultipliedColour(UniformColour value)
-            => PremultipliedColour.FromPremultiplied(new Color4(value.Value.X, value.Value.Y, value.Value.Z, value.Value.W));
+            => new PremultipliedColour(value.Value.X, value.Value.Y, value.Value.Z, value.Value.W);
 
         public static implicit operator UniformColour(PremultipliedColour value) => new UniformColour
         {
             Value =
             {
-                X = value.Premultiplied.R,
-                Y = value.Premultiplied.G,
-                Z = value.Premultiplied.B,
-                W = value.Premultiplied.A,
+                X = value.PremultipliedR,
+                Y = value.PremultipliedG,
+                Z = value.PremultipliedB,
+                W = value.Occlusion,
             }
         };
     }

osu.Framework/Graphics/Textures/PremultipliedImage.cs

@@ -27,7 +27,7 @@ public PremultipliedImage(int width, int height)
         }
 
         public PremultipliedImage(int width, int height, PremultipliedColour colour)
-            : this(new Image<Rgba32>(width, height, new Rgba32(colour.Premultiplied.R, colour.Premultiplied.G, colour.Premultiplied.B, colour.Premultiplied.A)))
+            : this(new Image<Rgba32>(width, height, colour.ToPremultipliedRgba32()))
         {
         }
 

osu.Framework/Graphics/Veldrid/Pipelines/GraphicsPipeline.cs

@@ -63,7 +63,7 @@ public override void Begin()
         /// <param name="clearInfo">The clearing parameters.</param>
         public void Clear(ClearInfo clearInfo)
         {
-            Commands.ClearColorTarget(0, clearInfo.Colour.Premultiplied.ToRgbaFloat());
+            Commands.ClearColorTarget(0, clearInfo.Colour.ToPremultipliedRgbaFloat());
 
             var framebuffer = currentFrameBuffer?.Framebuffer ?? Device.SwapchainFramebuffer;
             if (framebuffer.DepthTarget != null)

osu.Framework/Graphics/Veldrid/VeldridExtensions.cs

@@ -7,10 +7,10 @@
 using System.Runtime.InteropServices;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Rendering;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Logging;
-using osuTK.Graphics;
 using SharpGen.Runtime;
 using Veldrid;
 using Veldrid.MetalBindings;
@@ -27,7 +27,8 @@ namespace osu.Framework.Graphics.Veldrid
 {
     internal static class VeldridExtensions
     {
-        public static RgbaFloat ToRgbaFloat(this Color4 colour) => new RgbaFloat(colour.R, colour.G, colour.B, colour.A);
+        public static RgbaFloat ToPremultipliedRgbaFloat(this PremultipliedColour colour)
+            => new RgbaFloat(colour.PremultipliedR, colour.PremultipliedG, colour.PremultipliedB, colour.Occlusion);
 
         public static BlendFactor ToBlendFactor(this BlendingType type)
         {