diff --git a/src/ImageSharp/PixelFormats/PixelAlphaCompositionMode.cs b/src/ImageSharp/PixelFormats/PixelAlphaCompositionMode.cs
index f42a264db..b003e62a4 100644
--- a/src/ImageSharp/PixelFormats/PixelAlphaCompositionMode.cs
+++ b/src/ImageSharp/PixelFormats/PixelAlphaCompositionMode.cs
@@ -66,5 +66,10 @@ public enum PixelAlphaCompositionMode
     /// <summary>
     /// Clear where they overlap.
     /// </summary>
-    Xor
+    Xor,
+
+    /// <summary>
+    /// Adds the source and destination, clamping the result to the supported color and alpha range.
+    /// </summary>
+    Plus,
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs
index acd9fba9c..b553e3412 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs
@@ -202,2121 +202,4767 @@ internal static class AssociatedAlphaPixelBlenderOperators
     }
 
     /// <summary>
-    /// Applies the "NormalSrcAtop" associated-alpha composition equation.
+    /// Applies the "ColorDodgeSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcAtop : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcAtop" associated-alpha composition equation.
+    /// Applies the "ColorBurnSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcAtop : IPixelBlenderOperator
+    public readonly struct ColorBurnSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcAtop" associated-alpha composition equation.
+    /// Applies the "SoftLightSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcAtop : IPixelBlenderOperator
+    public readonly struct SoftLightSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcAtop" associated-alpha composition equation.
+    /// Applies the "DifferenceSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcAtop : IPixelBlenderOperator
+    public readonly struct DifferenceSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcAtop" associated-alpha composition equation.
+    /// Applies the "ExclusionSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcAtop : IPixelBlenderOperator
+    public readonly struct ExclusionSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcAtop" associated-alpha composition equation.
+    /// Applies the "HueSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcAtop : IPixelBlenderOperator
+    public readonly struct HueSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcAtop" associated-alpha composition equation.
+    /// Applies the "SaturationSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcAtop : IPixelBlenderOperator
+    public readonly struct SaturationSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcAtop" associated-alpha composition equation.
+    /// Applies the "ColorSrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcAtop : IPixelBlenderOperator
+    public readonly struct ColorSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcAtop" associated-alpha composition equation.
+    /// Applies the "LuminositySrc" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcAtop : IPixelBlenderOperator
+    public readonly struct LuminositySrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalSrcOver" associated-alpha composition equation.
+    /// Applies the "NormalSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcOver : IPixelBlenderOperator
+    public readonly struct NormalSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcOver" associated-alpha composition equation.
+    /// Applies the "MultiplySrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcOver : IPixelBlenderOperator
+    public readonly struct MultiplySrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcOver" associated-alpha composition equation.
+    /// Applies the "AddSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcOver : IPixelBlenderOperator
+    public readonly struct AddSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcOver" associated-alpha composition equation.
+    /// Applies the "SubtractSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcOver : IPixelBlenderOperator
+    public readonly struct SubtractSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcOver" associated-alpha composition equation.
+    /// Applies the "ScreenSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcOver : IPixelBlenderOperator
+    public readonly struct ScreenSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcOver" associated-alpha composition equation.
+    /// Applies the "DarkenSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcOver : IPixelBlenderOperator
+    public readonly struct DarkenSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcOver" associated-alpha composition equation.
+    /// Applies the "LightenSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcOver : IPixelBlenderOperator
+    public readonly struct LightenSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcOver" associated-alpha composition equation.
+    /// Applies the "OverlaySrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcOver : IPixelBlenderOperator
+    public readonly struct OverlaySrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcOver" associated-alpha composition equation.
+    /// Applies the "HardLightSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcOver : IPixelBlenderOperator
+    public readonly struct HardLightSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalSrcIn" associated-alpha composition equation.
+    /// Applies the "ColorDodgeSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcIn : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcIn" associated-alpha composition equation.
+    /// Applies the "ColorBurnSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcIn : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcIn" associated-alpha composition equation.
+    /// Applies the "SoftLightSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcIn : IPixelBlenderOperator
+    public readonly struct SoftLightSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcIn" associated-alpha composition equation.
+    /// Applies the "DifferenceSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcIn : IPixelBlenderOperator
+    public readonly struct DifferenceSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcIn" associated-alpha composition equation.
+    /// Applies the "ExclusionSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcIn : IPixelBlenderOperator
+    public readonly struct ExclusionSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcIn" associated-alpha composition equation.
+    /// Applies the "HueSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcIn : IPixelBlenderOperator
+    public readonly struct HueSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcIn" associated-alpha composition equation.
+    /// Applies the "SaturationSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcIn : IPixelBlenderOperator
+    public readonly struct SaturationSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcIn" associated-alpha composition equation.
+    /// Applies the "ColorSrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcIn : IPixelBlenderOperator
+    public readonly struct ColorSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcIn" associated-alpha composition equation.
+    /// Applies the "LuminositySrcAtop" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcIn : IPixelBlenderOperator
+    public readonly struct LuminositySrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalSrcOut" associated-alpha composition equation.
+    /// Applies the "NormalSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcOut : IPixelBlenderOperator
+    public readonly struct NormalSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcOut" associated-alpha composition equation.
+    /// Applies the "MultiplySrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcOut : IPixelBlenderOperator
+    public readonly struct MultiplySrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcOut" associated-alpha composition equation.
+    /// Applies the "AddSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcOut : IPixelBlenderOperator
+    public readonly struct AddSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcOut" associated-alpha composition equation.
+    /// Applies the "SubtractSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcOut : IPixelBlenderOperator
+    public readonly struct SubtractSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcOut" associated-alpha composition equation.
+    /// Applies the "ScreenSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcOut : IPixelBlenderOperator
+    public readonly struct ScreenSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcOut" associated-alpha composition equation.
+    /// Applies the "DarkenSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcOut : IPixelBlenderOperator
+    public readonly struct DarkenSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcOut" associated-alpha composition equation.
+    /// Applies the "LightenSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcOut : IPixelBlenderOperator
+    public readonly struct LightenSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcOut" associated-alpha composition equation.
+    /// Applies the "OverlaySrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcOut : IPixelBlenderOperator
+    public readonly struct OverlaySrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcOut" associated-alpha composition equation.
+    /// Applies the "HardLightSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcOut : IPixelBlenderOperator
+    public readonly struct HardLightSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDest" associated-alpha composition equation.
+    /// Applies the "ColorDodgeSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDest : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDest" associated-alpha composition equation.
+    /// Applies the "ColorBurnSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDest : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDest" associated-alpha composition equation.
+    /// Applies the "SoftLightSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddDest : IPixelBlenderOperator
+    public readonly struct SoftLightSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDest" associated-alpha composition equation.
+    /// Applies the "DifferenceSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDest : IPixelBlenderOperator
+    public readonly struct DifferenceSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDest" associated-alpha composition equation.
+    /// Applies the "ExclusionSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDest : IPixelBlenderOperator
+    public readonly struct ExclusionSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDest" associated-alpha composition equation.
+    /// Applies the "HueSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDest : IPixelBlenderOperator
+    public readonly struct HueSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDest" associated-alpha composition equation.
+    /// Applies the "SaturationSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDest : IPixelBlenderOperator
+    public readonly struct SaturationSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDest" associated-alpha composition equation.
+    /// Applies the "ColorSrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDest : IPixelBlenderOperator
+    public readonly struct ColorSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDest" associated-alpha composition equation.
+    /// Applies the "LuminositySrcOver" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDest : IPixelBlenderOperator
+    public readonly struct LuminositySrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestAtop" associated-alpha composition equation.
+    /// Applies the "NormalSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestAtop : IPixelBlenderOperator
+    public readonly struct NormalSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestAtop" associated-alpha composition equation.
+    /// Applies the "MultiplySrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestAtop : IPixelBlenderOperator
+    public readonly struct MultiplySrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestAtop" associated-alpha composition equation.
+    /// Applies the "AddSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestAtop : IPixelBlenderOperator
+    public readonly struct AddSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestAtop" associated-alpha composition equation.
+    /// Applies the "SubtractSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestAtop : IPixelBlenderOperator
+    public readonly struct SubtractSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestAtop" associated-alpha composition equation.
+    /// Applies the "ScreenSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestAtop : IPixelBlenderOperator
+    public readonly struct ScreenSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestAtop" associated-alpha composition equation.
+    /// Applies the "DarkenSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestAtop : IPixelBlenderOperator
+    public readonly struct DarkenSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestAtop" associated-alpha composition equation.
+    /// Applies the "LightenSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestAtop : IPixelBlenderOperator
+    public readonly struct LightenSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestAtop" associated-alpha composition equation.
+    /// Applies the "OverlaySrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestAtop : IPixelBlenderOperator
+    public readonly struct OverlaySrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestAtop" associated-alpha composition equation.
+    /// Applies the "HardLightSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestAtop : IPixelBlenderOperator
+    public readonly struct HardLightSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestOver" associated-alpha composition equation.
+    /// Applies the "ColorDodgeSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestOver : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestOver" associated-alpha composition equation.
+    /// Applies the "ColorBurnSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestOver : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestOver" associated-alpha composition equation.
+    /// Applies the "SoftLightSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestOver : IPixelBlenderOperator
+    public readonly struct SoftLightSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestOver" associated-alpha composition equation.
+    /// Applies the "DifferenceSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestOver : IPixelBlenderOperator
+    public readonly struct DifferenceSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestOver" associated-alpha composition equation.
+    /// Applies the "ExclusionSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestOver : IPixelBlenderOperator
+    public readonly struct ExclusionSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestOver" associated-alpha composition equation.
+    /// Applies the "HueSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestOver : IPixelBlenderOperator
+    public readonly struct HueSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestOver" associated-alpha composition equation.
+    /// Applies the "SaturationSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestOver : IPixelBlenderOperator
+    public readonly struct SaturationSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestOver" associated-alpha composition equation.
+    /// Applies the "ColorSrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestOver : IPixelBlenderOperator
+    public readonly struct ColorSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestOver" associated-alpha composition equation.
+    /// Applies the "LuminositySrcIn" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestOver : IPixelBlenderOperator
+    public readonly struct LuminositySrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestIn" associated-alpha composition equation.
+    /// Applies the "NormalSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestIn : IPixelBlenderOperator
+    public readonly struct NormalSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestIn" associated-alpha composition equation.
+    /// Applies the "MultiplySrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestIn : IPixelBlenderOperator
+    public readonly struct MultiplySrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestIn" associated-alpha composition equation.
+    /// Applies the "AddSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestIn : IPixelBlenderOperator
+    public readonly struct AddSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestIn" associated-alpha composition equation.
+    /// Applies the "SubtractSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestIn : IPixelBlenderOperator
+    public readonly struct SubtractSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestIn" associated-alpha composition equation.
+    /// Applies the "ScreenSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestIn : IPixelBlenderOperator
+    public readonly struct ScreenSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestIn" associated-alpha composition equation.
+    /// Applies the "DarkenSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestIn : IPixelBlenderOperator
+    public readonly struct DarkenSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestIn" associated-alpha composition equation.
+    /// Applies the "LightenSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestIn : IPixelBlenderOperator
+    public readonly struct LightenSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestIn" associated-alpha composition equation.
+    /// Applies the "OverlaySrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestIn : IPixelBlenderOperator
+    public readonly struct OverlaySrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestIn" associated-alpha composition equation.
+    /// Applies the "HardLightSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestIn : IPixelBlenderOperator
+    public readonly struct HardLightSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestOut" associated-alpha composition equation.
+    /// Applies the "ColorDodgeSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestOut : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestOut" associated-alpha composition equation.
+    /// Applies the "ColorBurnSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestOut : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestOut" associated-alpha composition equation.
+    /// Applies the "SoftLightSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestOut : IPixelBlenderOperator
+    public readonly struct SoftLightSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestOut" associated-alpha composition equation.
+    /// Applies the "DifferenceSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestOut : IPixelBlenderOperator
+    public readonly struct DifferenceSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestOut" associated-alpha composition equation.
+    /// Applies the "ExclusionSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestOut : IPixelBlenderOperator
+    public readonly struct ExclusionSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestOut" associated-alpha composition equation.
+    /// Applies the "HueSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestOut : IPixelBlenderOperator
+    public readonly struct HueSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestOut" associated-alpha composition equation.
+    /// Applies the "SaturationSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestOut : IPixelBlenderOperator
+    public readonly struct SaturationSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestOut" associated-alpha composition equation.
+    /// Applies the "ColorSrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestOut : IPixelBlenderOperator
+    public readonly struct ColorSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestOut" associated-alpha composition equation.
+    /// Applies the "LuminositySrcOut" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestOut : IPixelBlenderOperator
+    public readonly struct LuminositySrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminositySrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalClear" associated-alpha composition equation.
+    /// Applies the "NormalDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalClear : IPixelBlenderOperator
+    public readonly struct NormalDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyClear" associated-alpha composition equation.
+    /// Applies the "MultiplyDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyClear : IPixelBlenderOperator
+    public readonly struct MultiplyDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddClear" associated-alpha composition equation.
+    /// Applies the "AddDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddClear : IPixelBlenderOperator
+    public readonly struct AddDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractClear" associated-alpha composition equation.
+    /// Applies the "SubtractDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractClear : IPixelBlenderOperator
+    public readonly struct SubtractDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenClear" associated-alpha composition equation.
+    /// Applies the "ScreenDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenClear : IPixelBlenderOperator
+    public readonly struct ScreenDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenClear" associated-alpha composition equation.
+    /// Applies the "DarkenDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenClear : IPixelBlenderOperator
+    public readonly struct DarkenDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenClear" associated-alpha composition equation.
+    /// Applies the "LightenDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenClear : IPixelBlenderOperator
+    public readonly struct LightenDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayClear" associated-alpha composition equation.
+    /// Applies the "OverlayDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayClear : IPixelBlenderOperator
+    public readonly struct OverlayDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightClear" associated-alpha composition equation.
+    /// Applies the "HardLightDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightClear : IPixelBlenderOperator
+    public readonly struct HardLightDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalXor" associated-alpha composition equation.
+    /// Applies the "ColorDodgeDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct NormalXor : IPixelBlenderOperator
+    public readonly struct ColorDodgeDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyXor" associated-alpha composition equation.
+    /// Applies the "ColorBurnDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyXor : IPixelBlenderOperator
+    public readonly struct ColorBurnDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddXor" associated-alpha composition equation.
+    /// Applies the "SoftLightDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct AddXor : IPixelBlenderOperator
+    public readonly struct SoftLightDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractXor" associated-alpha composition equation.
+    /// Applies the "DifferenceDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractXor : IPixelBlenderOperator
+    public readonly struct DifferenceDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenXor" associated-alpha composition equation.
+    /// Applies the "ExclusionDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenXor : IPixelBlenderOperator
+    public readonly struct ExclusionDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenXor" associated-alpha composition equation.
+    /// Applies the "HueDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenXor : IPixelBlenderOperator
+    public readonly struct HueDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.HueDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenXor" associated-alpha composition equation.
+    /// Applies the "SaturationDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct LightenXor : IPixelBlenderOperator
+    public readonly struct SaturationDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.SaturationDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayXor" associated-alpha composition equation.
+    /// Applies the "ColorDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayXor : IPixelBlenderOperator
+    public readonly struct ColorDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.ColorDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightXor" associated-alpha composition equation.
+    /// Applies the "LuminosityDest" associated-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightXor : IPixelBlenderOperator
+    public readonly struct LuminosityDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => true;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDest(background, source, amount);
     }
 
-}
-
-/// <summary>
-/// Provides associated-alpha pixel blenders for each color and alpha composition pair.
-/// </summary>
-/// <typeparam name="TPixel">The associated-alpha destination pixel format.</typeparam>
-internal static partial class AssociatedAlphaPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
-{
     /// <summary>
-    /// Gets the shared blender for the "NormalSrc" composition equation.
+    /// Applies the "NormalDestAtop" associated-alpha composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> NormalSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalSrc>.Instance;
+    public readonly struct NormalDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
 
-    /// <summary>
-    /// Gets the shared blender for the "MultiplySrc" composition equation.
-    /// </summary>
-    public static PixelBlender<TPixel> MultiplySrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplySrc>.Instance;
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-    /// <summary>
-    /// Gets the shared blender for the "AddSrc" composition equation.
-    /// </summary>
-    public static PixelBlender<TPixel> AddSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrc>.Instance;
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-    /// <summary>
-    /// Gets the shared blender for the "SubtractSrc" composition equation.
-    /// </summary>
-    public static PixelBlender<TPixel> SubtractSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrc>.Instance;
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
+    }
 
     /// <summary>
-    /// Gets the shared blender for the "ScreenSrc" composition equation.
+    /// Applies the "MultiplyDestAtop" associated-alpha composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> ScreenSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrc>.Instance;
+    public readonly struct MultiplyDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
 
-    /// <summary>
-    /// Gets the shared blender for the "DarkenSrc" composition equation.
-    /// </summary>
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HueClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HueClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgeXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferenceXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HueXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HueXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HueXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgePlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgePlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorDodgePlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorBurnPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SoftLightPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferencePlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferencePlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferencePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferencePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DifferencePlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ExclusionPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HuePlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HuePlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HuePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HuePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HuePlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SaturationPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ColorPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityPlus" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => true;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LuminosityPlus(background, source, amount);
+    }
+
+}
+
+/// <summary>
+/// Provides associated-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The associated-alpha destination pixel format.</typeparam>
+internal static partial class AssociatedAlphaPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    /// <summary>
+    /// Gets the shared blender for the "NormalSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> NormalSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "MultiplySrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> MultiplySrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplySrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "AddSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> AddSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SubtractSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SubtractSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ScreenSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ScreenSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DarkenSrc" composition equation.
+    /// </summary>
     public static PixelBlender<TPixel> DarkenSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrc>.Instance;
 
     /// <summary>
@@ -2334,6 +4980,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrc>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrc => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminositySrc>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcAtop" composition equation.
     /// </summary>
@@ -2379,6 +5070,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcAtop>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrcAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminositySrcAtop>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcOver" composition equation.
     /// </summary>
@@ -2424,6 +5160,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcOver>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrcOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminositySrcOver>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcIn" composition equation.
     /// </summary>
