Moved blending factors into BlendingParameters.

osu.Framework.Tests/Visual/Audio/TestSceneSamples.cs

···
                 Size = new Vector2(4, notes);
                 Colour = Color4.SkyBlue;
 
-                Blending = BlendingMode.Additive;
+                Blending = BlendingParameters.Additive;
 
                 InternalChildren = new Drawable[]
                 {

osu.Framework.Tests/Visual/Audio/TestSceneTrack.cs

···
                                 Anchor = Anchor.BottomLeft,
                                 Origin = Anchor.Centre,
                                 Icon = FontAwesome.Solid.CircleNotch,
-                                Blending = BlendingMode.Additive,
+                                Blending = BlendingParameters.Additive,
                                 Colour = Color4.White,
                                 Alpha = 0.2f,
                                 Scale = new Vector2(20),

osu.Framework.Tests/Visual/Containers/TestSceneFrontToBackBox.cs

···
         [Test]
         public void TestOpaqueBoxWithAdditiveBlending()
         {
-            createBox(b => b.Blending = BlendingMode.Additive);
+            createBox(b => b.Blending = BlendingParameters.Additive);
             AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);
         }
 
···
         {
             createBox(b =>
             {
-                b.Blending = BlendingMode.Additive;
+                b.Blending = BlendingParameters.Additive;
                 b.Alpha = 0.5f;
             });
 
···
         {
             createBox(b =>
             {
-                b.Blending = new BlendingParameters
-                {
-                    Mode = BlendingMode.Inherit,
-                    AlphaEquation = BlendingEquation.Inherit,
-                    RGBEquation = equationMode
-                };
+                var blending = BlendingParameters.Inherit;
+                blending.RGBEquation = equationMode;
+                b.Blending = blending;
             });
 
             AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);
···
         {
             createBox(b =>
             {
-                b.Blending = new BlendingParameters
-                {
-                    Mode = BlendingMode.Inherit,
-                    AlphaEquation = equationMode,
-                    RGBEquation = BlendingEquation.Inherit
-                };
+                var blending = BlendingParameters.Inherit;
+                blending.AlphaEquation = equationMode;
+                b.Blending = blending;
             });
 
             AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);

osu.Framework.Tests/Visual/Drawables/TestSceneBlending.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
···
 using osu.Framework.Logging;
 using osuTK;
 using osuTK.Graphics;
-using osuTK.Graphics.ES30;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
     public class TestSceneBlending : FrameworkTestScene
     {
-        private readonly Dropdown<BlendingMode> colourModeDropdown;
+        private readonly Dropdown<string> colourModeDropdown;
         private readonly Dropdown<BlendingEquation> colourEquation;
         private readonly Dropdown<BlendingEquation> alphaEquation;
         private readonly BufferedContainer foregroundContainer;
···
         private readonly FillFlowContainer blendingAlphaSrcContainer;
         private readonly FillFlowContainer blendingAlphaDestContainer;
 
-        private readonly Dropdown<BlendingFactorSrc> blendingSrcDropdown;
-        private readonly Dropdown<BlendingFactorDest> blendingDestDropdown;
-        private readonly Dropdown<BlendingFactorSrc> blendingAlphaSrcDropdown;
-        private readonly Dropdown<BlendingFactorDest> blendingAlphaDestDropdown;
+        private readonly Dropdown<BlendingType> blendingSrcDropdown;
+        private readonly Dropdown<BlendingType> blendingDestDropdown;
+        private readonly Dropdown<BlendingType> blendingAlphaSrcDropdown;
+        private readonly Dropdown<BlendingType> blendingAlphaDestDropdown;
 
         private readonly FillFlowContainer settingsBox;
+
+        private readonly Dictionary<string, BlendingParameters> blendingModes = new Dictionary<string, BlendingParameters>
+        {
+            { "Inherit", BlendingParameters.Inherit },
+            { "Additive", BlendingParameters.Additive },
+            { "Mixture", BlendingParameters.Mixture },
+            { "Custom", BlendingParameters.Mixture },
+        };
 
         private bool inCustomMode;
 
···
                             Children = new Drawable[]
                             {
                                 new SpriteText { Text = "Blending mode" },
-                                colourModeDropdown = new BasicDropdown<BlendingMode> { Width = 200 }
+                                colourModeDropdown = new BasicDropdown<string> { Width = 200 }
                             }
                         },
                         new FillFlowContainer
···
                 Children = new Drawable[]
                 {
                     new SpriteText { Text = "Custom: Source" },
-                    blendingSrcDropdown = new BasicDropdown<BlendingFactorSrc> { Width = 200 }
+                    blendingSrcDropdown = new BasicDropdown<BlendingType> { Width = 200 }
                 },
             };
 
