From c9af728104216e768faef206c45a0a00a36bdfb7 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 7 Aug 2026 08:10:38 +1000
Subject: [PATCH] Add plus and extended pixel blend modes

Introduce the `Plus` alpha composition mode and add support for ColorDodge, ColorBurn, SoftLight, Difference, Exclusion, Hue, Saturation, Color, and Luminosity across straight-alpha and associated-alpha pixel blenders. The generated blender/function tables and selector logic were updated to expose the new combinations, and tests were expanded to cover mode mapping, expected blend results, and parity between straight and premultiplied alpha paths.
---
 .../PixelFormats/PixelAlphaCompositionMode.cs |    7 +-
 .../AssociatedAlphaPixelBlenders.Generated.cs | 4348 ++++++++--
 .../AssociatedAlphaPixelBlenders.Generated.tt |   10 +
 .../AssociatedAlphaPixelBlenders.cs           |  129 +
 ...iatedAlphaPorterDuffFunctions.Generated.cs | 7668 +++++++++++++++--
 ...iatedAlphaPorterDuffFunctions.Generated.tt |   14 +
 .../AssociatedAlphaPorterDuffFunctions.cs     |  449 +
 .../DefaultPixelBlenders.Generated.cs         | 4348 ++++++++--
 .../DefaultPixelBlenders.Generated.tt         |   10 +
 .../PorterDuffFunctions.Generated.cs          | 7151 ++++++++++++++-
 .../PorterDuffFunctions.Generated.tt          |   57 +-
 .../PixelBlenders/PorterDuffFunctions.cs      |  404 +
 .../PixelFormats/PixelColorBlendingMode.cs    |   45 +
 .../PixelOperations{TPixel}.PixelBenders.cs   |  132 +
 .../PixelFormats/PixelBlenderTests.cs         |  221 +-
 .../PixelBlenders/PorterDuffFunctionsTests.cs |  135 +-
 16 files changed, 23139 insertions(+), 1989 deletions(-)

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);
 }