@@ -2469,6 +5250,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcIn>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrcIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminositySrcIn>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcOut" composition equation.
     /// </summary>
@@ -2482,37 +5308,82 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// <summary>
     /// Gets the shared blender for the "AddSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> AddSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrcOut>.Instance;
+    public static PixelBlender<TPixel> AddSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SubtractSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SubtractSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ScreenSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ScreenSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DarkenSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DarkenSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LightenSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LightenSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "OverlaySrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> OverlaySrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlaySrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HardLightSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HardLightSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "SubtractSrcOut" composition equation.
+    /// Gets the shared blender for the "DifferenceSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> SubtractSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrcOut>.Instance;
+    public static PixelBlender<TPixel> DifferenceSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "ScreenSrcOut" composition equation.
+    /// Gets the shared blender for the "ExclusionSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> ScreenSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrcOut>.Instance;
+    public static PixelBlender<TPixel> ExclusionSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "DarkenSrcOut" composition equation.
+    /// Gets the shared blender for the "HueSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> DarkenSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrcOut>.Instance;
+    public static PixelBlender<TPixel> HueSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "LightenSrcOut" composition equation.
+    /// Gets the shared blender for the "SaturationSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> LightenSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenSrcOut>.Instance;
+    public static PixelBlender<TPixel> SaturationSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "OverlaySrcOut" composition equation.
+    /// Gets the shared blender for the "ColorSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> OverlaySrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlaySrcOut>.Instance;
+    public static PixelBlender<TPixel> ColorSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "HardLightSrcOut" composition equation.
+    /// Gets the shared blender for the "LuminositySrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> HardLightSrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcOut>.Instance;
+    public static PixelBlender<TPixel> LuminositySrcOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminositySrcOut>.Instance;
 
     /// <summary>
     /// Gets the shared blender for the "NormalDest" composition equation.
@@ -2559,6 +5430,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDest>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDest => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityDest>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestAtop" composition equation.
     /// </summary>
@@ -2604,6 +5520,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestAtop>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestAtop => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityDestAtop>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestOver" composition equation.
     /// </summary>
@@ -2649,6 +5610,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestOver>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestOver => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityDestOver>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestIn" composition equation.
     /// </summary>
@@ -2694,6 +5700,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestIn>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestIn => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityDestIn>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestOut" composition equation.
     /// </summary>
@@ -2739,6 +5790,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestOut>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestOut => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityDestOut>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalClear" composition equation.
     /// </summary>
@@ -2784,6 +5880,51 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightClear>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityClear => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityClear>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalXor" composition equation.
     /// </summary>
@@ -2829,4 +5970,139 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightXor>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgeXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferenceXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HueXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityXor => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "NormalPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> NormalPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "MultiplyPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> MultiplyPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "AddPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> AddPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SubtractPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SubtractPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ScreenPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ScreenPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DarkenPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DarkenPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LightenPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LightenPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "OverlayPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> OverlayPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HardLightPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HardLightPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgePlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgePlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorDodgePlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorBurnPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SoftLightPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferencePlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferencePlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DifferencePlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ExclusionPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HuePlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HuePlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HuePlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SaturationPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ColorPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityPlus => PixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LuminosityPlus>.Instance;
+
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt
index 5fc7f91c4..127f45df3 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt
@@ -29,6 +29,7 @@ var composers = new []
     "DestOut",
     "Clear",
     "Xor",
+    "Plus",
 };
 
 var blenders = new []
@@ -42,6 +43,15 @@ var blenders = new []
     "Lighten",
     "Overlay",
     "HardLight",
+    "ColorDodge",
+    "ColorBurn",
+    "SoftLight",
+    "Difference",
+    "Exclusion",
+    "Hue",
+    "Saturation",
+    "Color",
+    "Luminosity",
 };
 #>
 /// <summary>
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.cs b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.cs
index 0664e3fa0..8650cc9f9 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.cs
@@ -29,6 +29,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenSrc,
                 PixelColorBlendingMode.Overlay => OverlaySrc,
                 PixelColorBlendingMode.HardLight => HardLightSrc,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeSrc,
+                PixelColorBlendingMode.ColorBurn => ColorBurnSrc,
+                PixelColorBlendingMode.SoftLight => SoftLightSrc,
+                PixelColorBlendingMode.Difference => DifferenceSrc,
+                PixelColorBlendingMode.Exclusion => ExclusionSrc,
+                PixelColorBlendingMode.Hue => HueSrc,
+                PixelColorBlendingMode.Saturation => SaturationSrc,
+                PixelColorBlendingMode.Color => ColorSrc,
+                PixelColorBlendingMode.Luminosity => LuminositySrc,
                 _ => NormalSrc,
             },
             PixelAlphaCompositionMode.SrcAtop => colorMode switch
@@ -41,6 +50,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenSrcAtop,
                 PixelColorBlendingMode.Overlay => OverlaySrcAtop,
                 PixelColorBlendingMode.HardLight => HardLightSrcAtop,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeSrcAtop,
+                PixelColorBlendingMode.ColorBurn => ColorBurnSrcAtop,
+                PixelColorBlendingMode.SoftLight => SoftLightSrcAtop,
+                PixelColorBlendingMode.Difference => DifferenceSrcAtop,
+                PixelColorBlendingMode.Exclusion => ExclusionSrcAtop,
+                PixelColorBlendingMode.Hue => HueSrcAtop,
+                PixelColorBlendingMode.Saturation => SaturationSrcAtop,
+                PixelColorBlendingMode.Color => ColorSrcAtop,
+                PixelColorBlendingMode.Luminosity => LuminositySrcAtop,
                 _ => NormalSrcAtop,
             },
             PixelAlphaCompositionMode.SrcIn => colorMode switch
@@ -53,6 +71,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenSrcIn,
                 PixelColorBlendingMode.Overlay => OverlaySrcIn,
                 PixelColorBlendingMode.HardLight => HardLightSrcIn,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeSrcIn,
+                PixelColorBlendingMode.ColorBurn => ColorBurnSrcIn,
+                PixelColorBlendingMode.SoftLight => SoftLightSrcIn,
+                PixelColorBlendingMode.Difference => DifferenceSrcIn,
+                PixelColorBlendingMode.Exclusion => ExclusionSrcIn,
+                PixelColorBlendingMode.Hue => HueSrcIn,
+                PixelColorBlendingMode.Saturation => SaturationSrcIn,
+                PixelColorBlendingMode.Color => ColorSrcIn,
+                PixelColorBlendingMode.Luminosity => LuminositySrcIn,
                 _ => NormalSrcIn,
             },
             PixelAlphaCompositionMode.SrcOut => colorMode switch
@@ -65,6 +92,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenSrcOut,
                 PixelColorBlendingMode.Overlay => OverlaySrcOut,
                 PixelColorBlendingMode.HardLight => HardLightSrcOut,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeSrcOut,
+                PixelColorBlendingMode.ColorBurn => ColorBurnSrcOut,
+                PixelColorBlendingMode.SoftLight => SoftLightSrcOut,
+                PixelColorBlendingMode.Difference => DifferenceSrcOut,
+                PixelColorBlendingMode.Exclusion => ExclusionSrcOut,
+                PixelColorBlendingMode.Hue => HueSrcOut,
+                PixelColorBlendingMode.Saturation => SaturationSrcOut,
+                PixelColorBlendingMode.Color => ColorSrcOut,
+                PixelColorBlendingMode.Luminosity => LuminositySrcOut,
                 _ => NormalSrcOut,
             },
             PixelAlphaCompositionMode.Dest => colorMode switch
@@ -77,6 +113,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenDest,
                 PixelColorBlendingMode.Overlay => OverlayDest,
                 PixelColorBlendingMode.HardLight => HardLightDest,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeDest,
+                PixelColorBlendingMode.ColorBurn => ColorBurnDest,
+                PixelColorBlendingMode.SoftLight => SoftLightDest,
+                PixelColorBlendingMode.Difference => DifferenceDest,
+                PixelColorBlendingMode.Exclusion => ExclusionDest,
+                PixelColorBlendingMode.Hue => HueDest,
+                PixelColorBlendingMode.Saturation => SaturationDest,
+                PixelColorBlendingMode.Color => ColorDest,
+                PixelColorBlendingMode.Luminosity => LuminosityDest,
                 _ => NormalDest,
             },
             PixelAlphaCompositionMode.DestAtop => colorMode switch
@@ -89,6 +134,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenDestAtop,
                 PixelColorBlendingMode.Overlay => OverlayDestAtop,
                 PixelColorBlendingMode.HardLight => HardLightDestAtop,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeDestAtop,
+                PixelColorBlendingMode.ColorBurn => ColorBurnDestAtop,
+                PixelColorBlendingMode.SoftLight => SoftLightDestAtop,
+                PixelColorBlendingMode.Difference => DifferenceDestAtop,
+                PixelColorBlendingMode.Exclusion => ExclusionDestAtop,
+                PixelColorBlendingMode.Hue => HueDestAtop,
+                PixelColorBlendingMode.Saturation => SaturationDestAtop,
+                PixelColorBlendingMode.Color => ColorDestAtop,
+                PixelColorBlendingMode.Luminosity => LuminosityDestAtop,
                 _ => NormalDestAtop,
             },
             PixelAlphaCompositionMode.DestOver => colorMode switch
@@ -101,6 +155,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenDestOver,
                 PixelColorBlendingMode.Overlay => OverlayDestOver,
                 PixelColorBlendingMode.HardLight => HardLightDestOver,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeDestOver,
+                PixelColorBlendingMode.ColorBurn => ColorBurnDestOver,
+                PixelColorBlendingMode.SoftLight => SoftLightDestOver,
+                PixelColorBlendingMode.Difference => DifferenceDestOver,
+                PixelColorBlendingMode.Exclusion => ExclusionDestOver,
+                PixelColorBlendingMode.Hue => HueDestOver,
+                PixelColorBlendingMode.Saturation => SaturationDestOver,
+                PixelColorBlendingMode.Color => ColorDestOver,
+                PixelColorBlendingMode.Luminosity => LuminosityDestOver,
                 _ => NormalDestOver,
             },
             PixelAlphaCompositionMode.DestIn => colorMode switch
@@ -113,6 +176,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenDestIn,
                 PixelColorBlendingMode.Overlay => OverlayDestIn,
                 PixelColorBlendingMode.HardLight => HardLightDestIn,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeDestIn,
+                PixelColorBlendingMode.ColorBurn => ColorBurnDestIn,
+                PixelColorBlendingMode.SoftLight => SoftLightDestIn,
+                PixelColorBlendingMode.Difference => DifferenceDestIn,
+                PixelColorBlendingMode.Exclusion => ExclusionDestIn,
+                PixelColorBlendingMode.Hue => HueDestIn,
+                PixelColorBlendingMode.Saturation => SaturationDestIn,
+                PixelColorBlendingMode.Color => ColorDestIn,
+                PixelColorBlendingMode.Luminosity => LuminosityDestIn,
                 _ => NormalDestIn,
             },
             PixelAlphaCompositionMode.DestOut => colorMode switch
@@ -125,6 +197,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenDestOut,
                 PixelColorBlendingMode.Overlay => OverlayDestOut,
                 PixelColorBlendingMode.HardLight => HardLightDestOut,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeDestOut,
+                PixelColorBlendingMode.ColorBurn => ColorBurnDestOut,
+                PixelColorBlendingMode.SoftLight => SoftLightDestOut,
+                PixelColorBlendingMode.Difference => DifferenceDestOut,
+                PixelColorBlendingMode.Exclusion => ExclusionDestOut,
+                PixelColorBlendingMode.Hue => HueDestOut,
+                PixelColorBlendingMode.Saturation => SaturationDestOut,
+                PixelColorBlendingMode.Color => ColorDestOut,
+                PixelColorBlendingMode.Luminosity => LuminosityDestOut,
                 _ => NormalDestOut,
             },
             PixelAlphaCompositionMode.Clear => colorMode switch
@@ -137,6 +218,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenClear,
                 PixelColorBlendingMode.Overlay => OverlayClear,
                 PixelColorBlendingMode.HardLight => HardLightClear,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeClear,
+                PixelColorBlendingMode.ColorBurn => ColorBurnClear,
+                PixelColorBlendingMode.SoftLight => SoftLightClear,
+                PixelColorBlendingMode.Difference => DifferenceClear,
+                PixelColorBlendingMode.Exclusion => ExclusionClear,
+                PixelColorBlendingMode.Hue => HueClear,
+                PixelColorBlendingMode.Saturation => SaturationClear,
+                PixelColorBlendingMode.Color => ColorClear,
+                PixelColorBlendingMode.Luminosity => LuminosityClear,
                 _ => NormalClear,
             },
             PixelAlphaCompositionMode.Xor => colorMode switch
@@ -149,8 +239,38 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenXor,
                 PixelColorBlendingMode.Overlay => OverlayXor,
                 PixelColorBlendingMode.HardLight => HardLightXor,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeXor,
+                PixelColorBlendingMode.ColorBurn => ColorBurnXor,
+                PixelColorBlendingMode.SoftLight => SoftLightXor,
+                PixelColorBlendingMode.Difference => DifferenceXor,
+                PixelColorBlendingMode.Exclusion => ExclusionXor,
+                PixelColorBlendingMode.Hue => HueXor,
+                PixelColorBlendingMode.Saturation => SaturationXor,
+                PixelColorBlendingMode.Color => ColorXor,
+                PixelColorBlendingMode.Luminosity => LuminosityXor,
                 _ => NormalXor,
             },