···
                 Children = new Drawable[]
                 {
                     new SpriteText { Text = "Custom: Destination" },
-                    blendingDestDropdown = new BasicDropdown<BlendingFactorDest> { Width = 200 }
+                    blendingDestDropdown = new BasicDropdown<BlendingType> { Width = 200 }
                 },
             };
 
···
                 Children = new Drawable[]
                 {
                     new SpriteText { Text = "Custom: Alpha Source" },
-                    blendingAlphaSrcDropdown = new BasicDropdown<BlendingFactorSrc> { Width = 200 }
+                    blendingAlphaSrcDropdown = new BasicDropdown<BlendingType> { Width = 200 }
                 },
             };
 
···
                 Children = new Drawable[]
                 {
                     new SpriteText { Text = "Custom: Alpha Destination" },
-                    blendingAlphaDestDropdown = new BasicDropdown<BlendingFactorDest> { Width = 200 }
+                    blendingAlphaDestDropdown = new BasicDropdown<BlendingType> { Width = 200 }
                 },
             };
 
-            colourModeDropdown.Items = (BlendingMode[])Enum.GetValues(typeof(BlendingMode));
+            colourModeDropdown.Items = blendingModes.Keys;
             colourEquation.Items = (BlendingEquation[])Enum.GetValues(typeof(BlendingEquation));
             alphaEquation.Items = (BlendingEquation[])Enum.GetValues(typeof(BlendingEquation));
 
-            blendingSrcDropdown.Items = (BlendingFactorSrc[])Enum.GetValues(typeof(BlendingFactorSrc));
-            blendingDestDropdown.Items = (BlendingFactorDest[])Enum.GetValues(typeof(BlendingFactorDest));
-            blendingAlphaSrcDropdown.Items = (BlendingFactorSrc[])Enum.GetValues(typeof(BlendingFactorSrc));
-            blendingAlphaDestDropdown.Items = (BlendingFactorDest[])Enum.GetValues(typeof(BlendingFactorDest));
+            blendingSrcDropdown.Items = (BlendingType[])Enum.GetValues(typeof(BlendingType));
+            blendingDestDropdown.Items = (BlendingType[])Enum.GetValues(typeof(BlendingType));
+            blendingAlphaSrcDropdown.Items = (BlendingType[])Enum.GetValues(typeof(BlendingType));
+            blendingAlphaDestDropdown.Items = (BlendingType[])Enum.GetValues(typeof(BlendingType));
 
-            colourModeDropdown.Current.Value = foregroundContainer.Blending.Mode;
+            colourModeDropdown.Current.Value = "Mixture";
             colourEquation.Current.Value = foregroundContainer.Blending.RGBEquation;
             alphaEquation.Current.Value = foregroundContainer.Blending.AlphaEquation;
 
-            blendingSrcDropdown.Current.Value = BlendingFactorSrc.SrcAlpha;
-            blendingDestDropdown.Current.Value = BlendingFactorDest.OneMinusSrcAlpha;
-            blendingAlphaSrcDropdown.Current.Value = BlendingFactorSrc.One;
-            blendingAlphaDestDropdown.Current.Value = BlendingFactorDest.One;
+            blendingSrcDropdown.Current.Value = BlendingType.SrcAlpha;
+            blendingDestDropdown.Current.Value = BlendingType.OneMinusSrcAlpha;
+            blendingAlphaSrcDropdown.Current.Value = BlendingType.One;
+            blendingAlphaDestDropdown.Current.Value = BlendingType.One;
 
             colourModeDropdown.Current.ValueChanged += v => updateBlending();
             colourEquation.Current.ValueChanged += v => updateBlending();
···
 
         private void updateBlending()
         {
-            var newBlending = new BlendingParameters
-            {
-                Mode = colourModeDropdown.Current.Value,
-                RGBEquation = colourEquation.Current.Value,
-                AlphaEquation = alphaEquation.Current.Value
-            };
-
-            if (colourModeDropdown.Current.Value == BlendingMode.Custom)
+            if (colourModeDropdown.Current.Value == "Custom")
             {
                 if (!inCustomMode)
                     switchToCustomBlending();
 
-                newBlending.BlendingFactors = new BlendingFactors(blendingSrcDropdown.Current.Value, blendingDestDropdown.Current.Value,
-                    blendingAlphaSrcDropdown.Current.Value, blendingAlphaDestDropdown.Current.Value);
+                var blending = new BlendingParameters
+                {
+                    Source = blendingSrcDropdown.Current.Value,
+                    Destination = blendingDestDropdown.Current.Value,
+                    SourceAlpha = blendingAlphaSrcDropdown.Current.Value,
+                    DestinationAlpha = blendingAlphaDestDropdown.Current.Value,
+                    RGBEquation = colourEquation.Current.Value,
+                    AlphaEquation = alphaEquation.Current.Value
+                };
+
+                Logger.Log("Changed blending mode to: " + blending, LoggingTarget.Runtime, LogLevel.Debug);
+
+                foregroundContainer.Blending = blending;
 
                 inCustomMode = true;
             }
···
                 if (inCustomMode)
                     switchOffCustomBlending();
 
-                inCustomMode = false;
-            }
+                var blending = blendingModes[colourModeDropdown.Current.Value];
+
+                blending.RGBEquation = colourEquation.Current.Value;
+                blending.AlphaEquation = alphaEquation.Current.Value;
 
-            Logger.Log("Changed blending mode to: " + newBlending, LoggingTarget.Runtime, LogLevel.Debug);
+                Logger.Log("Changed blending mode to: " + blending, LoggingTarget.Runtime, LogLevel.Debug);
 
-            foregroundContainer.Blending = newBlending;
+                foregroundContainer.Blending = blending;
+
+                inCustomMode = false;
+            }
         }
 
         private class GradientPart : Box

osu.Framework/Graphics/BlendingParameters.cs