+            PixelAlphaCompositionMode.Plus => colorMode switch
+            {
+                PixelColorBlendingMode.Multiply => MultiplyPlus,
+                PixelColorBlendingMode.Add => AddPlus,
+                PixelColorBlendingMode.Subtract => SubtractPlus,
+                PixelColorBlendingMode.Screen => ScreenPlus,
+                PixelColorBlendingMode.Darken => DarkenPlus,
+                PixelColorBlendingMode.Lighten => LightenPlus,
+                PixelColorBlendingMode.Overlay => OverlayPlus,
+                PixelColorBlendingMode.HardLight => HardLightPlus,
+                PixelColorBlendingMode.ColorDodge => ColorDodgePlus,
+                PixelColorBlendingMode.ColorBurn => ColorBurnPlus,
+                PixelColorBlendingMode.SoftLight => SoftLightPlus,
+                PixelColorBlendingMode.Difference => DifferencePlus,
+                PixelColorBlendingMode.Exclusion => ExclusionPlus,
+                PixelColorBlendingMode.Hue => HuePlus,
+                PixelColorBlendingMode.Saturation => SaturationPlus,
+                PixelColorBlendingMode.Color => ColorPlus,
+                PixelColorBlendingMode.Luminosity => LuminosityPlus,
+                _ => NormalPlus,
+            },
             _ => colorMode switch
             {
                 PixelColorBlendingMode.Multiply => MultiplySrcOver,
@@ -161,6 +281,15 @@ internal static partial class AssociatedAlphaPixelBlenders<TPixel>
                 PixelColorBlendingMode.Lighten => LightenSrcOver,
                 PixelColorBlendingMode.Overlay => OverlaySrcOver,
                 PixelColorBlendingMode.HardLight => HardLightSrcOver,
+                PixelColorBlendingMode.ColorDodge => ColorDodgeSrcOver,
+                PixelColorBlendingMode.ColorBurn => ColorBurnSrcOver,
+                PixelColorBlendingMode.SoftLight => SoftLightSrcOver,
+                PixelColorBlendingMode.Difference => DifferenceSrcOver,
+                PixelColorBlendingMode.Exclusion => ExclusionSrcOver,
+                PixelColorBlendingMode.Hue => HueSrcOver,
+                PixelColorBlendingMode.Saturation => SaturationSrcOver,
+                PixelColorBlendingMode.Color => ColorSrcOver,
+                PixelColorBlendingMode.Luminosity => LuminositySrcOver,
                 _ => NormalSrcOver,
             },
         };
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.cs
index cd5a37a11..5057a25bd 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.cs
@@ -443,4593 +443,10479 @@ internal static partial class AssociatedAlphaPorterDuffFunctions
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorDodgeSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return AtopNormal(backdrop, source);
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorDodgeSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return AtopNormal(backdrop, source);
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorDodgeSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return AtopNormal(backdrop, source);
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorBurnSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Multiply(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplySrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorBurnSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Multiply(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplySrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorBurnSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Multiply(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SoftLightSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Add(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SoftLightSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Add(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SoftLightSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Add(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DifferenceSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Subtract(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DifferenceSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Subtract(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DifferenceSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Subtract(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ExclusionSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Screen(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ExclusionSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Screen(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ExclusionSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Screen(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HueSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Darken(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HueSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Darken(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HueSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Darken(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SaturationSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Lighten(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SaturationSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Lighten(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SaturationSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Lighten(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlaySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorSrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Overlay(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlaySrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Overlay(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlaySrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, Overlay(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LuminositySrc(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, HardLight(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LuminositySrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, HardLight(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcAtop" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrc" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LuminositySrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(backdrop, source, HardLight(backdrop, source));
+        return source;
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 NormalSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return OverNormal(backdrop, source);
+        return AtopNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> NormalSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return OverNormal(backdrop, source);
+        return AtopNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> NormalSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return OverNormal(backdrop, source);
+        return AtopNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplySrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 MultiplySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Multiply(backdrop, source));
+        return Atop(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplySrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> MultiplySrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Multiply(backdrop, source));
+        return Atop(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplySrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> MultiplySrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Multiply(backdrop, source));
+        return Atop(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 AddSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Add(backdrop, source));
+        return Atop(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> AddSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Add(backdrop, source));
+        return Atop(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> AddSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Add(backdrop, source));
+        return Atop(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SubtractSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Subtract(backdrop, source));
+        return Atop(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SubtractSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Subtract(backdrop, source));
+        return Atop(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SubtractSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Subtract(backdrop, source));
+        return Atop(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ScreenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Screen(backdrop, source));
+        return Atop(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ScreenSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Screen(backdrop, source));
+        return Atop(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ScreenSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Screen(backdrop, source));
+        return Atop(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DarkenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Darken(backdrop, source));
+        return Atop(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DarkenSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Darken(backdrop, source));
+        return Atop(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DarkenSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Darken(backdrop, source));
+        return Atop(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LightenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Lighten(backdrop, source));
+        return Atop(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LightenSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Lighten(backdrop, source));
+        return Atop(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LightenSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Lighten(backdrop, source));
+        return Atop(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlaySrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 OverlaySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Overlay(backdrop, source));
+        return Atop(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlaySrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> OverlaySrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Overlay(backdrop, source));
+        return Atop(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlaySrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> OverlaySrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, Overlay(backdrop, source));
+        return Atop(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HardLightSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, HardLight(backdrop, source));
+        return Atop(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HardLightSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, HardLight(backdrop, source));
+        return Atop(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcOver" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HardLightSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(backdrop, source, HardLight(backdrop, source));
+        return Atop(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorDodgeSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorDodgeSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorDodgeSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplySrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorBurnSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplySrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorBurnSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplySrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorBurnSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SoftLightSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SoftLightSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SoftLightSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DifferenceSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DifferenceSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DifferenceSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ExclusionSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ExclusionSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ExclusionSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HueSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HueSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HueSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SaturationSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SaturationSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SaturationSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlaySrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlaySrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlaySrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LuminositySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LuminositySrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcIn" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcAtop" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LuminositySrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(backdrop, source);
+        return Atop(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 NormalSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return OverNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> NormalSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return OverNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> NormalSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return OverNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplySrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 MultiplySrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplySrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> MultiplySrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplySrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplySrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> MultiplySrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 AddSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> AddSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> AddSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SubtractSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SubtractSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SubtractSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ScreenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ScreenSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ScreenSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DarkenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DarkenSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DarkenSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LightenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LightenSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LightenSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlaySrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 OverlaySrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlaySrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> OverlaySrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlaySrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlaySrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> OverlaySrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HardLightSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HardLightSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightSrcOut" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HardLightSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(backdrop, source);
+        return Over(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorDodgeSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorDodgeSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorDodgeSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplyDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorBurnSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplyDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorBurnSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplyDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorBurnSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDest" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SoftLightSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDest" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SoftLightSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDest" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SoftLightSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDest" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DifferenceSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDest" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DifferenceSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDest" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DifferenceSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDest" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ExclusionSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDest" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ExclusionSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDest" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ExclusionSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDest" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HueSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDest" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HueSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDest" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HueSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDest" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SaturationSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDest" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SaturationSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDest" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SaturationSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlayDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorSrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlayDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDest" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlayDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDest" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightDest(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LuminositySrcOver(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDest" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LuminositySrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDest" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcOver" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LuminositySrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return backdrop;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 NormalSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return AtopNormal(source, backdrop);
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> NormalSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return AtopNormal(source, backdrop);
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> NormalSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return AtopNormal(source, backdrop);
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplyDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 MultiplySrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Multiply(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplyDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> MultiplySrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Multiply(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplyDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> MultiplySrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Multiply(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 AddSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Add(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> AddSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Add(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "AddSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> AddSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Add(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SubtractSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Subtract(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SubtractSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Subtract(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SubtractSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Subtract(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ScreenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Screen(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ScreenSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Screen(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ScreenSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Screen(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DarkenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Darken(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DarkenSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Darken(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DarkenSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Darken(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LightenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Lighten(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LightenSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Lighten(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "LightenSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LightenSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Lighten(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlayDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 OverlaySrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Overlay(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlayDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> OverlaySrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Overlay(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "OverlaySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlayDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> OverlaySrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, Overlay(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HardLightSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, HardLight(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HardLightSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, HardLight(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestAtop" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HardLightSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Atop(source, backdrop, HardLight(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorDodgeSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return OverNormal(source, backdrop);
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorDodgeSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return OverNormal(source, backdrop);
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorDodgeSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return OverNormal(source, backdrop);
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplyDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorBurnSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Multiply(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplyDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorBurnSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Multiply(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplyDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorBurnSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Multiply(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SoftLightSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Add(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SoftLightSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Add(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SoftLightSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Add(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DifferenceSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Subtract(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DifferenceSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Subtract(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DifferenceSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Subtract(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ExclusionSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Screen(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ExclusionSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Screen(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ExclusionSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Screen(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HueSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Darken(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HueSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Darken(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "HueSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HueSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Darken(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SaturationSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Lighten(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SaturationSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Lighten(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SaturationSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Lighten(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlayDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorSrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Overlay(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlayDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Overlay(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "ColorSrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlayDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, Overlay(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LuminositySrcIn(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, HardLight(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LuminositySrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, HardLight(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestOver" compositing equation.
+    /// Returns the associated-alpha result of the "LuminositySrcIn" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LuminositySrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Over(source, backdrop, HardLight(source, backdrop));
+        return In(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "NormalSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplySrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplySrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplySrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlaySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlaySrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlaySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlaySrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlaySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlaySrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminositySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminositySrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminositySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminositySrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminositySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminositySrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplyDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlayDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlayDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return AtopNormal(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return AtopNormal(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return AtopNormal(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplyDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Multiply(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Multiply(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Multiply(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Add(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Add(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Add(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Subtract(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Subtract(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Subtract(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Screen(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Screen(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Screen(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Darken(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Darken(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Darken(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Lighten(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Lighten(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Lighten(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlayDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Overlay(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlayDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Overlay(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Overlay(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, HardLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, HardLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, HardLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Atop(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return OverNormal(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return OverNormal(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return OverNormal(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplyDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Multiply(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Multiply(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Multiply(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Add(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Add(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Add(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Subtract(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Subtract(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Subtract(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Screen(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Screen(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Screen(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Darken(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Darken(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Darken(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Lighten(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Lighten(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Lighten(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlayDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Overlay(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlayDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Overlay(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Overlay(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, HardLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, HardLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, HardLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Over(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplyDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlayDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlayDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplyDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlayDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlayDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplyClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "MultiplyClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "AddClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SubtractClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ScreenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DarkenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LightenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlayClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlayClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "OverlayClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HardLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorDodgeClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorBurnClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SoftLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "DifferenceClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ExclusionClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "HueClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "SaturationClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "ColorClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return Vector4.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return Vector256<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "LuminosityClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="opacity">The source opacity in the range 0 through 1.</param>
+    /// <returns>The associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return Vector512<float>.Zero;
+    }
+
+    /// <summary>
+    /// Returns the associated-alpha result of the "NormalXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 NormalXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "NormalXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> NormalXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "NormalXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> NormalXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplyXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplyDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 MultiplyXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplyXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplyDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> MultiplyXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplyXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplyDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> MultiplyXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "AddXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 AddXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "AddXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> AddXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "AddXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> AddXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SubtractXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SubtractXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SubtractXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ScreenXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ScreenXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ScreenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DarkenXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DarkenXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DarkenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "LightenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LightenXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "LightenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LightenXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "LightenXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LightenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "OverlayXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlayDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 OverlayXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "OverlayXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlayDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> OverlayXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "OverlayXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlayDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> OverlayXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HardLightXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HardLightXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestIn" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HardLightXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return In(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorDodgeXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorDodgeXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgeXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorDodgeXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplyDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorBurnXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplyDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorBurnXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplyDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorBurnXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SoftLightXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SoftLightXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SoftLightXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DifferenceXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DifferenceXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "DifferenceXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DifferenceXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ExclusionXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ExclusionXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ExclusionXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "HueXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HueXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "HueXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HueXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "HueXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HueXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SaturationXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SaturationXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SaturationXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlayDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlayDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "ColorXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlayDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "LuminosityXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LuminosityXor(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "LuminosityXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LuminosityXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightDestOut" compositing equation.
+    /// Returns the associated-alpha result of the "LuminosityXor" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LuminosityXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Out(source, backdrop);
+        return Xor(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalClear" compositing equation.
+    /// Returns the associated-alpha result of the "NormalPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 NormalPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return PlusNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalClear" compositing equation.
+    /// Returns the associated-alpha result of the "NormalPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> NormalPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return PlusNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalClear" compositing equation.
+    /// Returns the associated-alpha result of the "NormalPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> NormalPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return PlusNormal(backdrop, source);
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyClear" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplyPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplyClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 MultiplyPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyClear" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplyPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplyClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> MultiplyPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyClear" compositing equation.
+    /// Returns the associated-alpha result of the "MultiplyPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplyClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> MultiplyPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Multiply(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddClear" compositing equation.
+    /// Returns the associated-alpha result of the "AddPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 AddPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddClear" compositing equation.
+    /// Returns the associated-alpha result of the "AddPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> AddPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddClear" compositing equation.
+    /// Returns the associated-alpha result of the "AddPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> AddPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Add(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractClear" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SubtractPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractClear" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SubtractPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractClear" compositing equation.
+    /// Returns the associated-alpha result of the "SubtractPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SubtractPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Subtract(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenClear" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ScreenPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenClear" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ScreenPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenClear" compositing equation.
+    /// Returns the associated-alpha result of the "ScreenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ScreenPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Screen(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenClear" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DarkenPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenClear" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DarkenPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenClear" compositing equation.
+    /// Returns the associated-alpha result of the "DarkenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DarkenPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenClear" compositing equation.
+    /// Returns the associated-alpha result of the "LightenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LightenPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenClear" compositing equation.
+    /// Returns the associated-alpha result of the "LightenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LightenPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenClear" compositing equation.
+    /// Returns the associated-alpha result of the "LightenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LightenPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Lighten(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayClear" compositing equation.
+    /// Returns the associated-alpha result of the "OverlayPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlayClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 OverlayPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayClear" compositing equation.
+    /// Returns the associated-alpha result of the "OverlayPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlayClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> OverlayPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayClear" compositing equation.
+    /// Returns the associated-alpha result of the "OverlayPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlayClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> OverlayPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, Overlay(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightClear" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HardLightPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
-        return Vector4.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightClear" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HardLightPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
-        return Vector256<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightClear" compositing equation.
+    /// Returns the associated-alpha result of the "HardLightPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HardLightPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
-        return Vector512<float>.Zero;
+        // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
+        source *= opacity;
+
+        return Plus(backdrop, source, HardLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 NormalXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorDodgePlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> NormalXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorDodgePlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "NormalXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorDodgePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> NormalXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorDodgePlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, ColorDodge(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 MultiplyXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorBurnPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> MultiplyXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorBurnPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "MultiplyXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorBurnPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> MultiplyXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorBurnPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, ColorBurn(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddXor" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 AddXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SoftLightPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddXor" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> AddXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SoftLightPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "AddXor" compositing equation.
+    /// Returns the associated-alpha result of the "SoftLightPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> AddXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SoftLightPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, SoftLight(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractXor" compositing equation.
+    /// Returns the associated-alpha result of the "DifferencePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 SubtractXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DifferencePlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractXor" compositing equation.
+    /// Returns the associated-alpha result of the "DifferencePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> SubtractXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> DifferencePlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "SubtractXor" compositing equation.
+    /// Returns the associated-alpha result of the "DifferencePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> SubtractXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> DifferencePlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Difference(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenXor" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 ScreenXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ExclusionPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenXor" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> ScreenXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ExclusionPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "ScreenXor" compositing equation.
+    /// Returns the associated-alpha result of the "ExclusionPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> ScreenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ExclusionPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Exclusion(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenXor" compositing equation.
+    /// Returns the associated-alpha result of the "HuePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 HuePlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenXor" compositing equation.
+    /// Returns the associated-alpha result of the "HuePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> HuePlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "DarkenXor" compositing equation.
+    /// Returns the associated-alpha result of the "HuePlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> DarkenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> HuePlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Hue(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenXor" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 LightenXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 SaturationPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenXor" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> LightenXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> SaturationPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "LightenXor" compositing equation.
+    /// Returns the associated-alpha result of the "SaturationPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> LightenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> SaturationPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Saturation(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 OverlayXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 ColorPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> OverlayXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> ColorPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "OverlayXor" compositing equation.
+    /// Returns the associated-alpha result of the "ColorPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> OverlayXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> ColorPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Color(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightXor" compositing equation.
+    /// Returns the associated-alpha result of the "LuminosityPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 HardLightXor(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 LuminosityPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightXor" compositing equation.
+    /// Returns the associated-alpha result of the "LuminosityPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> HardLightXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    public static Vector256<float> LuminosityPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Luminosity(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the associated-alpha result of the "HardLightXor" compositing equation.
+    /// Returns the associated-alpha result of the "LuminosityPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The associated backdrop vector.</param>
     /// <param name="source">The associated source vector.</param>
     /// <param name="opacity">The source opacity in the range 0 through 1.</param>
     /// <returns>The associated composition result.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> HardLightXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    public static Vector512<float> LuminosityPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
     {
         // Associated RGB and alpha are scaled together so opacity cannot change the represented straight colour.
         source *= opacity;
 
-        return Xor(backdrop, source);
+        return Plus(backdrop, source, Luminosity(backdrop, source));
     }
 
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.tt
index e0652d679..8cc89620b 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.Generated.tt
@@ -73,6 +73,7 @@ internal static partial class AssociatedAlphaPorterDuffFunctions
         "DestOut",
         "Clear",
         "Xor",
+        "Plus",
     };
 
     private static readonly string[] Blenders =
@@ -86,6 +87,15 @@ internal static partial class AssociatedAlphaPorterDuffFunctions
         "Lighten",
         "Overlay",
         "HardLight",
+        "ColorDodge",
+        "ColorBurn",
+        "SoftLight",
+        "Difference",
+        "Exclusion",
+        "Hue",
+        "Saturation",
+        "Color",
+        "Luminosity",
     };
 
     private static readonly string[] VectorTypes =
@@ -131,6 +141,10 @@ internal static partial class AssociatedAlphaPorterDuffFunctions
                 return "Out(source, backdrop)";
             case "Clear":
                 return zero;
+            case "Plus":
+                return normal
+                    ? "PlusNormal(backdrop, source)"
+                    : $"Plus(backdrop, source, {blender}(backdrop, source))";
             default:
                 return "Xor(backdrop, source)";
         }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.cs b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.cs
index d7b5260d3..893e8e41a 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPorterDuffFunctions.cs
@@ -280,6 +280,384 @@ internal static partial class AssociatedAlphaPorterDuffFunctions
         return Vector512.ConditionalSelect(useRight, right, left);
     }
 
+    /// <summary>
+    /// Calculates the associated overlap term for ColorDodge blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodge(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.ColorDodge(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="ColorDodge(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodge(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.ColorDodge(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="ColorDodge(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodge(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.ColorDodge(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for ColorBurn blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurn(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.ColorBurn(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="ColorBurn(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurn(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.ColorBurn(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="ColorBurn(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurn(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.ColorBurn(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for SoftLight blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLight(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.SoftLight(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="SoftLight(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLight(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.SoftLight(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="SoftLight(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLight(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.SoftLight(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for Difference blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Difference(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.Difference(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Difference(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Difference(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Difference(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Difference(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Difference(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Difference(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for Exclusion blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Exclusion(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.Exclusion(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Exclusion(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Exclusion(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Exclusion(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Exclusion(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Exclusion(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Exclusion(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for Hue blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Hue(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.Hue(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Hue(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Hue(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Hue(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Hue(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Hue(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Hue(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for Saturation blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Saturation(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.Saturation(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Saturation(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Saturation(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Saturation(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Saturation(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Saturation(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Saturation(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for Color blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Color(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.Color(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Color(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Color(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Color(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Color(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Color(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Color(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <summary>
+    /// Calculates the associated overlap term for Luminosity blending.
+    /// </summary>
+    /// <param name="backdrop">The associated backdrop vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The associated overlap term.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Luminosity(Vector4 backdrop, Vector4 source)
+    {
+        Vector4 backdropAlpha = Numerics.PermuteW(backdrop);
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 unassociatedBackdrop = backdrop;
+        Vector4 unassociatedSource = source;
+
+        // This blend equation is defined in straight RGB, so recover each color before scaling the result by the overlap alpha.
+        Numerics.UnPremultiply(ref unassociatedBackdrop);
+        Numerics.UnPremultiply(ref unassociatedSource);
+        return PorterDuffFunctions.Luminosity(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Luminosity(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Luminosity(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> backdropAlpha = Avx.Permute(backdrop, ShuffleAlphaControl);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector256<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Luminosity(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
+    /// <inheritdoc cref="Luminosity(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Luminosity(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> backdropAlpha = Vector512_.ShuffleNative(backdrop, ShuffleAlphaControl);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> unassociatedBackdrop = Numerics.UnPremultiply(backdrop, backdropAlpha);
+        Vector512<float> unassociatedSource = Numerics.UnPremultiply(source, sourceAlpha);
+        return PorterDuffFunctions.Luminosity(unassociatedBackdrop, unassociatedSource) * backdropAlpha * sourceAlpha;
+    }
+
     /// <summary>
     /// Composites an associated source over an associated destination without a color-blending function.
     /// </summary>
@@ -310,6 +688,77 @@ internal static partial class AssociatedAlphaPorterDuffFunctions
         return source + (destination * (Vector512.Create(1F) - sourceAlpha));
     }
 
+    /// <summary>
+    /// Adds associated source and destination vectors without a color-blending function.
+    /// </summary>
+    /// <param name="destination">The associated destination vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <returns>The clamped associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 PlusNormal(Vector4 destination, Vector4 source)
+    {
+        Vector4 alpha = Vector4.Min(Vector4.One, Numerics.PermuteW(source) + Numerics.PermuteW(destination));
+        return Numerics.WithW(Vector4.Min(Vector4.One, destination + source), alpha);
+    }
+
+    /// <inheritdoc cref="PlusNormal(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> PlusNormal(Vector256<float> destination, Vector256<float> source)
+    {
+        Vector256<float> one = Vector256.Create(1F);
+        Vector256<float> alpha = Vector256.Min(one, Avx.Permute(source, ShuffleAlphaControl) + Avx.Permute(destination, ShuffleAlphaControl));
+        return Avx.Blend(Vector256.Min(one, destination + source), alpha, BlendAlphaControl);
+    }
+
+    /// <inheritdoc cref="PlusNormal(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> PlusNormal(Vector512<float> destination, Vector512<float> source)
+    {
+        Vector512<float> one = Vector512.Create(1F);
+        Vector512<float> alpha = Vector512.Min(one, Vector512_.ShuffleNative(source, ShuffleAlphaControl) + Vector512_.ShuffleNative(destination, ShuffleAlphaControl));
+        return Vector512.ConditionalSelect(AlphaMask512(), alpha, Vector512.Min(one, destination + source));
+    }
+
+    /// <summary>
+    /// Adds associated source and destination vectors using a color-blended overlap term.
+    /// </summary>
+    /// <param name="destination">The associated destination vector.</param>
+    /// <param name="source">The associated source vector.</param>
+    /// <param name="overlap">The associated overlap term produced by the color-blending function.</param>
+    /// <returns>The clamped associated composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Plus(Vector4 destination, Vector4 source, Vector4 overlap)
+    {
+        Vector4 destinationAlpha = Numerics.PermuteW(destination);
+        Vector4 alpha = Vector4.Min(Vector4.One, Numerics.PermuteW(source) + destinationAlpha);
+
+        // The blended source contributes straight source color outside the destination and the blend result in the overlap.
+        Vector4 result = destination + (source * (Vector4.One - destinationAlpha)) + overlap;
+        return Numerics.WithW(Vector4.Min(Vector4.One, result), alpha);
+    }
+
+    /// <inheritdoc cref="Plus(Vector4, Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Plus(Vector256<float> destination, Vector256<float> source, Vector256<float> overlap)
+    {
+        Vector256<float> one = Vector256.Create(1F);
+        Vector256<float> destinationAlpha = Avx.Permute(destination, ShuffleAlphaControl);
+        Vector256<float> alpha = Vector256.Min(one, Avx.Permute(source, ShuffleAlphaControl) + destinationAlpha);
+        Vector256<float> result = destination + (source * (one - destinationAlpha)) + overlap;
+        return Avx.Blend(Vector256.Min(one, result), alpha, BlendAlphaControl);
+    }
+
+    /// <inheritdoc cref="Plus(Vector4, Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Plus(Vector512<float> destination, Vector512<float> source, Vector512<float> overlap)
+    {
+        Vector512<float> one = Vector512.Create(1F);
+        Vector512<float> destinationAlpha = Vector512_.ShuffleNative(destination, ShuffleAlphaControl);
+        Vector512<float> alpha = Vector512.Min(one, Vector512_.ShuffleNative(source, ShuffleAlphaControl) + destinationAlpha);
+        Vector512<float> result = destination + (source * (one - destinationAlpha)) + overlap;
+        return Vector512.ConditionalSelect(AlphaMask512(), alpha, Vector512.Min(one, result));
+    }
+
     /// <summary>
     /// Composites an associated source atop an associated destination without a color-blending function.
     /// </summary>
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
index 298c35999..de2ccf3a9 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
@@ -202,2121 +202,4767 @@ internal static class DefaultPixelBlenderOperators
     }
 
     /// <summary>
-    /// Applies the "NormalSrcAtop" straight-alpha composition equation.
+    /// Applies the "ColorDodgeSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcAtop : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcAtop" straight-alpha composition equation.
+    /// Applies the "ColorBurnSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcAtop : IPixelBlenderOperator
+    public readonly struct ColorBurnSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcAtop" straight-alpha composition equation.
+    /// Applies the "SoftLightSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcAtop : IPixelBlenderOperator
+    public readonly struct SoftLightSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcAtop" straight-alpha composition equation.
+    /// Applies the "DifferenceSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcAtop : IPixelBlenderOperator
+    public readonly struct DifferenceSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcAtop" straight-alpha composition equation.
+    /// Applies the "ExclusionSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcAtop : IPixelBlenderOperator
+    public readonly struct ExclusionSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcAtop" straight-alpha composition equation.
+    /// Applies the "HueSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcAtop : IPixelBlenderOperator
+    public readonly struct HueSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.HueSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.HueSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.HueSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcAtop" straight-alpha composition equation.
+    /// Applies the "SaturationSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcAtop : IPixelBlenderOperator
+    public readonly struct SaturationSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.SaturationSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.SaturationSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
+            => PorterDuffFunctions.SaturationSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcAtop" straight-alpha composition equation.
+    /// Applies the "ColorSrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcAtop : IPixelBlenderOperator
+    public readonly struct ColorSrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorSrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+            => PorterDuffFunctions.ColorSrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcAtop" straight-alpha composition equation.
+    /// Applies the "LuminositySrc" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcAtop : IPixelBlenderOperator
+    public readonly struct LuminositySrc : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+            => PorterDuffFunctions.LuminositySrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+            => PorterDuffFunctions.LuminositySrc(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+            => PorterDuffFunctions.LuminositySrc(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalSrcOver" straight-alpha composition equation.
+    /// Applies the "NormalSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcOver : IPixelBlenderOperator
+    public readonly struct NormalSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
+            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
+            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
+            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcOver" straight-alpha composition equation.
+    /// Applies the "MultiplySrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcOver : IPixelBlenderOperator
+    public readonly struct MultiplySrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcOver" straight-alpha composition equation.
+    /// Applies the "AddSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcOver : IPixelBlenderOperator
+    public readonly struct AddSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddSrcOver(background, source, amount);
+            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddSrcOver(background, source, amount);
+            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddSrcOver(background, source, amount);
+            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcOver" straight-alpha composition equation.
+    /// Applies the "SubtractSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcOver : IPixelBlenderOperator
+    public readonly struct SubtractSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcOver" straight-alpha composition equation.
+    /// Applies the "ScreenSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcOver : IPixelBlenderOperator
+    public readonly struct ScreenSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcOver" straight-alpha composition equation.
+    /// Applies the "DarkenSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcOver : IPixelBlenderOperator
+    public readonly struct DarkenSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcOver" straight-alpha composition equation.
+    /// Applies the "LightenSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcOver : IPixelBlenderOperator
+    public readonly struct LightenSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
+            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
+            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
+            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcOver" straight-alpha composition equation.
+    /// Applies the "OverlaySrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcOver : IPixelBlenderOperator
+    public readonly struct OverlaySrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcOver" straight-alpha composition equation.
+    /// Applies the "HardLightSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcOver : IPixelBlenderOperator
+    public readonly struct HardLightSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalSrcIn" straight-alpha composition equation.
+    /// Applies the "ColorDodgeSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcIn : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcIn" straight-alpha composition equation.
+    /// Applies the "ColorBurnSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcIn : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcIn" straight-alpha composition equation.
+    /// Applies the "SoftLightSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcIn : IPixelBlenderOperator
+    public readonly struct SoftLightSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddSrcIn(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddSrcIn(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddSrcIn(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcIn" straight-alpha composition equation.
+    /// Applies the "DifferenceSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcIn : IPixelBlenderOperator
+    public readonly struct DifferenceSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcIn" straight-alpha composition equation.
+    /// Applies the "ExclusionSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcIn : IPixelBlenderOperator
+    public readonly struct ExclusionSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcIn" straight-alpha composition equation.
+    /// Applies the "HueSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcIn : IPixelBlenderOperator
+    public readonly struct HueSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
+            => PorterDuffFunctions.HueSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
+            => PorterDuffFunctions.HueSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
+            => PorterDuffFunctions.HueSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcIn" straight-alpha composition equation.
+    /// Applies the "SaturationSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcIn : IPixelBlenderOperator
+    public readonly struct SaturationSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcIn" straight-alpha composition equation.
+    /// Applies the "ColorSrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcIn : IPixelBlenderOperator
+    public readonly struct ColorSrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorSrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
+            => PorterDuffFunctions.ColorSrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcIn" straight-alpha composition equation.
+    /// Applies the "LuminositySrcAtop" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcIn : IPixelBlenderOperator
+    public readonly struct LuminositySrcAtop : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcAtop(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcAtop(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalSrcOut" straight-alpha composition equation.
+    /// Applies the "NormalSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalSrcOut : IPixelBlenderOperator
+    public readonly struct NormalSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
+            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
+            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
+            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplySrcOut" straight-alpha composition equation.
+    /// Applies the "MultiplySrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplySrcOut : IPixelBlenderOperator
+    public readonly struct MultiplySrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddSrcOut" straight-alpha composition equation.
+    /// Applies the "AddSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddSrcOut : IPixelBlenderOperator
+    public readonly struct AddSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddSrcOut(background, source, amount);
+            => PorterDuffFunctions.AddSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddSrcOut(background, source, amount);
+            => PorterDuffFunctions.AddSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddSrcOut(background, source, amount);
+            => PorterDuffFunctions.AddSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractSrcOut" straight-alpha composition equation.
+    /// Applies the "SubtractSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractSrcOut : IPixelBlenderOperator
+    public readonly struct SubtractSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenSrcOut" straight-alpha composition equation.
+    /// Applies the "ScreenSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenSrcOut : IPixelBlenderOperator
+    public readonly struct ScreenSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenSrcOut" straight-alpha composition equation.
+    /// Applies the "DarkenSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenSrcOut : IPixelBlenderOperator
+    public readonly struct DarkenSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenSrcOut" straight-alpha composition equation.
+    /// Applies the "LightenSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenSrcOut : IPixelBlenderOperator
+    public readonly struct LightenSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
+            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
+            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
+            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlaySrcOut" straight-alpha composition equation.
+    /// Applies the "OverlaySrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlaySrcOut : IPixelBlenderOperator
+    public readonly struct OverlaySrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightSrcOut" straight-alpha composition equation.
+    /// Applies the "HardLightSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightSrcOut : IPixelBlenderOperator
+    public readonly struct HardLightSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDest" straight-alpha composition equation.
+    /// Applies the "ColorDodgeSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDest : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalDest(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalDest(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalDest(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDest" straight-alpha composition equation.
+    /// Applies the "ColorBurnSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDest : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplyDest(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplyDest(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplyDest(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDest" straight-alpha composition equation.
+    /// Applies the "SoftLightSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddDest : IPixelBlenderOperator
+    public readonly struct SoftLightSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddDest(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddDest(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddDest(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDest" straight-alpha composition equation.
+    /// Applies the "DifferenceSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDest : IPixelBlenderOperator
+    public readonly struct DifferenceSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractDest(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractDest(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractDest(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDest" straight-alpha composition equation.
+    /// Applies the "ExclusionSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDest : IPixelBlenderOperator
+    public readonly struct ExclusionSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenDest(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenDest(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenDest(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDest" straight-alpha composition equation.
+    /// Applies the "HueSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDest : IPixelBlenderOperator
+    public readonly struct HueSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenDest(background, source, amount);
+            => PorterDuffFunctions.HueSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenDest(background, source, amount);
+            => PorterDuffFunctions.HueSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenDest(background, source, amount);
+            => PorterDuffFunctions.HueSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDest" straight-alpha composition equation.
+    /// Applies the "SaturationSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDest : IPixelBlenderOperator
+    public readonly struct SaturationSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenDest(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenDest(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenDest(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDest" straight-alpha composition equation.
+    /// Applies the "ColorSrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDest : IPixelBlenderOperator
+    public readonly struct ColorSrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlayDest(background, source, amount);
+            => PorterDuffFunctions.ColorSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlayDest(background, source, amount);
+            => PorterDuffFunctions.ColorSrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlayDest(background, source, amount);
+            => PorterDuffFunctions.ColorSrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDest" straight-alpha composition equation.
+    /// Applies the "LuminositySrcOver" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDest : IPixelBlenderOperator
+    public readonly struct LuminositySrcOver : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightDest(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightDest(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcOver(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightDest(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcOver(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestAtop" straight-alpha composition equation.
+    /// Applies the "NormalSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestAtop : IPixelBlenderOperator
+    public readonly struct NormalSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
+            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
+            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
+            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestAtop" straight-alpha composition equation.
+    /// Applies the "MultiplySrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestAtop : IPixelBlenderOperator
+    public readonly struct MultiplySrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestAtop" straight-alpha composition equation.
+    /// Applies the "AddSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestAtop : IPixelBlenderOperator
+    public readonly struct AddSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddDestAtop(background, source, amount);
+            => PorterDuffFunctions.AddSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddDestAtop(background, source, amount);
+            => PorterDuffFunctions.AddSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddDestAtop(background, source, amount);
+            => PorterDuffFunctions.AddSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestAtop" straight-alpha composition equation.
+    /// Applies the "SubtractSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestAtop : IPixelBlenderOperator
+    public readonly struct SubtractSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestAtop" straight-alpha composition equation.
+    /// Applies the "ScreenSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestAtop : IPixelBlenderOperator
+    public readonly struct ScreenSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestAtop" straight-alpha composition equation.
+    /// Applies the "DarkenSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestAtop : IPixelBlenderOperator
+    public readonly struct DarkenSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestAtop" straight-alpha composition equation.
+    /// Applies the "LightenSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestAtop : IPixelBlenderOperator
+    public readonly struct LightenSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
+            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
+            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
+            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestAtop" straight-alpha composition equation.
+    /// Applies the "OverlaySrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestAtop : IPixelBlenderOperator
+    public readonly struct OverlaySrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestAtop" straight-alpha composition equation.
+    /// Applies the "HardLightSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestAtop : IPixelBlenderOperator
+    public readonly struct HardLightSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestOver" straight-alpha composition equation.
+    /// Applies the "ColorDodgeSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestOver : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestOver" straight-alpha composition equation.
+    /// Applies the "ColorBurnSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestOver : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestOver" straight-alpha composition equation.
+    /// Applies the "SoftLightSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestOver : IPixelBlenderOperator
+    public readonly struct SoftLightSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddDestOver(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddDestOver(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddDestOver(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestOver" straight-alpha composition equation.
+    /// Applies the "DifferenceSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestOver : IPixelBlenderOperator
+    public readonly struct DifferenceSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestOver" straight-alpha composition equation.
+    /// Applies the "ExclusionSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestOver : IPixelBlenderOperator
+    public readonly struct ExclusionSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestOver" straight-alpha composition equation.
+    /// Applies the "HueSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestOver : IPixelBlenderOperator
+    public readonly struct HueSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
+            => PorterDuffFunctions.HueSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
+            => PorterDuffFunctions.HueSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
+            => PorterDuffFunctions.HueSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestOver" straight-alpha composition equation.
+    /// Applies the "SaturationSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestOver : IPixelBlenderOperator
+    public readonly struct SaturationSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenDestOver(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenDestOver(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenDestOver(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestOver" straight-alpha composition equation.
+    /// Applies the "ColorSrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestOver : IPixelBlenderOperator
+    public readonly struct ColorSrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorSrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
+            => PorterDuffFunctions.ColorSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestOver" straight-alpha composition equation.
+    /// Applies the "LuminositySrcIn" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestOver : IPixelBlenderOperator
+    public readonly struct LuminositySrcIn : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcIn(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestIn" straight-alpha composition equation.
+    /// Applies the "NormalSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestIn : IPixelBlenderOperator
+    public readonly struct NormalSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalDestIn(background, source, amount);
+            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalDestIn(background, source, amount);
+            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalDestIn(background, source, amount);
+            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestIn" straight-alpha composition equation.
+    /// Applies the "MultiplySrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestIn : IPixelBlenderOperator
+    public readonly struct MultiplySrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
+            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestIn" straight-alpha composition equation.
+    /// Applies the "AddSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestIn : IPixelBlenderOperator
+    public readonly struct AddSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddDestIn(background, source, amount);
+            => PorterDuffFunctions.AddSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddDestIn(background, source, amount);
+            => PorterDuffFunctions.AddSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddDestIn(background, source, amount);
+            => PorterDuffFunctions.AddSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestIn" straight-alpha composition equation.
+    /// Applies the "SubtractSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestIn : IPixelBlenderOperator
+    public readonly struct SubtractSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
+            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestIn" straight-alpha composition equation.
+    /// Applies the "ScreenSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestIn : IPixelBlenderOperator
+    public readonly struct ScreenSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
+            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestIn" straight-alpha composition equation.
+    /// Applies the "DarkenSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestIn : IPixelBlenderOperator
+    public readonly struct DarkenSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
+            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestIn" straight-alpha composition equation.
+    /// Applies the "LightenSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestIn : IPixelBlenderOperator
+    public readonly struct LightenSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenDestIn(background, source, amount);
+            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenDestIn(background, source, amount);
+            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenDestIn(background, source, amount);
+            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestIn" straight-alpha composition equation.
+    /// Applies the "OverlaySrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestIn : IPixelBlenderOperator
+    public readonly struct OverlaySrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
+            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestIn" straight-alpha composition equation.
+    /// Applies the "HardLightSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestIn : IPixelBlenderOperator
+    public readonly struct HardLightSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
+            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalDestOut" straight-alpha composition equation.
+    /// Applies the "ColorDodgeSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalDestOut : IPixelBlenderOperator
+    public readonly struct ColorDodgeSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyDestOut" straight-alpha composition equation.
+    /// Applies the "ColorBurnSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyDestOut : IPixelBlenderOperator
+    public readonly struct ColorBurnSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorBurnSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddDestOut" straight-alpha composition equation.
+    /// Applies the "SoftLightSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddDestOut : IPixelBlenderOperator
+    public readonly struct SoftLightSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddDestOut(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddDestOut(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddDestOut(background, source, amount);
+            => PorterDuffFunctions.SoftLightSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractDestOut" straight-alpha composition equation.
+    /// Applies the "DifferenceSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractDestOut : IPixelBlenderOperator
+    public readonly struct DifferenceSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
+            => PorterDuffFunctions.DifferenceSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenDestOut" straight-alpha composition equation.
+    /// Applies the "ExclusionSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenDestOut : IPixelBlenderOperator
+    public readonly struct ExclusionSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
+            => PorterDuffFunctions.ExclusionSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenDestOut" straight-alpha composition equation.
+    /// Applies the "HueSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenDestOut : IPixelBlenderOperator
+    public readonly struct HueSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
+            => PorterDuffFunctions.HueSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
+            => PorterDuffFunctions.HueSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
+            => PorterDuffFunctions.HueSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenDestOut" straight-alpha composition equation.
+    /// Applies the "SaturationSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenDestOut : IPixelBlenderOperator
+    public readonly struct SaturationSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenDestOut(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenDestOut(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenDestOut(background, source, amount);
+            => PorterDuffFunctions.SaturationSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayDestOut" straight-alpha composition equation.
+    /// Applies the "ColorSrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayDestOut : IPixelBlenderOperator
+    public readonly struct ColorSrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorSrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
+            => PorterDuffFunctions.ColorSrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightDestOut" straight-alpha composition equation.
+    /// Applies the "LuminositySrcOut" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightDestOut : IPixelBlenderOperator
+    public readonly struct LuminositySrcOut : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcOut(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
+            => PorterDuffFunctions.LuminositySrcOut(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalClear" straight-alpha composition equation.
+    /// Applies the "NormalDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalClear : IPixelBlenderOperator
+    public readonly struct NormalDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalClear(background, source, amount);
+            => PorterDuffFunctions.NormalDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalClear(background, source, amount);
+            => PorterDuffFunctions.NormalDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalClear(background, source, amount);
+            => PorterDuffFunctions.NormalDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyClear" straight-alpha composition equation.
+    /// Applies the "MultiplyDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyClear : IPixelBlenderOperator
+    public readonly struct MultiplyDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplyClear(background, source, amount);
+            => PorterDuffFunctions.MultiplyDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplyClear(background, source, amount);
+            => PorterDuffFunctions.MultiplyDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplyClear(background, source, amount);
+            => PorterDuffFunctions.MultiplyDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddClear" straight-alpha composition equation.
+    /// Applies the "AddDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddClear : IPixelBlenderOperator
+    public readonly struct AddDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddClear(background, source, amount);
+            => PorterDuffFunctions.AddDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddClear(background, source, amount);
+            => PorterDuffFunctions.AddDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddClear(background, source, amount);
+            => PorterDuffFunctions.AddDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractClear" straight-alpha composition equation.
+    /// Applies the "SubtractDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractClear : IPixelBlenderOperator
+    public readonly struct SubtractDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractClear(background, source, amount);
+            => PorterDuffFunctions.SubtractDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractClear(background, source, amount);
+            => PorterDuffFunctions.SubtractDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractClear(background, source, amount);
+            => PorterDuffFunctions.SubtractDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenClear" straight-alpha composition equation.
+    /// Applies the "ScreenDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenClear : IPixelBlenderOperator
+    public readonly struct ScreenDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenClear(background, source, amount);
+            => PorterDuffFunctions.ScreenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenClear(background, source, amount);
+            => PorterDuffFunctions.ScreenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenClear(background, source, amount);
+            => PorterDuffFunctions.ScreenDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenClear" straight-alpha composition equation.
+    /// Applies the "DarkenDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenClear : IPixelBlenderOperator
+    public readonly struct DarkenDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenClear(background, source, amount);
+            => PorterDuffFunctions.DarkenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenClear(background, source, amount);
+            => PorterDuffFunctions.DarkenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenClear(background, source, amount);
+            => PorterDuffFunctions.DarkenDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenClear" straight-alpha composition equation.
+    /// Applies the "LightenDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenClear : IPixelBlenderOperator
+    public readonly struct LightenDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenClear(background, source, amount);
+            => PorterDuffFunctions.LightenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenClear(background, source, amount);
+            => PorterDuffFunctions.LightenDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenClear(background, source, amount);
+            => PorterDuffFunctions.LightenDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayClear" straight-alpha composition equation.
+    /// Applies the "OverlayDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayClear : IPixelBlenderOperator
+    public readonly struct OverlayDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlayClear(background, source, amount);
+            => PorterDuffFunctions.OverlayDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlayClear(background, source, amount);
+            => PorterDuffFunctions.OverlayDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlayClear(background, source, amount);
+            => PorterDuffFunctions.OverlayDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightClear" straight-alpha composition equation.
+    /// Applies the "HardLightDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightClear : IPixelBlenderOperator
+    public readonly struct HardLightDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightClear(background, source, amount);
+            => PorterDuffFunctions.HardLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightClear(background, source, amount);
+            => PorterDuffFunctions.HardLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightClear(background, source, amount);
+            => PorterDuffFunctions.HardLightDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "NormalXor" straight-alpha composition equation.
+    /// Applies the "ColorDodgeDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct NormalXor : IPixelBlenderOperator
+    public readonly struct ColorDodgeDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.NormalXor(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.NormalXor(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.NormalXor(background, source, amount);
+            => PorterDuffFunctions.ColorDodgeDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "MultiplyXor" straight-alpha composition equation.
+    /// Applies the "ColorBurnDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct MultiplyXor : IPixelBlenderOperator
+    public readonly struct ColorBurnDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.MultiplyXor(background, source, amount);
+            => PorterDuffFunctions.ColorBurnDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.MultiplyXor(background, source, amount);
+            => PorterDuffFunctions.ColorBurnDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.MultiplyXor(background, source, amount);
+            => PorterDuffFunctions.ColorBurnDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "AddXor" straight-alpha composition equation.
+    /// Applies the "SoftLightDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct AddXor : IPixelBlenderOperator
+    public readonly struct SoftLightDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.AddXor(background, source, amount);
+            => PorterDuffFunctions.SoftLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.AddXor(background, source, amount);
+            => PorterDuffFunctions.SoftLightDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.AddXor(background, source, amount);
+            => PorterDuffFunctions.SoftLightDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "SubtractXor" straight-alpha composition equation.
+    /// Applies the "DifferenceDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct SubtractXor : IPixelBlenderOperator
+    public readonly struct DifferenceDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.SubtractXor(background, source, amount);
+            => PorterDuffFunctions.DifferenceDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.SubtractXor(background, source, amount);
+            => PorterDuffFunctions.DifferenceDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.SubtractXor(background, source, amount);
+            => PorterDuffFunctions.DifferenceDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "ScreenXor" straight-alpha composition equation.
+    /// Applies the "ExclusionDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct ScreenXor : IPixelBlenderOperator
+    public readonly struct ExclusionDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.ScreenXor(background, source, amount);
+            => PorterDuffFunctions.ExclusionDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.ScreenXor(background, source, amount);
+            => PorterDuffFunctions.ExclusionDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.ScreenXor(background, source, amount);
+            => PorterDuffFunctions.ExclusionDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "DarkenXor" straight-alpha composition equation.
+    /// Applies the "HueDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct DarkenXor : IPixelBlenderOperator
+    public readonly struct HueDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.DarkenXor(background, source, amount);
+            => PorterDuffFunctions.HueDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.DarkenXor(background, source, amount);
+            => PorterDuffFunctions.HueDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.DarkenXor(background, source, amount);
+            => PorterDuffFunctions.HueDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "LightenXor" straight-alpha composition equation.
+    /// Applies the "SaturationDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct LightenXor : IPixelBlenderOperator
+    public readonly struct SaturationDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.LightenXor(background, source, amount);
+            => PorterDuffFunctions.SaturationDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.LightenXor(background, source, amount);
+            => PorterDuffFunctions.SaturationDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.LightenXor(background, source, amount);
+            => PorterDuffFunctions.SaturationDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "OverlayXor" straight-alpha composition equation.
+    /// Applies the "ColorDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct OverlayXor : IPixelBlenderOperator
+    public readonly struct ColorDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.OverlayXor(background, source, amount);
+            => PorterDuffFunctions.ColorDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.OverlayXor(background, source, amount);
+            => PorterDuffFunctions.ColorDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.OverlayXor(background, source, amount);
+            => PorterDuffFunctions.ColorDest(background, source, amount);
     }
 
     /// <summary>
-    /// Applies the "HardLightXor" straight-alpha composition equation.
+    /// Applies the "LuminosityDest" straight-alpha composition equation.
     /// </summary>
-    public readonly struct HardLightXor : IPixelBlenderOperator
+    public readonly struct LuminosityDest : IPixelBlenderOperator
     {
         /// <inheritdoc />
         public static bool IsAssociatedAlpha => false;
 
         /// <inheritdoc />
         public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
-            => PorterDuffFunctions.HardLightXor(background, source, amount);
+            => PorterDuffFunctions.LuminosityDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
-            => PorterDuffFunctions.HardLightXor(background, source, amount);
+            => PorterDuffFunctions.LuminosityDest(background, source, amount);
 
         /// <inheritdoc />
         public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
-            => PorterDuffFunctions.HardLightXor(background, source, amount);
+            => PorterDuffFunctions.LuminosityDest(background, source, amount);
     }
 
-}
-
-/// <summary>
-/// Provides straight-alpha pixel blenders for each color and alpha composition pair.
-/// </summary>
-/// <typeparam name="TPixel">The destination pixel format.</typeparam>
-internal static class DefaultPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
-{
     /// <summary>
-    /// Gets the shared blender for the "NormalSrc" composition equation.
+    /// Applies the "NormalDestAtop" straight-alpha composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> NormalSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.NormalSrc>.Instance;
+    public readonly struct NormalDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
 
-    /// <summary>
-    /// Gets the shared blender for the "MultiplySrc" composition equation.
-    /// </summary>
-    public static PixelBlender<TPixel> MultiplySrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplySrc>.Instance;
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-    /// <summary>
-    /// Gets the shared blender for the "AddSrc" composition equation.
-    /// </summary>
-    public static PixelBlender<TPixel> AddSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrc>.Instance;
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-    /// <summary>
-    /// Gets the shared blender for the "SubtractSrc" composition equation.
-    /// </summary>
-    public static PixelBlender<TPixel> SubtractSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrc>.Instance;
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
+    }
 
     /// <summary>
-    /// Gets the shared blender for the "ScreenSrc" composition equation.
+    /// Applies the "MultiplyDestAtop" straight-alpha composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> ScreenSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrc>.Instance;
+    public readonly struct MultiplyDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
 
-    /// <summary>
-    /// Gets the shared blender for the "DarkenSrc" composition equation.
-    /// </summary>
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.AddDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.AddDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDodgeDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorBurnDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorBurnDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorBurnDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SoftLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SoftLightDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SoftLightDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DifferenceDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DifferenceDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DifferenceDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ExclusionDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ExclusionDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ExclusionDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HueDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HueDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HueDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SaturationDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SaturationDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SaturationDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LuminosityDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LuminosityDestAtop(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LuminosityDestAtop(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.AddDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.AddDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDodgeDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorBurnDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorBurnDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorBurnDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SoftLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SoftLightDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SoftLightDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DifferenceDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DifferenceDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DifferenceDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ExclusionDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ExclusionDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ExclusionDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HueDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HueDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HueDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SaturationDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SaturationDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SaturationDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LuminosityDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LuminosityDestOver(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LuminosityDestOver(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.AddDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.AddDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDodgeDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorBurnDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorBurnDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorBurnDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SoftLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SoftLightDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SoftLightDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DifferenceDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DifferenceDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DifferenceDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ExclusionDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ExclusionDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ExclusionDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HueDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HueDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HueDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SaturationDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SaturationDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SaturationDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LuminosityDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LuminosityDestIn(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LuminosityDestIn(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.AddDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.AddDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDodgeDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDodgeDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorBurnDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorBurnDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorBurnDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SoftLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SoftLightDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SoftLightDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DifferenceDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DifferenceDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DifferenceDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ExclusionDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ExclusionDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ExclusionDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HueDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HueDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HueDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HueDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SaturationDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SaturationDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SaturationDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LuminosityDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LuminosityDestOut(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LuminosityDestOut(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.NormalClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.NormalClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.AddClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.AddClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SubtractClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SubtractClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ScreenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ScreenClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DarkenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DarkenClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LightenClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LightenClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.OverlayClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.OverlayClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HardLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HardLightClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDodgeClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDodgeClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDodgeClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorBurnClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorBurnClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorBurnClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SoftLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SoftLightClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SoftLightClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DifferenceClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DifferenceClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DifferenceClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ExclusionClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ExclusionClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ExclusionClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HueClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HueClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HueClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HueClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SaturationClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SaturationClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SaturationClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LuminosityClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LuminosityClear(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LuminosityClear(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.NormalXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.NormalXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.AddXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.AddXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SubtractXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SubtractXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ScreenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ScreenXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DarkenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DarkenXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LightenXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LightenXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.OverlayXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.OverlayXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HardLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HardLightXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgeXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgeXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDodgeXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDodgeXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDodgeXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorBurnXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorBurnXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorBurnXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SoftLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SoftLightXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SoftLightXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferenceXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferenceXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DifferenceXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DifferenceXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DifferenceXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ExclusionXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ExclusionXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ExclusionXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HueXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HueXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HueXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HueXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HueXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SaturationXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SaturationXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SaturationXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LuminosityXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LuminosityXor(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LuminosityXor(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "NormalPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.NormalPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.NormalPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "MultiplyPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "AddPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.AddPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.AddPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SubtractPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SubtractPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SubtractPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ScreenPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ScreenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ScreenPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DarkenPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DarkenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DarkenPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LightenPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LightenPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LightenPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "OverlayPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.OverlayPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.OverlayPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HardLightPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HardLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HardLightPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorDodgePlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorDodgePlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorDodgePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorDodgePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorDodgePlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorBurnPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorBurnPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorBurnPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorBurnPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorBurnPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SoftLightPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SoftLightPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SoftLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SoftLightPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SoftLightPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "DifferencePlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DifferencePlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DifferencePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.DifferencePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.DifferencePlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ExclusionPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ExclusionPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ExclusionPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ExclusionPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ExclusionPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "HuePlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HuePlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HuePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.HuePlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.HuePlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "SaturationPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SaturationPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SaturationPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.SaturationPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.SaturationPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "ColorPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ColorPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ColorPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.ColorPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.ColorPlus(background, source, amount);
+    }
+
+    /// <summary>
+    /// Applies the "LuminosityPlus" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LuminosityPlus : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static bool IsAssociatedAlpha => false;
+
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LuminosityPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(Vector256<float> background, Vector256<float> source, Vector256<float> amount)
+            => PorterDuffFunctions.LuminosityPlus(background, source, amount);
+
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(Vector512<float> background, Vector512<float> source, Vector512<float> amount)
+            => PorterDuffFunctions.LuminosityPlus(background, source, amount);
+    }
+
+}
+
+/// <summary>
+/// Provides straight-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The destination pixel format.</typeparam>
+internal static class DefaultPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    /// <summary>
+    /// Gets the shared blender for the "NormalSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> NormalSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.NormalSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "MultiplySrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> MultiplySrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplySrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "AddSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> AddSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SubtractSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SubtractSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ScreenSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ScreenSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DarkenSrc" composition equation.
+    /// </summary>
     public static PixelBlender<TPixel> DarkenSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrc>.Instance;
 
     /// <summary>
@@ -2334,6 +4980,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrc>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorSrc>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrc" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrc => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminositySrc>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcAtop" composition equation.
     /// </summary>
@@ -2379,6 +5070,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcAtop>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorSrcAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrcAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrcAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminositySrcAtop>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcOver" composition equation.
     /// </summary>
@@ -2424,6 +5160,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcOver>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorSrcOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrcOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrcOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminositySrcOver>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcIn" composition equation.
     /// </summary>
@@ -2469,6 +5250,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcIn>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorSrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorSrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorSrcIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminositySrcIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminositySrcIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminositySrcIn>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalSrcOut" composition equation.
     /// </summary>
@@ -2482,37 +5308,82 @@ internal static class DefaultPixelBlenders<TPixel>
     /// <summary>
     /// Gets the shared blender for the "AddSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> AddSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrcOut>.Instance;
+    public static PixelBlender<TPixel> AddSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SubtractSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SubtractSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ScreenSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ScreenSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DarkenSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DarkenSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LightenSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LightenSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.LightenSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "OverlaySrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> OverlaySrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.OverlaySrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HardLightSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HardLightSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnSrcOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightSrcOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "SubtractSrcOut" composition equation.
+    /// Gets the shared blender for the "DifferenceSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> SubtractSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrcOut>.Instance;
+    public static PixelBlender<TPixel> DifferenceSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "ScreenSrcOut" composition equation.
+    /// Gets the shared blender for the "ExclusionSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> ScreenSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrcOut>.Instance;
+    public static PixelBlender<TPixel> ExclusionSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "DarkenSrcOut" composition equation.
+    /// Gets the shared blender for the "HueSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> DarkenSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrcOut>.Instance;
+    public static PixelBlender<TPixel> HueSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "LightenSrcOut" composition equation.
+    /// Gets the shared blender for the "SaturationSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> LightenSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.LightenSrcOut>.Instance;
+    public static PixelBlender<TPixel> SaturationSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "OverlaySrcOut" composition equation.
+    /// Gets the shared blender for the "ColorSrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> OverlaySrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.OverlaySrcOut>.Instance;
+    public static PixelBlender<TPixel> ColorSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorSrcOut>.Instance;
 
     /// <summary>
-    /// Gets the shared blender for the "HardLightSrcOut" composition equation.
+    /// Gets the shared blender for the "LuminositySrcOut" composition equation.
     /// </summary>
-    public static PixelBlender<TPixel> HardLightSrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcOut>.Instance;
+    public static PixelBlender<TPixel> LuminositySrcOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminositySrcOut>.Instance;
 
     /// <summary>
     /// Gets the shared blender for the "NormalDest" composition equation.
@@ -2559,6 +5430,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDest>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDest>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDest" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDest => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityDest>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestAtop" composition equation.
     /// </summary>
@@ -2604,6 +5520,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestAtop>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDestAtop>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestAtop" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestAtop => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityDestAtop>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestOver" composition equation.
     /// </summary>
@@ -2649,6 +5610,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestOver>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDestOver>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestOver" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestOver => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityDestOver>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestIn" composition equation.
     /// </summary>
@@ -2694,6 +5700,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestIn>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDestIn>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestIn" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestIn => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityDestIn>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalDestOut" composition equation.
     /// </summary>
@@ -2739,6 +5790,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestOut>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDestOut>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityDestOut" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityDestOut => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityDestOut>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalClear" composition equation.
     /// </summary>
@@ -2784,6 +5880,51 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightClear>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorClear>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityClear" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityClear => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityClear>.Instance;
+
     /// <summary>
     /// Gets the shared blender for the "NormalXor" composition equation.
     /// </summary>
@@ -2829,4 +5970,139 @@ internal static class DefaultPixelBlenders<TPixel>
     /// </summary>
     public static PixelBlender<TPixel> HardLightXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightXor>.Instance;
 
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgeXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgeXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgeXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferenceXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferenceXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferenceXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HueXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HueXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.HueXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityXor" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityXor => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityXor>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "NormalPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> NormalPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.NormalPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "MultiplyPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> MultiplyPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "AddPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> AddPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.AddPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SubtractPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SubtractPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ScreenPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ScreenPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DarkenPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DarkenPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LightenPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LightenPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.LightenPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "OverlayPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> OverlayPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HardLightPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HardLightPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorDodgePlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorDodgePlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorDodgePlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorBurnPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorBurnPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorBurnPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SoftLightPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SoftLightPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.SoftLightPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "DifferencePlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> DifferencePlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.DifferencePlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ExclusionPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ExclusionPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.ExclusionPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "HuePlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> HuePlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.HuePlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "SaturationPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> SaturationPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.SaturationPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "ColorPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> ColorPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.ColorPlus>.Instance;
+
+    /// <summary>
+    /// Gets the shared blender for the "LuminosityPlus" composition equation.
+    /// </summary>
+    public static PixelBlender<TPixel> LuminosityPlus => PixelBlender<TPixel, DefaultPixelBlenderOperators.LuminosityPlus>.Instance;
+
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
index e9bdbaf3c..8dc9fe564 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
@@ -29,6 +29,7 @@ var composers = new []
     "DestOut",
     "Clear",
     "Xor",
+    "Plus",
 };
 
 var blenders = new []
@@ -42,6 +43,15 @@ var blenders = new []
     "Lighten",
     "Overlay",
     "HardLight",
+    "ColorDodge",
+    "ColorBurn",
+    "SoftLight",
+    "Difference",
+    "Exclusion",
+    "Hue",
+    "Saturation",
+    "Color",
+    "Luminosity",
 };
 #>
 /// <summary>
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
index 262370cd5..138249fbd 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
@@ -454,6 +454,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> NormalXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "NormalPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 NormalPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Normal(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "NormalPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> NormalPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Normal(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "NormalPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> NormalPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Normal(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "NormalClear" compositing equation.
     /// </summary>
@@ -684,6 +729,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(NormalXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "NormalPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel NormalPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(NormalPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "MultiplySrc" compositing equation.
     /// </summary>
@@ -1125,6 +1186,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> MultiplyXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "MultiplyPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 MultiplyPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Multiply(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "MultiplyPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Multiply(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "MultiplyPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Multiply(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "MultiplyClear" compositing equation.
     /// </summary>
@@ -1355,6 +1461,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(MultiplyXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "MultiplyPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel MultiplyPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(MultiplyPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "AddSrc" compositing equation.
     /// </summary>
@@ -1796,6 +1918,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> AddXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "AddPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 AddPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Add(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "AddPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> AddPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Add(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "AddPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> AddPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Add(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "AddClear" compositing equation.
     /// </summary>
@@ -2026,6 +2193,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(AddXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "AddPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel AddPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(AddPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "SubtractSrc" compositing equation.
     /// </summary>
@@ -2467,6 +2650,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> SubtractXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "SubtractPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SubtractPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Subtract(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SubtractPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SubtractPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Subtract(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SubtractPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SubtractPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Subtract(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "SubtractClear" compositing equation.
     /// </summary>
@@ -2697,6 +2925,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(SubtractXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "SubtractPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SubtractPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SubtractPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "ScreenSrc" compositing equation.
     /// </summary>
@@ -3138,6 +3382,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> ScreenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "ScreenPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ScreenPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Screen(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ScreenPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ScreenPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Screen(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ScreenPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ScreenPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Screen(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "ScreenClear" compositing equation.
     /// </summary>
@@ -3368,6 +3657,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(ScreenXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "ScreenPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ScreenPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ScreenPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "DarkenSrc" compositing equation.
     /// </summary>
@@ -3810,33 +4115,78 @@ internal static partial class PorterDuffFunctions
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
     /// <summary>
-    /// Returns the result of the "DarkenClear" compositing equation.
+    /// Returns the result of the "DarkenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The backdrop vector.</param>
     /// <param name="source">The source vector.</param>
     /// <param name="opacity">The source opacity. Range 0..1</param>
     /// <returns>The <see cref="Vector4"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector4 DarkenClear(Vector4 backdrop, Vector4 source, float opacity)
+    public static Vector4 DarkenPlus(Vector4 backdrop, Vector4 source, float opacity)
     {
         source = Numerics.WithW(source, source * opacity);
 
-        return Clear(backdrop, source);
+        return Plus(backdrop, source, Darken(backdrop, source));
     }
 
     /// <summary>
-    /// Returns the result of the "DarkenClear" compositing equation.
+    /// Returns the result of the "DarkenPlus" compositing equation.
     /// </summary>
     /// <param name="backdrop">The backdrop vector.</param>
     /// <param name="source">The source vector.</param>
     /// <param name="opacity">The source opacity. Range 0..1</param>
     /// <returns>The <see cref="Vector256{Single}"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> DarkenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
-        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+    public static Vector256<float> DarkenPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Darken(backdrop, source));
+    }
 
     /// <summary>
-    /// Returns the result of the "DarkenClear" compositing equation.
+    /// Returns the result of the "DarkenPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DarkenPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Darken(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DarkenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DarkenClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "DarkenClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DarkenClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "DarkenClear" compositing equation.
     /// </summary>
     /// <param name="backdrop">The backdrop vector.</param>
     /// <param name="source">The source vector.</param>
@@ -4039,6 +4389,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(DarkenXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "DarkenPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DarkenPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DarkenPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "LightenSrc" compositing equation.
     /// </summary>
@@ -4480,6 +4846,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> LightenXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "LightenPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LightenPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Lighten(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LightenPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LightenPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Lighten(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LightenPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LightenPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Lighten(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "LightenClear" compositing equation.
     /// </summary>
@@ -4710,6 +5121,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(LightenXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "LightenPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LightenPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LightenPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "OverlaySrc" compositing equation.
     /// </summary>
@@ -5151,6 +5578,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> OverlayXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "OverlayPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 OverlayPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Overlay(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "OverlayPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> OverlayPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Overlay(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "OverlayPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> OverlayPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Overlay(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "OverlayClear" compositing equation.
     /// </summary>
@@ -5381,6 +5853,22 @@ internal static partial class PorterDuffFunctions
         return TPixel.FromUnassociatedScaledVector4(OverlayXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
 
+    /// <summary>
+    /// Returns the result of the "OverlayPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel OverlayPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(OverlayPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
     /// <summary>
     /// Returns the result of the "HardLightSrc" compositing equation.
     /// </summary>
@@ -5822,6 +6310,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> HardLightXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "HardLightPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HardLightPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, HardLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HardLightPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HardLightPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, HardLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HardLightPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HardLightPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, HardLight(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "HardLightClear" compositing equation.
     /// </summary>
@@ -6051,4 +6584,6608 @@ internal static partial class PorterDuffFunctions
         opacity = Numerics.Clamp(opacity, 0, 1);
         return TPixel.FromUnassociatedScaledVector4(HardLightXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
     }
+
+    /// <summary>
+    /// Returns the result of the "HardLightPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HardLightPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HardLightPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, ColorDodge(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgePlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgePlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgePlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, ColorDodge(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodgeClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodgeClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodgeClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgeXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgeXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgeXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDodgePlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDodgePlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDodgePlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, ColorBurn(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, ColorBurn(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurnClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurnClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurnClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurnPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorBurnPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorBurnPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, SoftLight(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SoftLightXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SoftLightXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "SoftLightPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, SoftLight(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLightClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLightClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SoftLightClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLightClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLightPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SoftLightPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SoftLightPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, Difference(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "DifferenceXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "DifferenceXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "DifferencePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferencePlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferencePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferencePlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferencePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferencePlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Difference(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 DifferenceClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> DifferenceClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "DifferenceClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> DifferenceClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferenceXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferenceXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferenceXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "DifferencePlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel DifferencePlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(DifferencePlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, Exclusion(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ExclusionXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ExclusionXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ExclusionPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Exclusion(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ExclusionClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ExclusionClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ExclusionClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ExclusionClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ExclusionPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ExclusionPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ExclusionPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "HueSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "HueSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "HueSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "HueDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, Hue(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "HueDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "HueDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "HueDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "HueXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "HueXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "HuePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HuePlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HuePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HuePlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HuePlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HuePlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Hue(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 HueClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> HueClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "HueClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> HueClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "HueSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HueXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HueXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HueXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "HuePlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel HuePlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(HuePlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "SaturationDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, Saturation(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "SaturationXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SaturationXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "SaturationPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Saturation(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SaturationClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SaturationClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "SaturationClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SaturationClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "SaturationPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel SaturationPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(SaturationPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorSrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorSrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "ColorSrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorSrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorSrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorSrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorSrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorSrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorSrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorSrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorSrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorSrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorSrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorSrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorSrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, Color(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "ColorXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "ColorPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Color(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "ColorClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "ColorSrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorSrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorSrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorSrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorSrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorSrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorSrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(ColorPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrc" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminositySrc(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return source;
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminositySrc(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrc compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminositySrc(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminositySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminositySrcAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminositySrcAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminositySrcOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminositySrcOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminositySrcOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminositySrcIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminositySrcIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminositySrcIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminositySrcOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminositySrcOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminositySrcOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDest(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDest(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDest" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDest(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        return backdrop;
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestAtop(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Atop(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestAtop(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Atop(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestAtop" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestAtop(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Atop(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestOver(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Over(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestOver(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Over(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOver" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestOver(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Over(source, backdrop, Luminosity(source, backdrop));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestIn(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return In(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestIn(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => In(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestIn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestIn(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => In(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityDestOut(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Out(source, backdrop);
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityDestOut(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Out(Avx.Blend(source, source * opacity, BlendAlphaControl), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOut" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityDestOut(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Out(Avx512F.BlendVariable(source, source * opacity, AlphaMask512()), backdrop);
+
+    /// <summary>
+    /// Returns the result of the "LuminosityXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityXor(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Xor(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityXor(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Xor(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "LuminosityXor" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityXor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+    /// <summary>
+    /// Returns the result of the "LuminosityPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityPlus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityPlus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityPlus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityPlus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, Luminosity(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 LuminosityClear(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Clear(backdrop, source);
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> LuminosityClear(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+        => Clear(backdrop, Avx.Blend(source, source * opacity, BlendAlphaControl));
+
+    /// <summary>
+    /// Returns the result of the "LuminosityClear" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> LuminosityClear(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+        => Clear(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
+
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrc" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminositySrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminositySrc(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminositySrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminositySrcAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminositySrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminositySrcOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminositySrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminositySrcIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminositySrcOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminositySrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminositySrcOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDest" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityDest(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestAtop" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityDestAtop(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOver" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityDestOver(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestIn" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityDestIn(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityDestOut" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityDestOut(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityClear" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityClear(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityXor" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityXor(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
+
+    /// <summary>
+    /// Returns the result of the "LuminosityPlus" compositing equation.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <typeparamref name="TPixel"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel LuminosityPlus<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        opacity = Numerics.Clamp(opacity, 0, 1);
+        return TPixel.FromUnassociatedScaledVector4(LuminosityPlus(backdrop.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), opacity));
+    }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
index 8837a90a3..3ee0e133c 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
@@ -464,6 +464,51 @@ internal static partial class PorterDuffFunctions
     public static Vector512<float> <#=blender#>Xor(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
         => Xor(backdrop, Avx512F.BlendVariable(source, source * opacity, AlphaMask512()));
 
+    /// <summary>
+    /// Returns the result of the "<#=blender#>Plus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 <#=blender#>Plus(Vector4 backdrop, Vector4 source, float opacity)
+    {
+        source = Numerics.WithW(source, source * opacity);
+
+        return Plus(backdrop, source, <#=blender#>(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "<#=blender#>Plus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> <#=blender#>Plus(Vector256<float> backdrop, Vector256<float> source, Vector256<float> opacity)
+    {
+        source = Avx.Blend(source, source * opacity, BlendAlphaControl);
+
+        return Plus(backdrop, source, <#=blender#>(backdrop, source));
+    }
+
+    /// <summary>
+    /// Returns the result of the "<#=blender#>Plus" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="opacity">The source opacity. Range 0..1</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> <#=blender#>Plus(Vector512<float> backdrop, Vector512<float> source, Vector512<float> opacity)
+    {
+        source = Avx512F.BlendVariable(source, source * opacity, AlphaMask512());
+
+        return Plus(backdrop, source, <#=blender#>(backdrop, source));
+    }
+
     /// <summary>
     /// Returns the result of the "<#=blender#>Clear" compositing equation.
     /// </summary>
@@ -535,6 +580,7 @@ var composers = new []{
     "DestOut",
     "Clear",
     "Xor",
+    "Plus",
 };
 
 var blenders = new []{
@@ -546,7 +592,16 @@ var blenders = new []{
     "Darken",
     "Lighten",
     "Overlay",
-    "HardLight"
+    "HardLight",
+    "ColorDodge",
+    "ColorBurn",
+    "SoftLight",
+    "Difference",
+    "Exclusion",
+    "Hue",
+    "Saturation",
+    "Color",
+    "Luminosity",
 };
 
 foreach(var blender in blenders)
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
index 46d97ad3d..4b048a6f4 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
@@ -324,6 +324,252 @@ internal static partial class PorterDuffFunctions
         return Vector512.Min(Vector512.Create(1F), Vector512.ConditionalSelect(AlphaMask512(), Vector512<float>.Zero, color));
     }
 
+    /// <summary>
+    /// Returns the result of the "ColorDodge" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorDodge(Vector4 backdrop, Vector4 source)
+        => new(
+            ColorDodgeValue(backdrop.X, source.X),
+            ColorDodgeValue(backdrop.Y, source.Y),
+            ColorDodgeValue(backdrop.Z, source.Z),
+            0F);
+
+    /// <inheritdoc cref="ColorDodge(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorDodge(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> one = Vector256.Create(1F);
+        Vector256<float> result = Vector256.Min(one, backdrop / (one - source));
+
+        // The explicit singular cases avoid the undefined 0 / 0 result while preserving the order required by the specification.
+        result = Avx.BlendVariable(result, one, Avx.CompareEqual(source, one));
+        result = Avx.BlendVariable(result, Vector256<float>.Zero, Avx.CompareEqual(backdrop, Vector256<float>.Zero));
+        return Avx.Blend(result, Vector256<float>.Zero, BlendAlphaControl);
+    }
+
+    /// <inheritdoc cref="ColorDodge(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorDodge(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> one = Vector512.Create(1F);
+        Vector512<float> result = Vector512.Min(one, backdrop / (one - source));
+        result = Vector512.ConditionalSelect(Vector512.Equals(source, one), one, result);
+        result = Vector512.ConditionalSelect(Vector512.Equals(backdrop, Vector512<float>.Zero), Vector512<float>.Zero, result);
+        return Vector512.ConditionalSelect(AlphaMask512(), Vector512<float>.Zero, result);
+    }
+
+    /// <summary>
+    /// Returns the result of the "ColorBurn" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 ColorBurn(Vector4 backdrop, Vector4 source)
+        => new(
+            ColorBurnValue(backdrop.X, source.X),
+            ColorBurnValue(backdrop.Y, source.Y),
+            ColorBurnValue(backdrop.Z, source.Z),
+            0F);
+
+    /// <inheritdoc cref="ColorBurn(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> ColorBurn(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> one = Vector256.Create(1F);
+        Vector256<float> result = one - Vector256.Min(one, (one - backdrop) / source);
+
+        // As with ColorDodge, resolve the branch singularities explicitly so transparent lanes never produce NaN.
+        result = Avx.BlendVariable(result, Vector256<float>.Zero, Avx.CompareEqual(source, Vector256<float>.Zero));
+        result = Avx.BlendVariable(result, one, Avx.CompareEqual(backdrop, one));
+        return Avx.Blend(result, Vector256<float>.Zero, BlendAlphaControl);
+    }
+
+    /// <inheritdoc cref="ColorBurn(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> ColorBurn(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> one = Vector512.Create(1F);
+        Vector512<float> result = one - Vector512.Min(one, (one - backdrop) / source);
+        result = Vector512.ConditionalSelect(Vector512.Equals(source, Vector512<float>.Zero), Vector512<float>.Zero, result);
+        result = Vector512.ConditionalSelect(Vector512.Equals(backdrop, one), one, result);
+        return Vector512.ConditionalSelect(AlphaMask512(), Vector512<float>.Zero, result);
+    }
+
+    /// <summary>
+    /// Returns the result of the "SoftLight" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 SoftLight(Vector4 backdrop, Vector4 source)
+        => new(
+            SoftLightValue(backdrop.X, source.X),
+            SoftLightValue(backdrop.Y, source.Y),
+            SoftLightValue(backdrop.Z, source.Z),
+            0F);
+
+    /// <inheritdoc cref="SoftLight(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> SoftLight(Vector256<float> backdrop, Vector256<float> source)
+    {
+        Vector256<float> one = Vector256.Create(1F);
+        Vector256<float> two = Vector256.Create(2F);
+        Vector256<float> dark = backdrop - ((one - (two * source)) * backdrop * (one - backdrop));
+        Vector256<float> polynomial = ((((Vector256.Create(16F) * backdrop) - Vector256.Create(12F)) * backdrop) + Vector256.Create(4F)) * backdrop;
+        Vector256<float> d = Avx.BlendVariable(polynomial, Avx.Sqrt(backdrop), Avx.CompareGreaterThan(backdrop, Vector256.Create(.25F)));
+        Vector256<float> light = backdrop + (((two * source) - one) * (d - backdrop));
+        Vector256<float> result = Avx.BlendVariable(dark, light, Avx.CompareGreaterThan(source, Vector256.Create(.5F)));
+        return Avx.Blend(result, Vector256<float>.Zero, BlendAlphaControl);
+    }
+
+    /// <inheritdoc cref="SoftLight(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> SoftLight(Vector512<float> backdrop, Vector512<float> source)
+    {
+        Vector512<float> one = Vector512.Create(1F);
+        Vector512<float> two = Vector512.Create(2F);
+        Vector512<float> dark = backdrop - ((one - (two * source)) * backdrop * (one - backdrop));
+        Vector512<float> polynomial = ((((Vector512.Create(16F) * backdrop) - Vector512.Create(12F)) * backdrop) + Vector512.Create(4F)) * backdrop;
+        Vector512<float> d = Vector512.ConditionalSelect(Avx512F.CompareGreaterThan(backdrop, Vector512.Create(.25F)), Vector512.Sqrt(backdrop), polynomial);
+        Vector512<float> light = backdrop + (((two * source) - one) * (d - backdrop));
+        Vector512<float> result = Vector512.ConditionalSelect(Avx512F.CompareGreaterThan(source, Vector512.Create(.5F)), light, dark);
+        return Vector512.ConditionalSelect(AlphaMask512(), Vector512<float>.Zero, result);
+    }
+
+    /// <summary>
+    /// Returns the result of the "Difference" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Difference(Vector4 backdrop, Vector4 source)
+        => Vector4.Abs(backdrop - source);
+
+    /// <inheritdoc cref="Difference(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Difference(Vector256<float> backdrop, Vector256<float> source)
+        => Vector256.Abs(backdrop - source);
+
+    /// <inheritdoc cref="Difference(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Difference(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Abs(backdrop - source);
+
+    /// <summary>
+    /// Returns the result of the "Exclusion" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Exclusion(Vector4 backdrop, Vector4 source)
+        => backdrop + source - (2F * backdrop * source);
+
+    /// <inheritdoc cref="Exclusion(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Exclusion(Vector256<float> backdrop, Vector256<float> source)
+        => backdrop + source - (Vector256.Create(2F) * backdrop * source);
+
+    /// <inheritdoc cref="Exclusion(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Exclusion(Vector512<float> backdrop, Vector512<float> source)
+        => backdrop + source - (Vector512.Create(2F) * backdrop * source);
+
+    /// <summary>
+    /// Returns the result of the "Hue" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Hue(Vector4 backdrop, Vector4 source)
+        => SetLuminosity(SetSaturation(source, Saturation(backdrop)), Luminosity(backdrop));
+
+    /// <inheritdoc cref="Hue(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Hue(Vector256<float> backdrop, Vector256<float> source)
+        => Vector256.Create(
+            Hue(backdrop.GetLower().AsVector4(), source.GetLower().AsVector4()).AsVector128(),
+            Hue(backdrop.GetUpper().AsVector4(), source.GetUpper().AsVector4()).AsVector128());
+
+    /// <inheritdoc cref="Hue(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Hue(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Create(Hue(backdrop.GetLower(), source.GetLower()), Hue(backdrop.GetUpper(), source.GetUpper()));
+
+    /// <summary>
+    /// Returns the result of the "Saturation" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Saturation(Vector4 backdrop, Vector4 source)
+        => SetLuminosity(SetSaturation(backdrop, Saturation(source)), Luminosity(backdrop));
+
+    /// <inheritdoc cref="Saturation(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Saturation(Vector256<float> backdrop, Vector256<float> source)
+        => Vector256.Create(
+            Saturation(backdrop.GetLower().AsVector4(), source.GetLower().AsVector4()).AsVector128(),
+            Saturation(backdrop.GetUpper().AsVector4(), source.GetUpper().AsVector4()).AsVector128());
+
+    /// <inheritdoc cref="Saturation(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Saturation(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Create(Saturation(backdrop.GetLower(), source.GetLower()), Saturation(backdrop.GetUpper(), source.GetUpper()));
+
+    /// <summary>
+    /// Returns the result of the "Color" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Color(Vector4 backdrop, Vector4 source)
+        => SetLuminosity(source, Luminosity(backdrop));
+
+    /// <inheritdoc cref="Color(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Color(Vector256<float> backdrop, Vector256<float> source)
+        => Vector256.Create(
+            Color(backdrop.GetLower().AsVector4(), source.GetLower().AsVector4()).AsVector128(),
+            Color(backdrop.GetUpper().AsVector4(), source.GetUpper().AsVector4()).AsVector128());
+
+    /// <inheritdoc cref="Color(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Color(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Create(Color(backdrop.GetLower(), source.GetLower()), Color(backdrop.GetUpper(), source.GetUpper()));
+
+    /// <summary>
+    /// Returns the result of the "Luminosity" compositing equation.
+    /// </summary>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <returns>The blended color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Luminosity(Vector4 backdrop, Vector4 source)
+        => SetLuminosity(backdrop, Luminosity(source));
+
+    /// <inheritdoc cref="Luminosity(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Luminosity(Vector256<float> backdrop, Vector256<float> source)
+        => Vector256.Create(
+            Luminosity(backdrop.GetLower().AsVector4(), source.GetLower().AsVector4()).AsVector128(),
+            Luminosity(backdrop.GetUpper().AsVector4(), source.GetUpper().AsVector4()).AsVector128());
+
+    /// <inheritdoc cref="Luminosity(Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Luminosity(Vector512<float> backdrop, Vector512<float> source)
+        => Vector512.Create(Luminosity(backdrop.GetLower(), source.GetLower()), Luminosity(backdrop.GetUpper(), source.GetUpper()));
+
     /// <summary>
     /// Applies raster coverage to a Porter-Duff composition result.
     /// </summary>
@@ -385,6 +631,113 @@ internal static partial class PorterDuffFunctions
         return Numerics.UnPremultiply(result, Vector512_.ShuffleNative(result, ShuffleAlphaControl));
     }
 
+    /// <summary>
+    /// Calculates one ColorDodge component, including the singular cases defined by the blending model.
+    /// </summary>
+    /// <param name="backdrop">The backdrop component.</param>
+    /// <param name="source">The source component.</param>
+    /// <returns>The blended component.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float ColorDodgeValue(float backdrop, float source)
+        => backdrop == 0F ? 0F : source == 1F ? 1F : MathF.Min(1F, backdrop / (1F - source));
+
+    /// <summary>
+    /// Calculates one ColorBurn component, including the singular cases defined by the blending model.
+    /// </summary>
+    /// <param name="backdrop">The backdrop component.</param>
+    /// <param name="source">The source component.</param>
+    /// <returns>The blended component.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float ColorBurnValue(float backdrop, float source)
+        => backdrop == 1F ? 1F : source == 0F ? 0F : 1F - MathF.Min(1F, (1F - backdrop) / source);
+
+    /// <summary>
+    /// Calculates one SoftLight component.
+    /// </summary>
+    /// <param name="backdrop">The backdrop component.</param>
+    /// <param name="source">The source component.</param>
+    /// <returns>The blended component.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float SoftLightValue(float backdrop, float source)
+    {
+        if (source <= .5F)
+        {
+            return backdrop - ((1F - (2F * source)) * backdrop * (1F - backdrop));
+        }
+
+        // The cubic segment joins the square-root segment smoothly while avoiding its steep slope near zero.
+        float d = backdrop <= .25F
+            ? (((((16F * backdrop) - 12F) * backdrop) + 4F) * backdrop)
+            : MathF.Sqrt(backdrop);
+
+        return backdrop + (((2F * source) - 1F) * (d - backdrop));
+    }
+
+    /// <summary>
+    /// Calculates the saturation of an RGB color.
+    /// </summary>
+    /// <param name="color">The color.</param>
+    /// <returns>The difference between the maximum and minimum RGB components.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float Saturation(Vector4 color)
+        => MathF.Max(color.X, MathF.Max(color.Y, color.Z)) - MathF.Min(color.X, MathF.Min(color.Y, color.Z));
+
+    /// <summary>
+    /// Calculates the luminosity of an RGB color.
+    /// </summary>
+    /// <param name="color">The color.</param>
+    /// <returns>The weighted RGB luminosity.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float Luminosity(Vector4 color)
+        => (.3F * color.X) + (.59F * color.Y) + (.11F * color.Z);
+
+    /// <summary>
+    /// Replaces the saturation of an RGB color while retaining its channel ordering.
+    /// </summary>
+    /// <param name="color">The color.</param>
+    /// <param name="saturation">The required saturation.</param>
+    /// <returns>The adjusted color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector4 SetSaturation(Vector4 color, float saturation)
+    {
+        float minimum = MathF.Min(color.X, MathF.Min(color.Y, color.Z));
+        float range = MathF.Max(color.X, MathF.Max(color.Y, color.Z)) - minimum;
+        if (range == 0F)
+        {
+            return Vector4.Zero;
+        }
+
+        // Translating the minimum to zero and scaling the range is equivalent to the specification's ordered-channel construction.
+        return (color - new Vector4(minimum)) * (saturation / range);
+    }
+
+    /// <summary>
+    /// Replaces the luminosity of an RGB color and clips the result to the representable gamut.
+    /// </summary>
+    /// <param name="color">The color.</param>
+    /// <param name="luminosity">The required luminosity.</param>
+    /// <returns>The adjusted color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector4 SetLuminosity(Vector4 color, float luminosity)
+    {
+        color += new Vector4(luminosity - Luminosity(color));
+
+        float minimum = MathF.Min(color.X, MathF.Min(color.Y, color.Z));
+        if (minimum < 0F)
+        {
+            // Pull every component toward the requested luminosity by the same ratio so hue is preserved.
+            color = new Vector4(luminosity) + ((color - new Vector4(luminosity)) * (luminosity / (luminosity - minimum)));
+        }
+
+        float maximum = MathF.Max(color.X, MathF.Max(color.Y, color.Z));
+        if (maximum > 1F)
+        {
+            color = new Vector4(luminosity) + ((color - new Vector4(luminosity)) * ((1F - luminosity) / (maximum - luminosity)));
+        }
+
+        return Numerics.WithW(color, Vector4.Zero);
+    }
+
     /// <summary>
     /// Helper function for Overlay and HardLight modes
     /// </summary>
@@ -783,6 +1136,57 @@ internal static partial class PorterDuffFunctions
         return Numerics.UnPremultiply(color, alpha);
     }
 
+    /// <summary>
+    /// Returns the result of the "Plus" compositing equation.
+    /// </summary>
+    /// <param name="destination">The destination vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="blend">The blended source and destination color.</param>
+    /// <returns>The composition result.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 Plus(Vector4 destination, Vector4 source, Vector4 blend)
+    {
+        Vector4 sourceAlpha = Numerics.PermuteW(source);
+        Vector4 destinationAlpha = Numerics.PermuteW(destination);
+        Vector4 overlap = sourceAlpha * destinationAlpha;
+
+        // Plus retains both non-overlapping regions and uses the selected blend mode in their overlap.
+        Vector4 color = (destination * destinationAlpha) + (source * (sourceAlpha - overlap)) + (blend * overlap);
+        Vector4 alpha = Vector4.Min(Vector4.One, sourceAlpha + destinationAlpha);
+        color = Vector4.Min(Vector4.One, color);
+
+        Numerics.UnPremultiply(ref color, alpha);
+        return color;
+    }
+
+    /// <inheritdoc cref="Plus(Vector4, Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> Plus(Vector256<float> destination, Vector256<float> source, Vector256<float> blend)
+    {
+        Vector256<float> one = Vector256.Create(1F);
+        Vector256<float> sourceAlpha = Avx.Permute(source, ShuffleAlphaControl);
+        Vector256<float> destinationAlpha = Avx.Permute(destination, ShuffleAlphaControl);
+        Vector256<float> overlap = sourceAlpha * destinationAlpha;
+        Vector256<float> color = (destination * destinationAlpha) + (source * (sourceAlpha - overlap)) + (blend * overlap);
+        Vector256<float> alpha = Vector256.Min(one, sourceAlpha + destinationAlpha);
+
+        return Numerics.UnPremultiply(Vector256.Min(one, color), alpha);
+    }
+
+    /// <inheritdoc cref="Plus(Vector4, Vector4, Vector4)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Plus(Vector512<float> destination, Vector512<float> source, Vector512<float> blend)
+    {
+        Vector512<float> one = Vector512.Create(1F);
+        Vector512<float> sourceAlpha = Vector512_.ShuffleNative(source, ShuffleAlphaControl);
+        Vector512<float> destinationAlpha = Vector512_.ShuffleNative(destination, ShuffleAlphaControl);
+        Vector512<float> overlap = sourceAlpha * destinationAlpha;
+        Vector512<float> color = (destination * destinationAlpha) + (source * (sourceAlpha - overlap)) + (blend * overlap);
+        Vector512<float> alpha = Vector512.Min(one, sourceAlpha + destinationAlpha);
+
+        return Numerics.UnPremultiply(Vector512.Min(one, color), alpha);
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static Vector4 Clear(Vector4 backdrop, Vector4 source) => Vector4.Zero;
 
diff --git a/src/ImageSharp/PixelFormats/PixelColorBlendingMode.cs b/src/ImageSharp/PixelFormats/PixelColorBlendingMode.cs
index 7aa07cf51..aa74f6172 100644
--- a/src/ImageSharp/PixelFormats/PixelColorBlendingMode.cs
+++ b/src/ImageSharp/PixelFormats/PixelColorBlendingMode.cs
@@ -52,4 +52,49 @@ public enum PixelColorBlendingMode
     /// Multiplies or screens the colors, depending on the source value.
     /// </summary>
     HardLight,
+
+    /// <summary>
+    /// Brightens the backdrop color to reflect the source color.
+    /// </summary>
+    ColorDodge,
+
+    /// <summary>
+    /// Darkens the backdrop color to reflect the source color.
+    /// </summary>
+    ColorBurn,
+
+    /// <summary>
+    /// Darkens or lightens the colors, depending on the source color.
+    /// </summary>
+    SoftLight,
+
+    /// <summary>
+    /// Subtracts the darker color from the lighter color.
+    /// </summary>
+    Difference,
+
+    /// <summary>
+    /// Produces an effect similar to Difference with lower contrast.
+    /// </summary>
+    Exclusion,
+
+    /// <summary>
+    /// Uses the hue of the source color with the saturation and luminosity of the backdrop color.
+    /// </summary>
+    Hue,
+
+    /// <summary>
+    /// Uses the saturation of the source color with the hue and luminosity of the backdrop color.
+    /// </summary>
+    Saturation,
+
+    /// <summary>
+    /// Uses the hue and saturation of the source color with the luminosity of the backdrop color.
+    /// </summary>
+    Color,
+
+    /// <summary>
+    /// Uses the luminosity of the source color with the hue and saturation of the backdrop color.
+    /// </summary>
+    Luminosity,
 }
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs
index fe7de51c9..b17c90b92 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs
@@ -42,6 +42,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenClear;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayClear;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightClear;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeClear;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnClear;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightClear;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceClear;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionClear;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueClear;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationClear;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorClear;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityClear;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalClear;
                 }
@@ -57,6 +66,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenXor;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayXor;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightXor;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeXor;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnXor;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightXor;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceXor;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionXor;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueXor;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationXor;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorXor;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityXor;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalXor;
                 }
@@ -72,6 +90,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrc;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrc;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrc;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeSrc;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnSrc;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightSrc;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceSrc;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionSrc;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueSrc;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationSrc;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorSrc;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminositySrc;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalSrc;
                 }
@@ -87,6 +114,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcAtop;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcAtop;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcAtop;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeSrcAtop;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnSrcAtop;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightSrcAtop;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceSrcAtop;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionSrcAtop;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueSrcAtop;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationSrcAtop;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorSrcAtop;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminositySrcAtop;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalSrcAtop;
                 }
@@ -102,6 +138,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcIn;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcIn;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcIn;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeSrcIn;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnSrcIn;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightSrcIn;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceSrcIn;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionSrcIn;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueSrcIn;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationSrcIn;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorSrcIn;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminositySrcIn;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalSrcIn;
                 }
@@ -117,6 +162,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcOut;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcOut;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcOut;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeSrcOut;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnSrcOut;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightSrcOut;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceSrcOut;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionSrcOut;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueSrcOut;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationSrcOut;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorSrcOut;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminositySrcOut;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalSrcOut;
                 }
@@ -132,6 +186,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDest;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDest;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDest;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeDest;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnDest;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightDest;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceDest;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionDest;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueDest;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationDest;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorDest;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityDest;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalDest;
                 }
@@ -147,6 +210,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestAtop;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestAtop;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestAtop;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeDestAtop;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnDestAtop;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightDestAtop;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceDestAtop;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionDestAtop;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueDestAtop;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationDestAtop;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorDestAtop;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityDestAtop;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalDestAtop;
                 }
@@ -162,6 +234,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestIn;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestIn;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestIn;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeDestIn;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnDestIn;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightDestIn;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceDestIn;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionDestIn;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueDestIn;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationDestIn;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorDestIn;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityDestIn;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalDestIn;
                 }
@@ -177,6 +258,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestOut;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestOut;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestOut;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeDestOut;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnDestOut;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightDestOut;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceDestOut;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionDestOut;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueDestOut;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationDestOut;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorDestOut;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityDestOut;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalDestOut;
                 }
@@ -192,10 +282,43 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenDestOver;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayDestOver;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightDestOver;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeDestOver;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnDestOver;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightDestOver;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceDestOver;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionDestOver;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueDestOver;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationDestOver;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorDestOver;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityDestOver;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalDestOver;
                 }
 
+            case PixelAlphaCompositionMode.Plus:
+                switch (colorMode)
+                {
+                    case PixelColorBlendingMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplyPlus;
+                    case PixelColorBlendingMode.Add: return DefaultPixelBlenders<TPixel>.AddPlus;
+                    case PixelColorBlendingMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractPlus;
+                    case PixelColorBlendingMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenPlus;
+                    case PixelColorBlendingMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenPlus;
+                    case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenPlus;
+                    case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlayPlus;
+                    case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightPlus;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgePlus;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnPlus;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightPlus;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferencePlus;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionPlus;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HuePlus;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationPlus;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorPlus;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminosityPlus;
+                    case PixelColorBlendingMode.Normal:
+                    default: return DefaultPixelBlenders<TPixel>.NormalPlus;
+                }
+
             case PixelAlphaCompositionMode.SrcOver:
             default:
                 switch (colorMode)
@@ -208,6 +331,15 @@ public partial class PixelOperations<TPixel>
                     case PixelColorBlendingMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcOver;
                     case PixelColorBlendingMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcOver;
                     case PixelColorBlendingMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcOver;
+                    case PixelColorBlendingMode.ColorDodge: return DefaultPixelBlenders<TPixel>.ColorDodgeSrcOver;
+                    case PixelColorBlendingMode.ColorBurn: return DefaultPixelBlenders<TPixel>.ColorBurnSrcOver;
+                    case PixelColorBlendingMode.SoftLight: return DefaultPixelBlenders<TPixel>.SoftLightSrcOver;
+                    case PixelColorBlendingMode.Difference: return DefaultPixelBlenders<TPixel>.DifferenceSrcOver;
+                    case PixelColorBlendingMode.Exclusion: return DefaultPixelBlenders<TPixel>.ExclusionSrcOver;
+                    case PixelColorBlendingMode.Hue: return DefaultPixelBlenders<TPixel>.HueSrcOver;
+                    case PixelColorBlendingMode.Saturation: return DefaultPixelBlenders<TPixel>.SaturationSrcOver;
+                    case PixelColorBlendingMode.Color: return DefaultPixelBlenders<TPixel>.ColorSrcOver;
+                    case PixelColorBlendingMode.Luminosity: return DefaultPixelBlenders<TPixel>.LuminositySrcOver;
                     case PixelColorBlendingMode.Normal:
                     default: return DefaultPixelBlenders<TPixel>.NormalSrcOver;
                 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
index c203bee16..7562d8ff6 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
@@ -50,7 +50,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenClear.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenClear.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlayClear.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightClear.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorClear.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityClear.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -63,7 +72,38 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenXor.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenXor.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlayXor.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightXor.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorXor.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityXor.GetType());
+
+            AddBlenderModeMappings(
+                data,
+                PixelAlphaCompositionMode.Plus,
+                DefaultPixelBlenders<Rgba32>.NormalPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.MultiplyPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.AddPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.SubtractPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.ScreenPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.DarkenPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.LightenPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.OverlayPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.HardLightPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgePlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferencePlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.HuePlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorPlus.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityPlus.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -76,7 +116,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenSrc.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenSrc.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlaySrc.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightSrc.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorSrc.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminositySrc.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -89,7 +138,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenSrcAtop.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenSrcAtop.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlaySrcAtop.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightSrcAtop.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorSrcAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminositySrcAtop.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -102,7 +160,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenSrcIn.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenSrcIn.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlaySrcIn.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightSrcIn.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorSrcIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminositySrcIn.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -115,7 +182,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenSrcOut.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenSrcOut.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlaySrcOut.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightSrcOut.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorSrcOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminositySrcOut.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -128,7 +204,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenDest.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenDest.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlayDest.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightDest.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDest.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityDest.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -141,7 +226,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenDestAtop.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenDestAtop.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlayDestAtop.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightDestAtop.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDestAtop.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityDestAtop.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -154,7 +248,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenDestIn.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenDestIn.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlayDestIn.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightDestIn.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDestIn.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityDestIn.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -167,7 +270,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenDestOut.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenDestOut.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlayDestOut.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightDestOut.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDestOut.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityDestOut.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -180,7 +292,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenDestOver.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenDestOver.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlayDestOver.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightDestOver.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDestOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminosityDestOver.GetType());
 
             AddBlenderModeMappings(
                 data,
@@ -193,7 +314,16 @@ public class PixelBlenderTests
                 DefaultPixelBlenders<Rgba32>.DarkenSrcOver.GetType(),
                 DefaultPixelBlenders<Rgba32>.LightenSrcOver.GetType(),
                 DefaultPixelBlenders<Rgba32>.OverlaySrcOver.GetType(),
-                DefaultPixelBlenders<Rgba32>.HardLightSrcOver.GetType());
+                DefaultPixelBlenders<Rgba32>.HardLightSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorDodgeSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorBurnSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.SoftLightSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.DifferenceSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ExclusionSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.HueSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.SaturationSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.ColorSrcOver.GetType(),
+                DefaultPixelBlenders<Rgba32>.LuminositySrcOver.GetType());
 
             return data;
         }
@@ -228,6 +358,51 @@ public class PixelBlenderTests
             ExerciseAllAssociatedAlphaBlenderModeCombinations,
             HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX | HwIntrinsics.DisableHWIntrinsic);
 
+    [Theory]
+    [InlineData(PixelColorBlendingMode.ColorDodge)]
+    [InlineData(PixelColorBlendingMode.ColorBurn)]
+    [InlineData(PixelColorBlendingMode.SoftLight)]
+    [InlineData(PixelColorBlendingMode.Difference)]
+    [InlineData(PixelColorBlendingMode.Exclusion)]
+    [InlineData(PixelColorBlendingMode.Hue)]
+    [InlineData(PixelColorBlendingMode.Saturation)]
+    [InlineData(PixelColorBlendingMode.Color)]
+    [InlineData(PixelColorBlendingMode.Luminosity)]
+    public void NewSrcOverModesMatchAcrossAlphaRepresentations(PixelColorBlendingMode colorMode)
+    {
+        Rgba32 background = new(220, 80, 40, 160);
+        Rgba32 source = new(20, 180, 120, 96);
+        PixelBlender<Rgba32> straightBlender = PixelOperations<Rgba32>.Instance.GetPixelBlender(colorMode, PixelAlphaCompositionMode.SrcOver);
+        PixelBlender<Rgba32P> associatedBlender = PixelOperations<Rgba32P>.Instance.GetPixelBlender(colorMode, PixelAlphaCompositionMode.SrcOver);
+
+        Rgba32 straightResult = straightBlender.Blend(background, source, .625F);
+        Rgba32P expected = Rgba32P.FromRgba32(straightResult);
+        Rgba32P actual = associatedBlender.Blend(Rgba32P.FromRgba32(background), Rgba32P.FromRgba32(source), .625F);
+
+        // Associated storage introduces one extra byte quantization, but both paths must describe the same composite.
+        Assert.True(Math.Abs(expected.R - actual.R) <= 1, $"{colorMode}: expected {expected}, actual {actual}");
+        Assert.True(Math.Abs(expected.G - actual.G) <= 1, $"{colorMode}: expected {expected}, actual {actual}");
+        Assert.True(Math.Abs(expected.B - actual.B) <= 1, $"{colorMode}: expected {expected}, actual {actual}");
+        Assert.Equal(expected.A, actual.A);
+    }
+
+    [Fact]
+    public void PlusMatchesAcrossAlphaRepresentations()
+    {
+        Rgba32 background = new(220, 80, 40, 160);
+        Rgba32 source = new(20, 180, 120, 96);
+        PixelBlender<Rgba32> straightBlender = PixelOperations<Rgba32>.Instance.GetPixelBlender(PixelColorBlendingMode.Normal, PixelAlphaCompositionMode.Plus);
+        PixelBlender<Rgba32P> associatedBlender = PixelOperations<Rgba32P>.Instance.GetPixelBlender(PixelColorBlendingMode.Normal, PixelAlphaCompositionMode.Plus);
+
+        Rgba32P expected = Rgba32P.FromRgba32(straightBlender.Blend(background, source, .625F));
+        Rgba32P actual = associatedBlender.Blend(Rgba32P.FromRgba32(background), Rgba32P.FromRgba32(source), .625F);
+
+        Assert.True(Math.Abs(expected.R - actual.R) <= 1, $"expected {expected}, actual {actual}");
+        Assert.True(Math.Abs(expected.G - actual.G) <= 1, $"expected {expected}, actual {actual}");
+        Assert.True(Math.Abs(expected.B - actual.B) <= 1, $"expected {expected}, actual {actual}");
+        Assert.Equal(expected.A, actual.A);
+    }
+
     [Fact]
     public void AssociatedHardLightDestAtopRoundsExactMidpointAwayFromZero() =>
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
@@ -691,6 +866,8 @@ public class PixelBlenderTests
         { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcIn, Color.MidnightBlue.ToPixel<Rgba32>() },
         { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcOut, new Rgba32(0) },
         { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcOver, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { new Rgba32(51, 102, 153, 77), new Rgba32(204, 51, 26, 102), .5F, PixelAlphaCompositionMode.Plus, new Rgba32(112, 82, 102, 128) },
+        { new Rgba32(230, 51, 26, 191), new Rgba32(204, 230, 77, 191), 1F, PixelAlphaCompositionMode.Plus, new Rgba32(255, 210, 77, 255) },
     };
 
     [Theory]
@@ -716,7 +893,16 @@ public class PixelBlenderTests
         Type darken,
         Type lighten,
         Type overlay,
-        Type hardLight)
+        Type hardLight,
+        Type colorDodge,
+        Type colorBurn,
+        Type softLight,
+        Type difference,
+        Type exclusion,
+        Type hue,
+        Type saturation,
+        Type color,
+        Type luminosity)
     {
         data.Add(PixelColorBlendingMode.Normal, alphaMode, normal);
         data.Add(PixelColorBlendingMode.Multiply, alphaMode, multiply);
@@ -727,6 +913,15 @@ public class PixelBlenderTests
         data.Add(PixelColorBlendingMode.Lighten, alphaMode, lighten);
         data.Add(PixelColorBlendingMode.Overlay, alphaMode, overlay);
         data.Add(PixelColorBlendingMode.HardLight, alphaMode, hardLight);
+        data.Add(PixelColorBlendingMode.ColorDodge, alphaMode, colorDodge);
+        data.Add(PixelColorBlendingMode.ColorBurn, alphaMode, colorBurn);
+        data.Add(PixelColorBlendingMode.SoftLight, alphaMode, softLight);
+        data.Add(PixelColorBlendingMode.Difference, alphaMode, difference);
+        data.Add(PixelColorBlendingMode.Exclusion, alphaMode, exclusion);
+        data.Add(PixelColorBlendingMode.Hue, alphaMode, hue);
+        data.Add(PixelColorBlendingMode.Saturation, alphaMode, saturation);
+        data.Add(PixelColorBlendingMode.Color, alphaMode, color);
+        data.Add(PixelColorBlendingMode.Luminosity, alphaMode, luminosity);
     }
 
     private static void ExerciseAllBlenderModeCombinations()
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs
index 0def09788..4891f9e44 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 using SixLabors.ImageSharp.Tests.TestUtilities;
 
@@ -444,10 +445,136 @@ public class PorterDuffFunctionsTests
         Assert.Equal(expected512, actual, FloatComparer);
     }
 
+    public static TheoryData<PixelColorBlendingMode, TestVector4, TestVector4, TestVector4> ExtendedBlendFunctionData { get; } = new()
+    {
+        { PixelColorBlendingMode.ColorDodge, CreateTestVector(0F, .25F, .8F, 1F), CreateTestVector(1F, .5F, .5F, 1F), CreateTestVector(0F, .5F, 1F, 1F) },
+        { PixelColorBlendingMode.ColorBurn, CreateTestVector(1F, .4F, .75F, 1F), CreateTestVector(0F, 0F, .5F, 1F), CreateTestVector(1F, 0F, .5F, 1F) },
+        { PixelColorBlendingMode.SoftLight, CreateTestVector(.25F, .64F, .16F, 1F), CreateTestVector(.75F, .75F, .25F, 1F), CreateTestVector(.375F, .72F, .0928F, 1F) },
+        { PixelColorBlendingMode.SoftLight, CreateTestVector(.25F, .36F, .81F, 1F), CreateTestVector(.5F, .5F, .5F, 1F), CreateTestVector(.25F, .36F, .81F, 1F) },
+        { PixelColorBlendingMode.Difference, CreateTestVector(.1F, .8F, .4F, 1F), CreateTestVector(.7F, .2F, .4F, 1F), CreateTestVector(.6F, .6F, 0F, 1F) },
+        { PixelColorBlendingMode.Exclusion, CreateTestVector(.1F, .8F, .4F, 1F), CreateTestVector(.7F, .2F, .4F, 1F), CreateTestVector(.66F, .68F, .48F, 1F) },
+        { PixelColorBlendingMode.Hue, CreateTestVector(.2F, .7F, .4F, 1F), CreateTestVector(.9F, .1F, .6F, 1F), CreateTestVector(.832625F, .332625F, .645125F, 1F) },
+        { PixelColorBlendingMode.Saturation, CreateTestVector(.2F, .7F, .4F, 1F), CreateTestVector(.9F, .1F, .6F, 1F), CreateTestVector(.0098F, .8098F, .3298F, 1F) },
+        { PixelColorBlendingMode.Color, CreateTestVector(.2F, .7F, .4F, 1F), CreateTestVector(.9F, .1F, .6F, 1F), CreateTestVector(1F, .234851485F, .713069307F, 1F) },
+        { PixelColorBlendingMode.Luminosity, CreateTestVector(.2F, .7F, .4F, 1F), CreateTestVector(.9F, .1F, .6F, 1F), CreateTestVector(.078F, .578F, .278F, 1F) },
+        { PixelColorBlendingMode.Hue, CreateTestVector(.5F, .5F, .5F, 1F), CreateTestVector(.9F, .2F, .6F, 1F), CreateTestVector(.5F, .5F, .5F, 1F) },
+        { PixelColorBlendingMode.Saturation, CreateTestVector(.5F, .5F, .5F, 1F), CreateTestVector(.9F, .2F, .6F, 1F), CreateTestVector(.5F, .5F, .5F, 1F) },
+    };
+
+    [Theory]
+    [MemberData(nameof(ExtendedBlendFunctionData))]
+    public void ExtendedBlendFunction(PixelColorBlendingMode mode, TestVector4 back, TestVector4 source, TestVector4 expected)
+    {
+        Vector4 actual = InvokeExtendedBlend(mode, back, source, 1F);
+        VectorAssert.Equal(expected, actual, 4);
+    }
+
+    [Theory]
+    [MemberData(nameof(ExtendedBlendFunctionData))]
+    public void ExtendedBlendFunction256(PixelColorBlendingMode mode, TestVector4 back, TestVector4 source, TestVector4 expected)
+    {
+        if (!Avx.IsSupported)
+        {
+            return;
+        }
+
+        Vector256<float> actual = InvokeExtendedBlend(mode, Vector256.Create(back.AsVector().AsVector128(), back.AsVector().AsVector128()), Vector256.Create(source.AsVector().AsVector128(), source.AsVector().AsVector128()), Vector256.Create(1F));
+        Vector256<float> expectedVector = Vector256.Create(expected.AsVector().AsVector128(), expected.AsVector().AsVector128());
+        Assert.Equal(expectedVector, actual, FloatComparer);
+    }
+
+    [Theory]
+    [MemberData(nameof(ExtendedBlendFunctionData))]
+    public void ExtendedBlendFunction512(PixelColorBlendingMode mode, TestVector4 back, TestVector4 source, TestVector4 expected)
+    {
+        if (!Avx512F.IsSupported)
+        {
+            return;
+        }
+
+        Vector512<float> actual = InvokeExtendedBlend(mode, CreateVector512(back), CreateVector512(source), Vector512.Create(1F));
+        Assert.Equal(CreateVector512(expected), actual, FloatComparer);
+    }
+
+    /// <summary>
+    /// Creates serializable vector test data without relying on the legacy convenience constructor's channel assignments.
+    /// </summary>
+    /// <param name="x">The X component.</param>
+    /// <param name="y">The Y component.</param>
+    /// <param name="z">The Z component.</param>
+    /// <param name="w">The W component.</param>
+    /// <returns>The test vector.</returns>
+    private static TestVector4 CreateTestVector(float x, float y, float z, float w)
+        => new() { X = x, Y = y, Z = z, W = w };
+
+    /// <summary>
+    /// Invokes a new blend mode through its straight-alpha source-over function.
+    /// </summary>
+    /// <param name="mode">The color blending mode.</param>
+    /// <param name="backdrop">The backdrop vector.</param>
+    /// <param name="source">The source vector.</param>
+    /// <param name="amount">The source amount.</param>
+    /// <returns>The composition result.</returns>
+    private static Vector4 InvokeExtendedBlend(PixelColorBlendingMode mode, Vector4 backdrop, Vector4 source, float amount)
+        => mode switch
+        {
+            PixelColorBlendingMode.ColorDodge => PorterDuffFunctions.ColorDodgeSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.ColorBurn => PorterDuffFunctions.ColorBurnSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.SoftLight => PorterDuffFunctions.SoftLightSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Difference => PorterDuffFunctions.DifferenceSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Exclusion => PorterDuffFunctions.ExclusionSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Hue => PorterDuffFunctions.HueSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Saturation => PorterDuffFunctions.SaturationSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Color => PorterDuffFunctions.ColorSrcOver(backdrop, source, amount),
+            _ => PorterDuffFunctions.LuminositySrcOver(backdrop, source, amount),
+        };
+
+    /// <inheritdoc cref="InvokeExtendedBlend(PixelColorBlendingMode, Vector4, Vector4, float)" />
+    private static Vector256<float> InvokeExtendedBlend(PixelColorBlendingMode mode, Vector256<float> backdrop, Vector256<float> source, Vector256<float> amount)
+        => mode switch
+        {
+            PixelColorBlendingMode.ColorDodge => PorterDuffFunctions.ColorDodgeSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.ColorBurn => PorterDuffFunctions.ColorBurnSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.SoftLight => PorterDuffFunctions.SoftLightSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Difference => PorterDuffFunctions.DifferenceSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Exclusion => PorterDuffFunctions.ExclusionSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Hue => PorterDuffFunctions.HueSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Saturation => PorterDuffFunctions.SaturationSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Color => PorterDuffFunctions.ColorSrcOver(backdrop, source, amount),
+            _ => PorterDuffFunctions.LuminositySrcOver(backdrop, source, amount),
+        };
+
+    /// <inheritdoc cref="InvokeExtendedBlend(PixelColorBlendingMode, Vector4, Vector4, float)" />
+    private static Vector512<float> InvokeExtendedBlend(PixelColorBlendingMode mode, Vector512<float> backdrop, Vector512<float> source, Vector512<float> amount)
+        => mode switch
+        {
+            PixelColorBlendingMode.ColorDodge => PorterDuffFunctions.ColorDodgeSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.ColorBurn => PorterDuffFunctions.ColorBurnSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.SoftLight => PorterDuffFunctions.SoftLightSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Difference => PorterDuffFunctions.DifferenceSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Exclusion => PorterDuffFunctions.ExclusionSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Hue => PorterDuffFunctions.HueSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Saturation => PorterDuffFunctions.SaturationSrcOver(backdrop, source, amount),
+            PixelColorBlendingMode.Color => PorterDuffFunctions.ColorSrcOver(backdrop, source, amount),
+            _ => PorterDuffFunctions.LuminositySrcOver(backdrop, source, amount),
+        };
+
     private static Vector512<float> CreateVector512(TestVector4 vector)
         => Vector512.Create(
-            vector.X, vector.Y, vector.Z, vector.W,
-            vector.X, vector.Y, vector.Z, vector.W,
-            vector.X, vector.Y, vector.Z, vector.W,
-            vector.X, vector.Y, vector.Z, vector.W);
+            vector.X,
+            vector.Y,
+            vector.Z,
+            vector.W,
+            vector.X,
+            vector.Y,
+            vector.Z,
+            vector.W,
+            vector.X,
+            vector.Y,
+            vector.Z,
+            vector.W,
+            vector.X,
+            vector.Y,
+            vector.Z,
+            vector.W);
 }