···
     /// </summary>
     public struct BlendingParameters : IEquatable<BlendingParameters>
     {
-        private BlendingFactors blendingFactors;
-        private BlendingMode mode;
+        #region Public Members
 
         /// <summary>
-        /// The blending factors that represent the current blending mode.
+        /// The blending factor for the source color of the blend.
         /// </summary>
-        public BlendingFactors BlendingFactors
-        {
-            get => blendingFactors;
-            set
-            {
-                blendingFactors = value;
-                mode = BlendingMode.Custom;
-            }
-        }
+        public BlendingType Source;
 
         /// <summary>
-        /// Gets or sets <see cref="BlendingMode"/> to use.
+        /// The blending factor for the destination color of the blend.
         /// </summary>
-        public BlendingMode Mode
-        {
-            get => mode;
-            set
-            {
-                mode = value;
-                if (mode != BlendingMode.Custom)
-                    blendingFactors = new BlendingFactors(value);
-            }
-        }
+        public BlendingType Destination;
+
+        /// <summary>
+        /// The blending factor for the source alpha of the blend.
+        /// </summary>
+        public BlendingType SourceAlpha;
+
+        /// <summary>
+        /// The blending factor for the destination alpha of the blend.
+        /// </summary>
+        public BlendingType DestinationAlpha;
 
         /// <summary>
         /// Gets or sets the <see cref="BlendingEquation"/> to use for the RGB components of the blend.
···
         /// </summary>
         public BlendingEquation AlphaEquation;
 
+        #endregion
+
+        #region Default Blending Parameter Types
+
+        public static BlendingParameters None => new BlendingParameters
+        {
+            Source = BlendingType.One,
+            Destination = BlendingType.Zero,
+            SourceAlpha = BlendingType.One,
+            DestinationAlpha = BlendingType.Zero,
+            RGBEquation = BlendingEquation.Add,
+            AlphaEquation = BlendingEquation.Add,
+        };
+
+        public static BlendingParameters Inherit => new BlendingParameters
+        {
+            Source = BlendingType.Inherit,
+            Destination = BlendingType.Inherit,
+            SourceAlpha = BlendingType.Inherit,
+            DestinationAlpha = BlendingType.Inherit,
+            RGBEquation = BlendingEquation.Inherit,
+            AlphaEquation = BlendingEquation.Inherit,
+        };
+
+        public static BlendingParameters Mixture => new BlendingParameters
+        {
+            Source = BlendingType.SrcAlpha,
+            Destination = BlendingType.OneMinusSrcAlpha,
+            SourceAlpha = BlendingType.One,
+            DestinationAlpha = BlendingType.One,
+            RGBEquation = BlendingEquation.Add,
+            AlphaEquation = BlendingEquation.Add,
+        };
+
+        public static BlendingParameters Additive => new BlendingParameters
+        {
+            Source = BlendingType.SrcAlpha,
+            Destination = BlendingType.One,
+            SourceAlpha = BlendingType.One,
+            DestinationAlpha = BlendingType.One,
+            RGBEquation = BlendingEquation.Add,
+            AlphaEquation = BlendingEquation.Add,
+        };
+
+        #endregion
+
+        #region GL Type Getters
+
         /// <summary>
         /// Gets the <see cref="BlendEquationMode"/> for the currently specified RGB Equation.
         /// </summary>
···
         /// </summary>
         public BlendEquationMode AlphaEquationMode => translateEquation(AlphaEquation);
 
+        /// <summary>
+        /// Gets the <see cref="BlendingFactorSrc"/> for the currently specified source blending mode.
+        /// </summary>
+        public BlendingFactorSrc SourceBlendingFactor => translateBlendingFactorSrc(Source);
+
+        /// <summary>
+        /// Gets the <see cref="BlendingFactorDest"/> for the currently specified destination blending mode.
+        /// </summary>
+        public BlendingFactorDest DestinationBlendingFactor => translateBlendingFactorDest(Destination);
+
+        /// <summary>
+        /// Gets the <see cref="BlendingFactorSrc"/> for the currently specified source alpha mode.
+        /// </summary>
+        public BlendingFactorSrc SourceAlphaBlendingFactor => translateBlendingFactorSrc(SourceAlpha);
+
+        /// <summary>
+        /// Gets the <see cref="BlendingFactorDest"/> for the currently specified destination alpha mode.
+        /// </summary>
+        public BlendingFactorDest DestinationAlphaBlendingFactor => translateBlendingFactorDest(DestinationAlpha);
+
+        private static BlendingFactorSrc translateBlendingFactorSrc(BlendingType factor)
+        {
+            switch (factor)
+            {
+                case BlendingType.ConstantAlpha:
+                    return BlendingFactorSrc.ConstantAlpha;
+
+                case BlendingType.ConstantColor:
+                    return BlendingFactorSrc.ConstantColor;
+
+                case BlendingType.DstAlpha:
+                    return BlendingFactorSrc.DstAlpha;
+
+                case BlendingType.DstColor:
+                    return BlendingFactorSrc.DstColor;
+
+                case BlendingType.One:
+                    return BlendingFactorSrc.One;
+
+                case BlendingType.OneMinusConstantAlpha:
+                    return BlendingFactorSrc.OneMinusConstantAlpha;
+
+                case BlendingType.OneMinusConstantColor:
+                    return BlendingFactorSrc.OneMinusConstantColor;
+
+                case BlendingType.OneMinusDstAlpha:
+                    return BlendingFactorSrc.OneMinusDstAlpha;
+
+                case BlendingType.OneMinusDstColor:
+                    return BlendingFactorSrc.OneMinusDstColor;
+
+                case BlendingType.OneMinusSrcAlpha:
+                    return BlendingFactorSrc.OneMinusSrcColor;
+
+                case BlendingType.SrcAlpha:
+                    return BlendingFactorSrc.SrcAlpha;
+
+                case BlendingType.SrcAlphaSaturate:
+                    return BlendingFactorSrc.SrcAlphaSaturate;
+
+                case BlendingType.SrcColor:
+                    return BlendingFactorSrc.SrcColor;
+
+                default:
+                case BlendingType.Zero:
+                    return BlendingFactorSrc.Zero;
+            }
+        }
+
+        private static BlendingFactorDest translateBlendingFactorDest(BlendingType factor)
+        {
+            switch (factor)
+            {
+                case BlendingType.ConstantAlpha:
+                    return BlendingFactorDest.ConstantAlpha;
+
+                case BlendingType.ConstantColor:
+                    return BlendingFactorDest.ConstantColor;
+
+                case BlendingType.DstAlpha:
+                    return BlendingFactorDest.DstAlpha;
+
+                case BlendingType.DstColor:
+                    return BlendingFactorDest.DstColor;
+
+                case BlendingType.One:
+                    return BlendingFactorDest.One;
+
+                case BlendingType.OneMinusConstantAlpha:
+                    return BlendingFactorDest.OneMinusConstantAlpha;
+
+                case BlendingType.OneMinusConstantColor:
+                    return BlendingFactorDest.OneMinusConstantColor;
+
+                case BlendingType.OneMinusDstAlpha:
+                    return BlendingFactorDest.OneMinusDstAlpha;
+
+                case BlendingType.OneMinusDstColor:
+                    return BlendingFactorDest.OneMinusDstColor;
+
+                case BlendingType.OneMinusSrcAlpha:
+                    return BlendingFactorDest.OneMinusSrcAlpha;
+
+                case BlendingType.OneMinusSrcColor:
+                    return BlendingFactorDest.OneMinusSrcColor;
+
+                case BlendingType.SrcAlpha:
+                    return BlendingFactorDest.SrcAlpha;
+
+                case BlendingType.SrcAlphaSaturate:
+                    return BlendingFactorDest.SrcAlphaSaturate;
+
+                case BlendingType.SrcColor:
+                    return BlendingFactorDest.SrcColor;
+
+                default:
+                case BlendingType.Zero:
+                    return BlendingFactorDest.Zero;
+            }
+        }
+
         private static BlendEquationMode translateEquation(BlendingEquation blendingEquation)
         {
             switch (blendingEquation)
···
             }
         }
 
-        public BlendingParameters(BlendingMode mode)
+        #endregion
+
+        /// <summary>
+        /// Copy all properties that are marked as inherited from a parent <see cref="BlendingParameters"/> object.
+        /// </summary>
+        /// <param name="parent">The parent <see cref="BlendingParameters"/> from which to copy inherited properties.</param>
+        public void CopyFromParent(BlendingParameters parent)
         {
-            RGBEquation = default;
-            AlphaEquation = default;
-            blendingFactors = new BlendingFactors(mode);
-            this.mode = mode;
-        }
+            if (Source == BlendingType.Inherit)
+                Source = parent.Source;
+
+            if (Destination == BlendingType.Inherit)
+                Destination = parent.Destination;
 
-        public static implicit operator BlendingParameters(BlendingMode blendingMode) => new BlendingParameters { Mode = blendingMode };
+            if (SourceAlpha == BlendingType.Inherit)
+                SourceAlpha = parent.SourceAlpha;
 
-        public static implicit operator BlendingParameters(BlendingEquation blendingEquation) => new BlendingParameters
-        {
-            RGBEquation = blendingEquation,
-            AlphaEquation = blendingEquation
-        };
+            if (DestinationAlpha == BlendingType.Inherit)
+                DestinationAlpha = parent.DestinationAlpha;
 
-        public bool IsDisabled =>
-            BlendingFactors.IsDisabled
-            && RGBEquation == BlendingEquation.Add
-            && AlphaEquation == BlendingEquation.Add;
+            if (RGBEquation == BlendingEquation.Inherit)
+                RGBEquation = parent.RGBEquation;
 
-        public bool Equals(BlendingParameters other) =>
-            other.BlendingFactors.Equals(BlendingFactors)
-            && other.RGBEquation == RGBEquation
-            && other.AlphaEquation == AlphaEquation;
+            if (AlphaEquation == BlendingEquation.Inherit)
+                AlphaEquation = parent.AlphaEquation;
+        }
 
-        public override string ToString() => $"BlendingParameter Mode: {Mode} BlendingFactor: {BlendingFactors} RGBEquation: {RGBEquation} AlphaEquation: {AlphaEquation}";
-    }
+        /// <summary>
+        /// Any properties marked as inherited will have their blending mode changed to the default type. This can occur when a root element is set to inherited.
+        /// </summary>
+        public void ApplyDefaultToInherited()
+        {
+            if (Source == BlendingType.Inherit)
+                Source = BlendingType.SrcAlpha;
 
-    public struct BlendingFactors : IEquatable<BlendingFactors>
-    {
-        public readonly BlendingFactorSrc Source;
-        public readonly BlendingFactorDest Destination;
-        public readonly BlendingFactorSrc SourceAlpha;
-        public readonly BlendingFactorDest DestinationAlpha;
+            if (Destination == BlendingType.Inherit)
+                Destination = BlendingType.OneMinusSrcAlpha;
 
-        public BlendingFactors(BlendingMode mode)
-        {
-            switch (mode)
-            {
-                case BlendingMode.Custom:
-                case BlendingMode.Inherit:
-                case BlendingMode.Mixture:
-                    Source = BlendingFactorSrc.SrcAlpha;
-                    Destination = BlendingFactorDest.OneMinusSrcAlpha;
-                    SourceAlpha = BlendingFactorSrc.One;
-                    DestinationAlpha = BlendingFactorDest.One;
-                    break;
+            if (SourceAlpha == BlendingType.Inherit)
+                SourceAlpha = BlendingType.One;
 
-                case BlendingMode.Additive:
-                    Source = BlendingFactorSrc.SrcAlpha;
-                    Destination = BlendingFactorDest.One;
-                    SourceAlpha = BlendingFactorSrc.One;
-                    DestinationAlpha = BlendingFactorDest.One;
-                    break;
+            if (DestinationAlpha == BlendingType.Inherit)
+                DestinationAlpha = BlendingType.One;
 
-                default:
-                    Source = BlendingFactorSrc.One;
-                    Destination = BlendingFactorDest.Zero;
-                    SourceAlpha = BlendingFactorSrc.One;
-                    DestinationAlpha = BlendingFactorDest.Zero;
-                    break;
-            }
-        }
+            if (RGBEquation == BlendingEquation.Inherit)
+                RGBEquation = BlendingEquation.Add;
 
-        public BlendingFactors(BlendingFactorSrc source, BlendingFactorDest destination, BlendingFactorSrc sourceAlpha, BlendingFactorDest destinationAlpha)
-        {
-            Source = source;
-            Destination = destination;
-            SourceAlpha = sourceAlpha;
-            DestinationAlpha = destinationAlpha;
+            if (AlphaEquation == BlendingEquation.Inherit)
+                AlphaEquation = BlendingEquation.Add;
         }
 
-        public bool Equals(BlendingFactors other) =>
+        public bool Equals(BlendingParameters other) =>
             other.Source == Source
             && other.Destination == Destination
             && other.SourceAlpha == SourceAlpha
-            && other.DestinationAlpha == DestinationAlpha;
+            && other.DestinationAlpha == DestinationAlpha
+            && other.RGBEquation == RGBEquation
+            && other.AlphaEquation == AlphaEquation;
 
         public bool IsDisabled =>
-            Source == BlendingFactorSrc.One
-            && Destination == BlendingFactorDest.Zero
-            && SourceAlpha == BlendingFactorSrc.One
-            && DestinationAlpha == BlendingFactorDest.Zero;
+            Source == BlendingType.One
+            && Destination == BlendingType.Zero
+            && SourceAlpha == BlendingType.One
+            && DestinationAlpha == BlendingType.Zero
+            && RGBEquation == BlendingEquation.Add
+            && AlphaEquation == BlendingEquation.Add;
 
-        public override string ToString() => $"{Source}/{Destination}/{SourceAlpha}/{DestinationAlpha}";
+        public override string ToString() => $"BlendingParameter: Factor: {Source}/{Destination}/{SourceAlpha}/{DestinationAlpha} RGBEquation: {RGBEquation} AlphaEquation: {AlphaEquation}";
     }
 
-    public enum BlendingMode
+    public enum BlendingType
     {
-        /// <summary>
-        /// Inherits from parent.
-        /// </summary>
         Inherit = 0,
-
-        /// <summary>
-        /// Mixes with existing colour by a factor of the colour's alpha.
-        /// </summary>
-        Mixture,
-
-        /// <summary>
-        /// Purely additive (by a factor of the colour's alpha) blending.
-        /// </summary>
-        Additive,
-
-        /// <summary>
-        /// The blending mode will be manually provided.
-        /// </summary>
-        Custom,
-
-        /// <summary>
-        /// No alpha blending whatsoever.
-        /// </summary>
-        None,
+        ConstantAlpha,
+        ConstantColor,
+        DstAlpha,
+        DstColor,
+        One,
+        OneMinusConstantAlpha,
+        OneMinusConstantColor,
+        OneMinusDstAlpha,
+        OneMinusDstColor,
+        OneMinusSrcAlpha,
+        OneMinusSrcColor,
+        SrcAlpha,
+        SrcAlphaSaturate,
+        SrcColor,
+        Zero
     }
 
     public enum BlendingEquation

osu.Framework/Graphics/Containers/BufferedContainer.cs

···
             }
         }
 
-        private BlendingParameters effectBlending;
+        private BlendingParameters effectBlending = BlendingParameters.Inherit;
 
         /// <summary>
-        /// The <see cref="BlendingParameters"/> to use after applying all effects. Default is <see cref="BlendingMode.Inherit"/>.
-        /// <see cref="BlendingMode.Inherit"/> inherits the blending mode of the original, i.e. <see cref="Drawable.Blending"/> is used.
+        /// The <see cref="BlendingParameters"/> to use after applying all effects. Default is <see cref="BlendingType.Inherit"/>.
+        /// <see cref="BlendingType.Inherit"/> inherits the blending mode of the original, i.e. <see cref="Drawable.Blending"/> is used.
         /// Does not affect the original which is drawn when <see cref="DrawOriginal"/> is true.
         /// </summary>
         public BlendingParameters EffectBlending
···
             {
                 BlendingParameters blending = EffectBlending;
 
-                if (blending.Mode == BlendingMode.Inherit)
-                {
-                    blending.Mode = Blending.Mode;
-                    if (Blending.Mode == BlendingMode.Custom)
-                        blending.BlendingFactors = Blending.BlendingFactors; //in custom mode we also need to copy blending factor
-                }
-
-                if (blending.RGBEquation == BlendingEquation.Inherit)
-                    blending.RGBEquation = Blending.RGBEquation;
-
-                if (blending.AlphaEquation == BlendingEquation.Inherit)
-                    blending.AlphaEquation = Blending.AlphaEquation;
+                blending.CopyFromParent(Blending);
+                blending.ApplyDefaultToInherited();
 
                 return blending;
             }

osu.Framework/Graphics/Containers/BufferedContainer_DrawNode.cs

···
                 FrameBuffer current = SharedData.CurrentEffectBuffer;
                 FrameBuffer target = SharedData.GetNextEffectBuffer();
 
-                GLWrapper.SetBlend(new BlendingParameters(BlendingMode.None));
+                GLWrapper.SetBlend(BlendingParameters.None);
 
                 using (BindFrameBuffer(target))
                 {

osu.Framework/Graphics/Containers/CompositeDrawable_DrawNode.cs

···
 
                 GLWrapper.PushMaskingInfo(edgeEffectMaskingInfo);
 
-                GLWrapper.SetBlend(new BlendingParameters(edgeEffect.Type == EdgeEffectType.Glow ? BlendingMode.Additive : BlendingMode.Mixture));
+                GLWrapper.SetBlend(edgeEffect.Type == EdgeEffectType.Glow ? BlendingParameters.Additive : BlendingParameters.Mixture);
 
                 Shader.Bind();
 

osu.Framework/Graphics/DrawColourInfo.cs

···
         public DrawColourInfo(ColourInfo? colour = null, BlendingParameters? blending = null)
         {
             Colour = colour ?? ColourInfo.SingleColour(Color4.White);
-            Blending = blending ?? new BlendingParameters(BlendingMode.Inherit);
+            Blending = blending ?? BlendingParameters.Inherit;
         }
 
         public bool Equals(DrawColourInfo other) => Colour.Equals(other.Colour) && Blending.Equals(other.Blending);

osu.Framework/Graphics/Drawable.cs

···
             BlendingParameters localBlending = Blending;
 
             if (Parent != null)
-            {
-                if (localBlending.Mode == BlendingMode.Inherit)
-                {
-                    localBlending.Mode = Parent.Blending.Mode;
-
-                    if (Parent.Blending.Mode == BlendingMode.Custom)
-                        localBlending.BlendingFactors = Parent.Blending.BlendingFactors; //copy blending settings from parent if custom
-                }
-
-                if (localBlending.RGBEquation == BlendingEquation.Inherit)
-                    localBlending.RGBEquation = Parent.Blending.RGBEquation;
+                localBlending.CopyFromParent(Parent.Blending);
 
-                if (localBlending.AlphaEquation == BlendingEquation.Inherit)
-                    localBlending.AlphaEquation = Parent.Blending.AlphaEquation;
-            }
+            localBlending.ApplyDefaultToInherited();
 
             ci.Blending = localBlending;
 

osu.Framework/Graphics/Effects/GlowEffect.cs

···
         /// <summary>
         /// The blending mode of the glow. Default is additive.
         /// </summary>
-        public BlendingParameters Blending = BlendingMode.Additive;
+        public BlendingParameters Blending = BlendingParameters.Additive;
 
         /// <summary>
         /// Whether to draw the glow <see cref="EffectPlacement.InFront"/> or <see cref="EffectPlacement.Behind"/> the glowing

osu.Framework/Graphics/Lines/Path_DrawNode.cs

···
                 GLWrapper.PushDepthInfo(DepthInfo.Default);
 
                 // Blending is removed to allow for correct blending between the wedges of the path.
-                GLWrapper.SetBlend(new BlendingParameters(BlendingMode.None));
+                GLWrapper.SetBlend(BlendingParameters.None);
 
                 pathShader.Bind();
 

osu.Framework/Graphics/OpenGL/GLWrapper.cs

···
                 lastBlendingEnabledState = true;
 
                 GL.BlendEquationSeparate(blendingParameters.RGBEquationMode, blendingParameters.AlphaEquationMode);
-                GL.BlendFuncSeparate(blendingParameters.BlendingFactors.Source, blendingParameters.BlendingFactors.Destination,
-                    blendingParameters.BlendingFactors.SourceAlpha, blendingParameters.BlendingFactors.DestinationAlpha);
+                GL.BlendFuncSeparate(blendingParameters.SourceBlendingFactor, blendingParameters.DestinationBlendingFactor,
+                    blendingParameters.SourceAlphaBlendingFactor, blendingParameters.DestinationAlphaBlendingFactor);
             }
 
             lastBlendingParameters = blendingParameters;

osu.Framework/Graphics/Shapes/Box.cs

···
                 conservativeScreenSpaceDrawQuad = Source.conservativeScreenSpaceDrawQuad;
 
                 hasOpaqueInterior = DrawColourInfo.Colour.MinAlpha == 1
-                                    && DrawColourInfo.Blending.Equals(new BlendingParameters(BlendingMode.Mixture))
+                                    && DrawColourInfo.Blending.Equals(BlendingParameters.Mixture)
                                     && DrawColourInfo.Colour.HasSingleColour;
             }
 

osu.Framework/Graphics/UserInterface/Button.cs

···
                 Add(flash);
 
                 flash.Colour = Background.Colour;
-                flash.Blending = BlendingMode.Additive;
+                flash.Blending = BlendingParameters.Additive;
                 flash.FadeOutFromOne(200);
                 flash.Expire();
             }

osu.Framework/Testing/Drawables/Steps/StepSlider.cs

···
             {
                 RelativeSizeAxes = Axes.Both,
                 Colour = Color4.RoyalBlue,
-                Blending = BlendingMode.Additive,
+                Blending = BlendingParameters.Additive,
                 Alpha = 0.6f,
             };