From 4b30c4ea10c80efbffe586b0668a4a6607d3b7ee Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Tue, 17 Mar 2026 11:02:22 +1000
Subject: [PATCH] Expand pixel blender API to support single color bulk
 operations

---
 .gitignore                                    |     2 +
 .../DefaultPixelBlenders.Generated.cs         | 14946 +++++++++++++---
 .../DefaultPixelBlenders.Generated.tt         |    84 +
 .../PixelFormats/PixelBlender{TPixel}.cs      |    98 +
 src/ImageSharp/Primitives/Point.cs            |     9 +-
 src/ImageSharp/Primitives/Rectangle.cs        |    12 +-
 src/ImageSharp/Primitives/RectangleF.cs       |    24 +-
 .../ImageSharp.Tests/Primitives/PointTests.cs |    30 +-
 .../Primitives/RectangleFTests.cs             |    13 +
 .../Primitives/RectangleTests.cs              |    13 +
 10 files changed, 12263 insertions(+), 2968 deletions(-)

diff --git a/.gitignore b/.gitignore
index fadf36964c..a8d2917be7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -227,3 +227,5 @@ artifacts/
 #lfs
 hooks/**
 lfs/**
+
+.dotnet
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
index f62d3c6761..7cd9cc57ad 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
@@ -81,8 +81,10 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -90,65 +92,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
                     destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrc" composition equation.
-    /// </summary>
-    public class MultiplySrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrc Instance { get; } = new MultiplySrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -157,34 +129,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -193,9 +175,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -207,10 +189,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -218,33 +199,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "AddSrc" composition equation.
+    /// A pixel blender that implements the "MultiplySrc" composition equation.
     /// </summary>
-    public class AddSrc : PixelBlender<TPixel>
+    public class MultiplySrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static AddSrc Instance { get; } = new AddSrc();
+        public static MultiplySrc Instance { get; } = new MultiplySrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -264,7 +245,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -274,21 +255,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -296,65 +279,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrc" composition equation.
-    /// </summary>
-    public class SubtractSrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrc Instance { get; } = new SubtractSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -363,34 +316,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -399,9 +362,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -413,10 +376,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -424,33 +386,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenSrc" composition equation.
+    /// A pixel blender that implements the "AddSrc" composition equation.
     /// </summary>
-    public class ScreenSrc : PixelBlender<TPixel>
+    public class AddSrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static ScreenSrc Instance { get; } = new ScreenSrc();
+        public static AddSrc Instance { get; } = new AddSrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -470,7 +432,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -480,21 +442,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -502,65 +466,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrc" composition equation.
-    /// </summary>
-    public class DarkenSrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrc Instance { get; } = new DarkenSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -569,34 +503,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -605,9 +549,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -619,10 +563,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -630,33 +573,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "LightenSrc" composition equation.
+    /// A pixel blender that implements the "SubtractSrc" composition equation.
     /// </summary>
-    public class LightenSrc : PixelBlender<TPixel>
+    public class SubtractSrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static LightenSrc Instance { get; } = new LightenSrc();
+        public static SubtractSrc Instance { get; } = new SubtractSrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -676,7 +619,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -686,21 +629,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -708,65 +653,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrc" composition equation.
-    /// </summary>
-    public class OverlaySrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrc Instance { get; } = new OverlaySrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -775,34 +690,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -811,9 +736,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -825,10 +750,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -836,33 +760,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightSrc" composition equation.
+    /// A pixel blender that implements the "ScreenSrc" composition equation.
     /// </summary>
-    public class HardLightSrc : PixelBlender<TPixel>
+    public class ScreenSrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static HardLightSrc Instance { get; } = new HardLightSrc();
+        public static ScreenSrc Instance { get; } = new ScreenSrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -882,7 +806,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -892,21 +816,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -914,65 +840,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcAtop" composition equation.
-    /// </summary>
-    public class NormalSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcAtop Instance { get; } = new NormalSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -981,34 +877,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -1017,9 +923,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -1031,10 +937,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -1042,33 +947,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplySrcAtop" composition equation.
+    /// A pixel blender that implements the "DarkenSrc" composition equation.
     /// </summary>
-    public class MultiplySrcAtop : PixelBlender<TPixel>
+    public class DarkenSrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static MultiplySrcAtop Instance { get; } = new MultiplySrcAtop();
+        public static DarkenSrc Instance { get; } = new DarkenSrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1088,7 +993,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -1098,21 +1003,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1120,65 +1027,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcAtop" composition equation.
-    /// </summary>
-    public class AddSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcAtop Instance { get; } = new AddSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1187,34 +1064,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -1223,9 +1110,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -1237,10 +1124,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -1248,33 +1134,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractSrcAtop" composition equation.
+    /// A pixel blender that implements the "LightenSrc" composition equation.
     /// </summary>
-    public class SubtractSrcAtop : PixelBlender<TPixel>
+    public class LightenSrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static SubtractSrcAtop Instance { get; } = new SubtractSrcAtop();
+        public static LightenSrc Instance { get; } = new LightenSrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1294,7 +1180,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -1304,21 +1190,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1326,65 +1214,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcAtop" composition equation.
-    /// </summary>
-    public class ScreenSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcAtop Instance { get; } = new ScreenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1393,34 +1251,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -1429,9 +1297,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -1443,10 +1311,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -1454,33 +1321,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "DarkenSrcAtop" composition equation.
+    /// A pixel blender that implements the "OverlaySrc" composition equation.
     /// </summary>
-    public class DarkenSrcAtop : PixelBlender<TPixel>
+    public class OverlaySrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static DarkenSrcAtop Instance { get; } = new DarkenSrcAtop();
+        public static OverlaySrc Instance { get; } = new OverlaySrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1500,7 +1367,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -1510,21 +1377,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1532,65 +1401,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcAtop" composition equation.
-    /// </summary>
-    public class LightenSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcAtop Instance { get; } = new LightenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1599,34 +1438,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -1635,9 +1484,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -1649,10 +1498,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -1660,33 +1508,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlaySrcAtop" composition equation.
+    /// A pixel blender that implements the "HardLightSrc" composition equation.
     /// </summary>
-    public class OverlaySrcAtop : PixelBlender<TPixel>
+    public class HardLightSrc : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static OverlaySrcAtop Instance { get; } = new OverlaySrcAtop();
+        public static HardLightSrc Instance { get; } = new HardLightSrc();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1706,7 +1554,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -1716,21 +1564,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1738,65 +1588,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcAtop" composition equation.
-    /// </summary>
-    public class HardLightSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcAtop Instance { get; } = new HardLightSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -1805,34 +1625,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -1841,9 +1671,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -1855,10 +1685,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -1866,33 +1695,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "NormalSrcOver" composition equation.
+    /// A pixel blender that implements the "NormalSrcAtop" composition equation.
     /// </summary>
-    public class NormalSrcOver : PixelBlender<TPixel>
+    public class NormalSrcAtop : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static NormalSrcOver Instance { get; } = new NormalSrcOver();
+        public static NormalSrcAtop Instance { get; } = new NormalSrcAtop();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1912,7 +1741,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -1922,14 +1751,52 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
                 }
             }
         }
@@ -1958,7 +1825,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -1969,33 +1836,79 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
-    }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplySrcOver" composition equation.
+    /// A pixel blender that implements the "MultiplySrcAtop" composition equation.
     /// </summary>
-    public class MultiplySrcOver : PixelBlender<TPixel>
+    public class MultiplySrcAtop : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static MultiplySrcOver Instance { get; } = new MultiplySrcOver();
+        public static MultiplySrcAtop Instance { get; } = new MultiplySrcAtop();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2015,7 +1928,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -2025,21 +1938,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2047,65 +1962,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcOver" composition equation.
-    /// </summary>
-    public class AddSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcOver Instance { get; } = new AddSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2114,34 +1999,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -2150,9 +2045,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -2164,10 +2059,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -2175,33 +2069,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractSrcOver" composition equation.
+    /// A pixel blender that implements the "AddSrcAtop" composition equation.
     /// </summary>
-    public class SubtractSrcOver : PixelBlender<TPixel>
+    public class AddSrcAtop : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static SubtractSrcOver Instance { get; } = new SubtractSrcOver();
+        public static AddSrcAtop Instance { get; } = new AddSrcAtop();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2221,7 +2115,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -2231,14 +2125,52 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
                 }
             }
         }
@@ -2267,7 +2199,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -2278,33 +2210,79 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenSrcOver" composition equation.
+    /// A pixel blender that implements the "SubtractSrcAtop" composition equation.
     /// </summary>
-    public class ScreenSrcOver : PixelBlender<TPixel>
+    public class SubtractSrcAtop : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static ScreenSrcOver Instance { get; } = new ScreenSrcOver();
+        public static SubtractSrcAtop Instance { get; } = new SubtractSrcAtop();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2324,7 +2302,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -2334,21 +2312,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2356,65 +2336,9946 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
                 }
             }
         }
-    }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "ScreenSrcAtop" composition equation.
+    /// </summary>
+    public class ScreenSrcAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static ScreenSrcAtop Instance { get; } = new ScreenSrcAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "DarkenSrcAtop" composition equation.
+    /// </summary>
+    public class DarkenSrcAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static DarkenSrcAtop Instance { get; } = new DarkenSrcAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "LightenSrcAtop" composition equation.
+    /// </summary>
+    public class LightenSrcAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static LightenSrcAtop Instance { get; } = new LightenSrcAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "OverlaySrcAtop" composition equation.
+    /// </summary>
+    public class OverlaySrcAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static OverlaySrcAtop Instance { get; } = new OverlaySrcAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "HardLightSrcAtop" composition equation.
+    /// </summary>
+    public class HardLightSrcAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static HardLightSrcAtop Instance { get; } = new HardLightSrcAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "NormalSrcOver" composition equation.
+    /// </summary>
+    public class NormalSrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static NormalSrcOver Instance { get; } = new NormalSrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "MultiplySrcOver" composition equation.
+    /// </summary>
+    public class MultiplySrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static MultiplySrcOver Instance { get; } = new MultiplySrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "AddSrcOver" composition equation.
+    /// </summary>
+    public class AddSrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static AddSrcOver Instance { get; } = new AddSrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "SubtractSrcOver" composition equation.
+    /// </summary>
+    public class SubtractSrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static SubtractSrcOver Instance { get; } = new SubtractSrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "ScreenSrcOver" composition equation.
+    /// </summary>
+    public class ScreenSrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static ScreenSrcOver Instance { get; } = new ScreenSrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "DarkenSrcOver" composition equation.
+    /// </summary>
+    public class DarkenSrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static DarkenSrcOver Instance { get; } = new DarkenSrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "LightenSrcOver" composition equation.
+    /// </summary>
+    public class LightenSrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static LightenSrcOver Instance { get; } = new LightenSrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "OverlaySrcOver" composition equation.
+    /// </summary>
+    public class OverlaySrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static OverlaySrcOver Instance { get; } = new OverlaySrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "HardLightSrcOver" composition equation.
+    /// </summary>
+    public class HardLightSrcOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static HardLightSrcOver Instance { get; } = new HardLightSrcOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "NormalSrcIn" composition equation.
+    /// </summary>
+    public class NormalSrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static NormalSrcIn Instance { get; } = new NormalSrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "MultiplySrcIn" composition equation.
+    /// </summary>
+    public class MultiplySrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static MultiplySrcIn Instance { get; } = new MultiplySrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "AddSrcIn" composition equation.
+    /// </summary>
+    public class AddSrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static AddSrcIn Instance { get; } = new AddSrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "SubtractSrcIn" composition equation.
+    /// </summary>
+    public class SubtractSrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static SubtractSrcIn Instance { get; } = new SubtractSrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "ScreenSrcIn" composition equation.
+    /// </summary>
+    public class ScreenSrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static ScreenSrcIn Instance { get; } = new ScreenSrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "DarkenSrcIn" composition equation.
+    /// </summary>
+    public class DarkenSrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static DarkenSrcIn Instance { get; } = new DarkenSrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "LightenSrcIn" composition equation.
+    /// </summary>
+    public class LightenSrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static LightenSrcIn Instance { get; } = new LightenSrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "OverlaySrcIn" composition equation.
+    /// </summary>
+    public class OverlaySrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static OverlaySrcIn Instance { get; } = new OverlaySrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "HardLightSrcIn" composition equation.
+    /// </summary>
+    public class HardLightSrcIn : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static HardLightSrcIn Instance { get; } = new HardLightSrcIn();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "NormalSrcOut" composition equation.
+    /// </summary>
+    public class NormalSrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static NormalSrcOut Instance { get; } = new NormalSrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "MultiplySrcOut" composition equation.
+    /// </summary>
+    public class MultiplySrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static MultiplySrcOut Instance { get; } = new MultiplySrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "AddSrcOut" composition equation.
+    /// </summary>
+    public class AddSrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static AddSrcOut Instance { get; } = new AddSrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "SubtractSrcOut" composition equation.
+    /// </summary>
+    public class SubtractSrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static SubtractSrcOut Instance { get; } = new SubtractSrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "ScreenSrcOut" composition equation.
+    /// </summary>
+    public class ScreenSrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static ScreenSrcOut Instance { get; } = new ScreenSrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "DarkenSrcOut" composition equation.
+    /// </summary>
+    public class DarkenSrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static DarkenSrcOut Instance { get; } = new DarkenSrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "LightenSrcOut" composition equation.
+    /// </summary>
+    public class LightenSrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static LightenSrcOut Instance { get; } = new LightenSrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "OverlaySrcOut" composition equation.
+    /// </summary>
+    public class OverlaySrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static OverlaySrcOut Instance { get; } = new OverlaySrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "HardLightSrcOut" composition equation.
+    /// </summary>
+    public class HardLightSrcOut : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static HardLightSrcOut Instance { get; } = new HardLightSrcOut();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "NormalDest" composition equation.
+    /// </summary>
+    public class NormalDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static NormalDest Instance { get; } = new NormalDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "MultiplyDest" composition equation.
+    /// </summary>
+    public class MultiplyDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static MultiplyDest Instance { get; } = new MultiplyDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "AddDest" composition equation.
+    /// </summary>
+    public class AddDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static AddDest Instance { get; } = new AddDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "SubtractDest" composition equation.
+    /// </summary>
+    public class SubtractDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static SubtractDest Instance { get; } = new SubtractDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "ScreenDest" composition equation.
+    /// </summary>
+    public class ScreenDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static ScreenDest Instance { get; } = new ScreenDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "DarkenDest" composition equation.
+    /// </summary>
+    public class DarkenDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static DarkenDest Instance { get; } = new DarkenDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "LightenDest" composition equation.
+    /// </summary>
+    public class LightenDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static LightenDest Instance { get; } = new LightenDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "OverlayDest" composition equation.
+    /// </summary>
+    public class OverlayDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static OverlayDest Instance { get; } = new OverlayDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "HardLightDest" composition equation.
+    /// </summary>
+    public class HardLightDest : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static HardLightDest Instance { get; } = new HardLightDest();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "NormalDestAtop" composition equation.
+    /// </summary>
+    public class NormalDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static NormalDestAtop Instance { get; } = new NormalDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "MultiplyDestAtop" composition equation.
+    /// </summary>
+    public class MultiplyDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static MultiplyDestAtop Instance { get; } = new MultiplyDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "AddDestAtop" composition equation.
+    /// </summary>
+    public class AddDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static AddDestAtop Instance { get; } = new AddDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "SubtractDestAtop" composition equation.
+    /// </summary>
+    public class SubtractDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static SubtractDestAtop Instance { get; } = new SubtractDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "ScreenDestAtop" composition equation.
+    /// </summary>
+    public class ScreenDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static ScreenDestAtop Instance { get; } = new ScreenDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "DarkenDestAtop" composition equation.
+    /// </summary>
+    public class DarkenDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static DarkenDestAtop Instance { get; } = new DarkenDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "LightenDestAtop" composition equation.
+    /// </summary>
+    public class LightenDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static LightenDestAtop Instance { get; } = new LightenDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "OverlayDestAtop" composition equation.
+    /// </summary>
+    public class OverlayDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static OverlayDestAtop Instance { get; } = new OverlayDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "HardLightDestAtop" composition equation.
+    /// </summary>
+    public class HardLightDestAtop : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static HardLightDestAtop Instance { get; } = new HardLightDestAtop();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "NormalDestOver" composition equation.
+    /// </summary>
+    public class NormalDestOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static NormalDestOver Instance { get; } = new NormalDestOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
 
     /// <summary>
-    /// A pixel blender that implements the "DarkenSrcOver" composition equation.
+    /// A pixel blender that implements the "MultiplyDestOver" composition equation.
     /// </summary>
-    public class DarkenSrcOver : PixelBlender<TPixel>
+    public class MultiplyDestOver : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static DarkenSrcOver Instance { get; } = new DarkenSrcOver();
+        public static MultiplyDestOver Instance { get; } = new MultiplyDestOver();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// A pixel blender that implements the "AddDestOver" composition equation.
+    /// </summary>
+    public class AddDestOver : PixelBlender<TPixel>
+    {
+        /// <summary>
+        /// Gets the static instance of this blender.
+        /// </summary>
+        public static AddDestOver Instance { get; } = new AddDestOver();
+
+        /// <inheritdoc />
+        public override TPixel Blend(TPixel background, TPixel source, float amount)
+        {
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2423,34 +12284,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -2459,9 +12330,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -2473,10 +12344,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -2484,33 +12354,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "LightenSrcOver" composition equation.
+    /// A pixel blender that implements the "SubtractDestOver" composition equation.
     /// </summary>
-    public class LightenSrcOver : PixelBlender<TPixel>
+    public class SubtractDestOver : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static LightenSrcOver Instance { get; } = new LightenSrcOver();
+        public static SubtractDestOver Instance { get; } = new SubtractDestOver();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2530,7 +12400,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -2540,21 +12410,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2562,65 +12434,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcOver" composition equation.
-    /// </summary>
-    public class OverlaySrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcOver Instance { get; } = new OverlaySrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2629,34 +12471,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -2665,9 +12517,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -2679,10 +12531,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -2690,33 +12541,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightSrcOver" composition equation.
+    /// A pixel blender that implements the "ScreenDestOver" composition equation.
     /// </summary>
-    public class HardLightSrcOver : PixelBlender<TPixel>
+    public class ScreenDestOver : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static HardLightSrcOver Instance { get; } = new HardLightSrcOver();
+        public static ScreenDestOver Instance { get; } = new ScreenDestOver();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2736,7 +12587,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -2746,21 +12597,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2768,65 +12621,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcIn" composition equation.
-    /// </summary>
-    public class NormalSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcIn Instance { get; } = new NormalSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2835,34 +12658,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -2871,9 +12704,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -2885,10 +12718,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -2896,33 +12728,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplySrcIn" composition equation.
+    /// A pixel blender that implements the "DarkenDestOver" composition equation.
     /// </summary>
-    public class MultiplySrcIn : PixelBlender<TPixel>
+    public class DarkenDestOver : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static MultiplySrcIn Instance { get; } = new MultiplySrcIn();
+        public static DarkenDestOver Instance { get; } = new DarkenDestOver();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2942,7 +12774,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -2952,21 +12784,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -2974,65 +12808,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcIn" composition equation.
-    /// </summary>
-    public class AddSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcIn Instance { get; } = new AddSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3041,34 +12845,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -3077,9 +12891,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -3091,10 +12905,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -3102,33 +12915,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractSrcIn" composition equation.
+    /// A pixel blender that implements the "LightenDestOver" composition equation.
     /// </summary>
-    public class SubtractSrcIn : PixelBlender<TPixel>
+    public class LightenDestOver : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static SubtractSrcIn Instance { get; } = new SubtractSrcIn();
+        public static LightenDestOver Instance { get; } = new LightenDestOver();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3148,7 +12961,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -3158,21 +12971,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3180,65 +12995,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcIn" composition equation.
-    /// </summary>
-    public class ScreenSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcIn Instance { get; } = new ScreenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3247,34 +13032,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -3283,9 +13078,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -3297,10 +13092,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -3308,33 +13102,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "DarkenSrcIn" composition equation.
+    /// A pixel blender that implements the "OverlayDestOver" composition equation.
     /// </summary>
-    public class DarkenSrcIn : PixelBlender<TPixel>
+    public class OverlayDestOver : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static DarkenSrcIn Instance { get; } = new DarkenSrcIn();
+        public static OverlayDestOver Instance { get; } = new OverlayDestOver();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3354,7 +13148,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -3364,21 +13158,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3386,65 +13182,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcIn" composition equation.
-    /// </summary>
-    public class LightenSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcIn Instance { get; } = new LightenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3453,34 +13219,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -3489,9 +13265,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -3503,10 +13279,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -3514,33 +13289,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlaySrcIn" composition equation.
+    /// A pixel blender that implements the "HardLightDestOver" composition equation.
     /// </summary>
-    public class OverlaySrcIn : PixelBlender<TPixel>
+    public class HardLightDestOver : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static OverlaySrcIn Instance { get; } = new OverlaySrcIn();
+        public static HardLightDestOver Instance { get; } = new HardLightDestOver();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3560,7 +13335,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -3570,21 +13345,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3592,65 +13369,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
                 }
             }
             else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcIn" composition equation.
-    /// </summary>
-    public class HardLightSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcIn Instance { get; } = new HardLightSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3659,34 +13406,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -3695,9 +13452,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -3709,10 +13466,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -3720,33 +13476,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "NormalSrcOut" composition equation.
+    /// A pixel blender that implements the "NormalDestIn" composition equation.
     /// </summary>
-    public class NormalSrcOut : PixelBlender<TPixel>
+    public class NormalDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static NormalSrcOut Instance { get; } = new NormalSrcOut();
+        public static NormalDestIn Instance { get; } = new NormalDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3766,7 +13522,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -3776,21 +13532,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3798,65 +13556,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcOut" composition equation.
-    /// </summary>
-    public class MultiplySrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcOut Instance { get; } = new MultiplySrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -3865,34 +13593,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -3901,9 +13639,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -3915,10 +13653,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -3926,33 +13663,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "AddSrcOut" composition equation.
+    /// A pixel blender that implements the "MultiplyDestIn" composition equation.
     /// </summary>
-    public class AddSrcOut : PixelBlender<TPixel>
+    public class MultiplyDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static AddSrcOut Instance { get; } = new AddSrcOut();
+        public static MultiplyDestIn Instance { get; } = new MultiplyDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3972,7 +13709,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -3982,21 +13719,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4004,65 +13743,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcOut" composition equation.
-    /// </summary>
-    public class SubtractSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcOut Instance { get; } = new SubtractSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4071,34 +13780,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -4107,9 +13826,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -4121,10 +13840,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -4132,33 +13850,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenSrcOut" composition equation.
+    /// A pixel blender that implements the "AddDestIn" composition equation.
     /// </summary>
-    public class ScreenSrcOut : PixelBlender<TPixel>
+    public class AddDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static ScreenSrcOut Instance { get; } = new ScreenSrcOut();
+        public static AddDestIn Instance { get; } = new AddDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4178,7 +13896,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -4188,21 +13906,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4210,65 +13930,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcOut" composition equation.
-    /// </summary>
-    public class DarkenSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcOut Instance { get; } = new DarkenSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4277,34 +13967,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -4313,9 +14013,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -4327,10 +14027,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -4338,33 +14037,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "LightenSrcOut" composition equation.
+    /// A pixel blender that implements the "SubtractDestIn" composition equation.
     /// </summary>
-    public class LightenSrcOut : PixelBlender<TPixel>
+    public class SubtractDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static LightenSrcOut Instance { get; } = new LightenSrcOut();
+        public static SubtractDestIn Instance { get; } = new SubtractDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4384,7 +14083,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -4394,21 +14093,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4416,65 +14117,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcOut" composition equation.
-    /// </summary>
-    public class OverlaySrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcOut Instance { get; } = new OverlaySrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4483,34 +14154,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -4519,9 +14200,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -4533,10 +14214,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -4544,33 +14224,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightSrcOut" composition equation.
+    /// A pixel blender that implements the "ScreenDestIn" composition equation.
     /// </summary>
-    public class HardLightSrcOut : PixelBlender<TPixel>
+    public class ScreenDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static HardLightSrcOut Instance { get; } = new HardLightSrcOut();
+        public static ScreenDestIn Instance { get; } = new ScreenDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4590,7 +14270,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -4600,21 +14280,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4622,65 +14304,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDest" composition equation.
-    /// </summary>
-    public class NormalDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDest Instance { get; } = new NormalDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4689,34 +14341,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -4725,9 +14387,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -4739,10 +14401,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -4750,33 +14411,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplyDest" composition equation.
+    /// A pixel blender that implements the "DarkenDestIn" composition equation.
     /// </summary>
-    public class MultiplyDest : PixelBlender<TPixel>
+    public class DarkenDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static MultiplyDest Instance { get; } = new MultiplyDest();
+        public static DarkenDestIn Instance { get; } = new DarkenDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4796,7 +14457,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -4806,21 +14467,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4828,65 +14491,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
                 }
             }
             else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDest" composition equation.
-    /// </summary>
-    public class AddDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDest Instance { get; } = new AddDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -4895,34 +14528,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -4931,9 +14574,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -4945,10 +14588,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -4956,33 +14598,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractDest" composition equation.
+    /// A pixel blender that implements the "LightenDestIn" composition equation.
     /// </summary>
-    public class SubtractDest : PixelBlender<TPixel>
+    public class LightenDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static SubtractDest Instance { get; } = new SubtractDest();
+        public static LightenDestIn Instance { get; } = new LightenDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5002,7 +14644,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -5012,21 +14654,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5034,65 +14678,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDest" composition equation.
-    /// </summary>
-    public class ScreenDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDest Instance { get; } = new ScreenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5101,34 +14715,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -5137,9 +14761,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -5151,10 +14775,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -5162,33 +14785,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "DarkenDest" composition equation.
+    /// A pixel blender that implements the "OverlayDestIn" composition equation.
     /// </summary>
-    public class DarkenDest : PixelBlender<TPixel>
+    public class OverlayDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static DarkenDest Instance { get; } = new DarkenDest();
+        public static OverlayDestIn Instance { get; } = new OverlayDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5208,7 +14831,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -5218,21 +14841,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5240,65 +14865,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDest" composition equation.
-    /// </summary>
-    public class LightenDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDest Instance { get; } = new LightenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5307,34 +14902,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -5343,9 +14948,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -5357,10 +14962,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -5368,33 +14972,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlayDest" composition equation.
+    /// A pixel blender that implements the "HardLightDestIn" composition equation.
     /// </summary>
-    public class OverlayDest : PixelBlender<TPixel>
+    public class HardLightDestIn : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static OverlayDest Instance { get; } = new OverlayDest();
+        public static HardLightDestIn Instance { get; } = new HardLightDestIn();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5414,7 +15018,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -5424,21 +15028,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5446,65 +15052,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDest" composition equation.
-    /// </summary>
-    public class HardLightDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDest Instance { get; } = new HardLightDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5513,34 +15089,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -5549,9 +15135,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -5563,10 +15149,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -5574,33 +15159,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "NormalDestAtop" composition equation.
+    /// A pixel blender that implements the "NormalDestOut" composition equation.
     /// </summary>
-    public class NormalDestAtop : PixelBlender<TPixel>
+    public class NormalDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static NormalDestAtop Instance { get; } = new NormalDestAtop();
+        public static NormalDestOut Instance { get; } = new NormalDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5620,7 +15205,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -5630,21 +15215,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5652,65 +15239,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestAtop" composition equation.
-    /// </summary>
-    public class MultiplyDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestAtop Instance { get; } = new MultiplyDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5719,34 +15276,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -5755,9 +15322,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -5769,10 +15336,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -5780,33 +15346,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "AddDestAtop" composition equation.
+    /// A pixel blender that implements the "MultiplyDestOut" composition equation.
     /// </summary>
-    public class AddDestAtop : PixelBlender<TPixel>
+    public class MultiplyDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static AddDestAtop Instance { get; } = new AddDestAtop();
+        public static MultiplyDestOut Instance { get; } = new MultiplyDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5826,7 +15392,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -5836,21 +15402,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5858,65 +15426,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestAtop" composition equation.
-    /// </summary>
-    public class SubtractDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestAtop Instance { get; } = new SubtractDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -5925,34 +15463,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -5961,9 +15509,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -5975,10 +15523,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -5986,33 +15533,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenDestAtop" composition equation.
+    /// A pixel blender that implements the "AddDestOut" composition equation.
     /// </summary>
-    public class ScreenDestAtop : PixelBlender<TPixel>
+    public class AddDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static ScreenDestAtop Instance { get; } = new ScreenDestAtop();
+        public static AddDestOut Instance { get; } = new AddDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6032,7 +15579,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -6042,21 +15589,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6064,65 +15613,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, amount);
                 }
             }
             else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestAtop" composition equation.
-    /// </summary>
-    public class DarkenDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestAtop Instance { get; } = new DarkenDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6131,34 +15650,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -6167,9 +15696,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -6181,10 +15710,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -6192,33 +15720,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "LightenDestAtop" composition equation.
+    /// A pixel blender that implements the "SubtractDestOut" composition equation.
     /// </summary>
-    public class LightenDestAtop : PixelBlender<TPixel>
+    public class SubtractDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static LightenDestAtop Instance { get; } = new LightenDestAtop();
+        public static SubtractDestOut Instance { get; } = new SubtractDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6238,7 +15766,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -6248,21 +15776,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6270,65 +15800,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestAtop" composition equation.
-    /// </summary>
-    public class OverlayDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestAtop Instance { get; } = new OverlayDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6337,34 +15837,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -6373,9 +15883,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -6387,10 +15897,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -6398,33 +15907,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightDestAtop" composition equation.
+    /// A pixel blender that implements the "ScreenDestOut" composition equation.
     /// </summary>
-    public class HardLightDestAtop : PixelBlender<TPixel>
+    public class ScreenDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static HardLightDestAtop Instance { get; } = new HardLightDestAtop();
+        public static ScreenDestOut Instance { get; } = new ScreenDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6444,7 +15953,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -6454,21 +15963,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6476,65 +15987,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestOver" composition equation.
-    /// </summary>
-    public class NormalDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestOver Instance { get; } = new NormalDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6543,34 +16024,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -6579,9 +16070,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -6593,10 +16084,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -6604,33 +16094,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplyDestOver" composition equation.
+    /// A pixel blender that implements the "DarkenDestOut" composition equation.
     /// </summary>
-    public class MultiplyDestOver : PixelBlender<TPixel>
+    public class DarkenDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static MultiplyDestOver Instance { get; } = new MultiplyDestOver();
+        public static DarkenDestOut Instance { get; } = new DarkenDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6650,7 +16140,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -6660,21 +16150,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6682,65 +16174,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestOver" composition equation.
-    /// </summary>
-    public class AddDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestOver Instance { get; } = new AddDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6749,34 +16211,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -6785,9 +16257,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -6799,10 +16271,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -6810,33 +16281,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractDestOver" composition equation.
+    /// A pixel blender that implements the "LightenDestOut" composition equation.
     /// </summary>
-    public class SubtractDestOver : PixelBlender<TPixel>
+    public class LightenDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static SubtractDestOver Instance { get; } = new SubtractDestOver();
+        public static LightenDestOut Instance { get; } = new LightenDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6856,7 +16327,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -6866,21 +16337,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6888,65 +16361,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestOver" composition equation.
-    /// </summary>
-    public class ScreenDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestOver Instance { get; } = new ScreenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -6955,34 +16398,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -6991,9 +16444,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -7005,10 +16458,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -7016,33 +16468,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "DarkenDestOver" composition equation.
+    /// A pixel blender that implements the "OverlayDestOut" composition equation.
     /// </summary>
-    public class DarkenDestOver : PixelBlender<TPixel>
+    public class OverlayDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static DarkenDestOver Instance { get; } = new DarkenDestOver();
+        public static OverlayDestOut Instance { get; } = new OverlayDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7062,7 +16514,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -7072,21 +16524,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7094,65 +16548,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestOver" composition equation.
-    /// </summary>
-    public class LightenDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestOver Instance { get; } = new LightenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7161,34 +16585,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -7197,9 +16631,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -7211,10 +16645,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -7222,33 +16655,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlayDestOver" composition equation.
+    /// A pixel blender that implements the "HardLightDestOut" composition equation.
     /// </summary>
-    public class OverlayDestOver : PixelBlender<TPixel>
+    public class HardLightDestOut : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static OverlayDestOver Instance { get; } = new OverlayDestOver();
+        public static HardLightDestOut Instance { get; } = new HardLightDestOut();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7268,7 +16701,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -7278,21 +16711,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7300,65 +16735,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
                 }
             }
             else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestOver" composition equation.
-    /// </summary>
-    public class HardLightDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestOver Instance { get; } = new HardLightDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7367,34 +16772,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -7403,9 +16818,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -7417,10 +16832,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -7428,33 +16842,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "NormalDestIn" composition equation.
+    /// A pixel blender that implements the "NormalClear" composition equation.
     /// </summary>
-    public class NormalDestIn : PixelBlender<TPixel>
+    public class NormalClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static NormalDestIn Instance { get; } = new NormalDestIn();
+        public static NormalClear Instance { get; } = new NormalClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7474,7 +16888,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -7484,21 +16898,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7506,65 +16922,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestIn" composition equation.
-    /// </summary>
-    public class MultiplyDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestIn Instance { get; } = new MultiplyDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7573,34 +16959,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -7609,9 +17005,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -7623,10 +17019,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -7634,33 +17029,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "AddDestIn" composition equation.
+    /// A pixel blender that implements the "MultiplyClear" composition equation.
     /// </summary>
-    public class AddDestIn : PixelBlender<TPixel>
+    public class MultiplyClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static AddDestIn Instance { get; } = new AddDestIn();
+        public static MultiplyClear Instance { get; } = new MultiplyClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7680,7 +17075,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -7690,21 +17085,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7712,65 +17109,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestIn" composition equation.
-    /// </summary>
-    public class SubtractDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestIn Instance { get; } = new SubtractDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7779,34 +17146,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -7815,9 +17192,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -7829,10 +17206,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -7840,33 +17216,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenDestIn" composition equation.
+    /// A pixel blender that implements the "AddClear" composition equation.
     /// </summary>
-    public class ScreenDestIn : PixelBlender<TPixel>
+    public class AddClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static ScreenDestIn Instance { get; } = new ScreenDestIn();
+        public static AddClear Instance { get; } = new AddClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7886,7 +17262,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -7896,21 +17272,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7918,65 +17296,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestIn" composition equation.
-    /// </summary>
-    public class DarkenDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestIn Instance { get; } = new DarkenDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -7985,34 +17333,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -8021,9 +17379,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -8035,10 +17393,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -8046,33 +17403,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "LightenDestIn" composition equation.
+    /// A pixel blender that implements the "SubtractClear" composition equation.
     /// </summary>
-    public class LightenDestIn : PixelBlender<TPixel>
+    public class SubtractClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static LightenDestIn Instance { get; } = new LightenDestIn();
+        public static SubtractClear Instance { get; } = new SubtractClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8092,7 +17449,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -8102,21 +17459,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8124,65 +17483,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestIn" composition equation.
-    /// </summary>
-    public class OverlayDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestIn Instance { get; } = new OverlayDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8191,34 +17520,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -8227,9 +17566,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -8241,10 +17580,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -8252,33 +17590,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightDestIn" composition equation.
+    /// A pixel blender that implements the "ScreenClear" composition equation.
     /// </summary>
-    public class HardLightDestIn : PixelBlender<TPixel>
+    public class ScreenClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static HardLightDestIn Instance { get; } = new HardLightDestIn();
+        public static ScreenClear Instance { get; } = new ScreenClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8298,7 +17636,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -8308,21 +17646,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8330,65 +17670,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestOut" composition equation.
-    /// </summary>
-    public class NormalDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestOut Instance { get; } = new NormalDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8397,34 +17707,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -8433,9 +17753,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -8447,10 +17767,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -8458,33 +17777,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplyDestOut" composition equation.
+    /// A pixel blender that implements the "DarkenClear" composition equation.
     /// </summary>
-    public class MultiplyDestOut : PixelBlender<TPixel>
+    public class DarkenClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static MultiplyDestOut Instance { get; } = new MultiplyDestOut();
+        public static DarkenClear Instance { get; } = new DarkenClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8504,7 +17823,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -8514,21 +17833,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8536,65 +17857,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, amount);
                 }
             }
             else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestOut" composition equation.
-    /// </summary>
-    public class AddDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestOut Instance { get; } = new AddDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8603,34 +17894,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -8639,9 +17940,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -8653,10 +17954,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -8664,33 +17964,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractDestOut" composition equation.
+    /// A pixel blender that implements the "LightenClear" composition equation.
     /// </summary>
-    public class SubtractDestOut : PixelBlender<TPixel>
+    public class LightenClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static SubtractDestOut Instance { get; } = new SubtractDestOut();
+        public static LightenClear Instance { get; } = new LightenClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8710,7 +18010,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -8720,21 +18020,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8742,65 +18044,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestOut" composition equation.
-    /// </summary>
-    public class ScreenDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestOut Instance { get; } = new ScreenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8809,34 +18081,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -8845,9 +18127,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -8859,10 +18141,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -8870,33 +18151,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "DarkenDestOut" composition equation.
+    /// A pixel blender that implements the "OverlayClear" composition equation.
     /// </summary>
-    public class DarkenDestOut : PixelBlender<TPixel>
+    public class OverlayClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static DarkenDestOut Instance { get; } = new DarkenDestOut();
+        public static OverlayClear Instance { get; } = new OverlayClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8916,7 +18197,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -8926,21 +18207,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -8948,65 +18231,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestOut" composition equation.
-    /// </summary>
-    public class LightenDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestOut Instance { get; } = new LightenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9015,34 +18268,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -9051,9 +18314,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -9065,10 +18328,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -9076,33 +18338,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlayDestOut" composition equation.
+    /// A pixel blender that implements the "HardLightClear" composition equation.
     /// </summary>
-    public class OverlayDestOut : PixelBlender<TPixel>
+    public class HardLightClear : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static OverlayDestOut Instance { get; } = new OverlayDestOut();
+        public static HardLightClear Instance { get; } = new HardLightClear();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9122,7 +18384,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -9132,21 +18394,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9154,65 +18418,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestOut" composition equation.
-    /// </summary>
-    public class HardLightDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestOut Instance { get; } = new HardLightDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, amount);
+                }
+            }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9221,34 +18455,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -9257,9 +18501,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -9271,10 +18515,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -9282,33 +18525,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "NormalClear" composition equation.
+    /// A pixel blender that implements the "NormalXor" composition equation.
     /// </summary>
-    public class NormalClear : PixelBlender<TPixel>
+    public class NormalXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static NormalClear Instance { get; } = new NormalClear();
+        public static NormalXor Instance { get; } = new NormalXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9328,7 +18571,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -9338,21 +18581,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9360,65 +18605,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyClear" composition equation.
-    /// </summary>
-    public class MultiplyClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyClear Instance { get; } = new MultiplyClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9427,34 +18642,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -9463,9 +18688,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -9477,10 +18702,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -9488,33 +18712,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "AddClear" composition equation.
+    /// A pixel blender that implements the "MultiplyXor" composition equation.
     /// </summary>
-    public class AddClear : PixelBlender<TPixel>
+    public class MultiplyXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static AddClear Instance { get; } = new AddClear();
+        public static MultiplyXor Instance { get; } = new MultiplyXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9534,7 +18758,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -9544,21 +18768,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9566,65 +18792,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractClear" composition equation.
-    /// </summary>
-    public class SubtractClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractClear Instance { get; } = new SubtractClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9633,34 +18829,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -9669,9 +18875,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -9683,10 +18889,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -9694,33 +18899,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenClear" composition equation.
+    /// A pixel blender that implements the "AddXor" composition equation.
     /// </summary>
-    public class ScreenClear : PixelBlender<TPixel>
+    public class AddXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static ScreenClear Instance { get; } = new ScreenClear();
+        public static AddXor Instance { get; } = new AddXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9740,7 +18945,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -9750,21 +18955,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9772,65 +18979,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenClear" composition equation.
-    /// </summary>
-    public class DarkenClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenClear Instance { get; } = new DarkenClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9839,34 +19016,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -9875,9 +19062,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -9889,10 +19076,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -9900,33 +19086,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "LightenClear" composition equation.
+    /// A pixel blender that implements the "SubtractXor" composition equation.
     /// </summary>
-    public class LightenClear : PixelBlender<TPixel>
+    public class SubtractXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static LightenClear Instance { get; } = new LightenClear();
+        public static SubtractXor Instance { get; } = new SubtractXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9946,7 +19132,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -9956,21 +19142,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -9978,65 +19166,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayClear" composition equation.
-    /// </summary>
-    public class OverlayClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayClear Instance { get; } = new OverlayClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10045,34 +19203,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -10081,9 +19249,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -10095,10 +19263,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -10106,33 +19273,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightClear" composition equation.
+    /// A pixel blender that implements the "ScreenXor" composition equation.
     /// </summary>
-    public class HardLightClear : PixelBlender<TPixel>
+    public class ScreenXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static HardLightClear Instance { get; } = new HardLightClear();
+        public static ScreenXor Instance { get; } = new ScreenXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10152,7 +19319,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -10162,21 +19329,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10184,65 +19353,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalXor" composition equation.
-    /// </summary>
-    public class NormalXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalXor Instance { get; } = new NormalXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10251,34 +19390,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -10287,9 +19436,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -10301,10 +19450,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -10312,33 +19460,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplyXor" composition equation.
+    /// A pixel blender that implements the "DarkenXor" composition equation.
     /// </summary>
-    public class MultiplyXor : PixelBlender<TPixel>
+    public class DarkenXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static MultiplyXor Instance { get; } = new MultiplyXor();
+        public static DarkenXor Instance { get; } = new DarkenXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10358,7 +19506,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -10368,21 +19516,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10390,65 +19540,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddXor" composition equation.
-    /// </summary>
-    public class AddXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddXor Instance { get; } = new AddXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.AddXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10457,34 +19577,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -10493,9 +19623,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -10507,10 +19637,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -10518,33 +19647,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractXor" composition equation.
+    /// A pixel blender that implements the "LightenXor" composition equation.
     /// </summary>
-    public class SubtractXor : PixelBlender<TPixel>
+    public class LightenXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static SubtractXor Instance { get; } = new SubtractXor();
+        public static LightenXor Instance { get; } = new LightenXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10564,7 +19693,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -10574,21 +19703,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10596,65 +19727,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenXor" composition equation.
-    /// </summary>
-    public class ScreenXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenXor Instance { get; } = new ScreenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10663,34 +19764,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -10699,9 +19810,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -10713,10 +19824,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -10724,33 +19834,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "DarkenXor" composition equation.
+    /// A pixel blender that implements the "OverlayXor" composition equation.
     /// </summary>
-    public class DarkenXor : PixelBlender<TPixel>
+    public class OverlayXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static DarkenXor Instance { get; } = new DarkenXor();
+        public static OverlayXor Instance { get; } = new OverlayXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10770,7 +19880,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -10780,21 +19890,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10802,65 +19914,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenXor" composition equation.
-    /// </summary>
-    public class LightenXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenXor Instance { get; } = new LightenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -10869,34 +19951,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -10905,9 +19997,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -10919,10 +20011,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                         Vector128.Create(Unsafe.Add(ref amountBase, 1)));
                     opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
 
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -10930,33 +20021,33 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlayXor" composition equation.
+    /// A pixel blender that implements the "HardLightXor" composition equation.
     /// </summary>
-    public class OverlayXor : PixelBlender<TPixel>
+    public class HardLightXor : PixelBlender<TPixel>
     {
         /// <summary>
         /// Gets the static instance of this blender.
         /// </summary>
-        public static OverlayXor Instance { get; } = new OverlayXor();
+        public static HardLightXor Instance { get; } = new HardLightXor();
 
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10976,7 +20067,7 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
@@ -10986,21 +20077,23 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
         {
+            amount = Numerics.Clamp(amount, 0, 1);
+
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -11008,65 +20101,35 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, amount);
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, amount);
                 }
             }
         }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightXor" composition equation.
-    /// </summary>
-    public class HardLightXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightXor Instance { get; } = new HardLightXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            amount = Numerics.Clamp(amount, 0, 1);
-
             if (Avx2.IsSupported && destination.Length >= 2)
             {
                 // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
@@ -11075,34 +20138,44 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
                 ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
                 {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
                     destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
                     sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
                 if (Numerics.Modulo2(destination.Length) != 0)
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
         {
             if (Avx2.IsSupported && destination.Length >= 2)
             {
@@ -11111,9 +20184,9 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
 
                 ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref float amountBase = ref MemoryMarshal.GetReference(amount);
 
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
                 Vector256<float> vOne = Vector256.Create(1F);
 
                 while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
@@ -11128,7 +20201,6 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                     destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
                     destinationBase = ref Unsafe.Add(ref destinationBase, 1);
                     backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                     amountBase = ref Unsafe.Add(ref amountBase, 2);
                 }
 
@@ -11136,14 +20208,14 @@ protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Ve
                 {
                     // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
                     int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
             else
             {
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
                 }
             }
         }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
index 5b71bb0a64..3b885826b8 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
@@ -123,6 +123,44 @@ var blenders = new []{
             }
         }
 
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
+        {
+            amount = Numerics.Clamp(amount, 0, 1);
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
+                }
+            }
+        }
+
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
@@ -169,6 +207,52 @@ var blenders = new []{
                 }
             }
         }
+
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
+                Vector256<float> vOne = Vector256.Create(1F);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // We need to create a Vector256<float> containing the current and next amount values
+                    // taking up each half of the Vector256<float> and then clamp them.
+                    Vector256<float> opacity = Vector256.Create(
+                        Vector128.Create(amountBase),
+                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
+                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+
+                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 2);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+        }
     }
 
 <#
diff --git a/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs
index 4ed6174386..bad9ae01c1 100644
--- a/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs
@@ -64,6 +64,39 @@ public void Blend<TPixelSrc>(
         PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, destinationVectors[..maxLength], destination, PixelConversionModifiers.Scale);
     }
 
+    /// <summary>
+    /// Blends a row against a constant source color.
+    /// </summary>
+    /// <param name="configuration"><see cref="Configuration"/> to use internally</param>
+    /// <param name="destination">the destination span</param>
+    /// <param name="background">the background span</param>
+    /// <param name="source">the source color</param>
+    /// <param name="amount">
+    /// A value between 0 and 1 indicating the weight of the second source vector.
+    /// At amount = 0, "background" is returned, at amount = 1, "source" is returned.
+    /// </param>
+    public void Blend(
+        Configuration configuration,
+        Span<TPixel> destination,
+        ReadOnlySpan<TPixel> background,
+        TPixel source,
+        float amount)
+    {
+        int maxLength = destination.Length;
+        Guard.MustBeGreaterThanOrEqualTo(background.Length, maxLength, nameof(background.Length));
+        Guard.MustBeBetweenOrEqualTo(amount, 0, 1, nameof(amount));
+
+        using IMemoryOwner<Vector4> buffer = configuration.MemoryAllocator.Allocate<Vector4>(maxLength * 2);
+        Span<Vector4> destinationVectors = buffer.Slice(0, maxLength);
+        Span<Vector4> backgroundVectors = buffer.Slice(maxLength, maxLength);
+
+        PixelOperations<TPixel>.Instance.ToVector4(configuration, background[..maxLength], backgroundVectors, PixelConversionModifiers.Scale);
+
+        this.BlendFunction(destinationVectors, backgroundVectors, source.ToScaledVector4(), amount);
+
+        PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, destinationVectors[..maxLength], destination, PixelConversionModifiers.Scale);
+    }
+
     /// <summary>
     /// Blends 2 rows together
     /// </summary>
@@ -121,6 +154,39 @@ public void Blend<TPixelSrc>(
         PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, destinationVectors[..maxLength], destination, PixelConversionModifiers.Scale);
     }
 
+    /// <summary>
+    /// Blends a row against a constant source color.
+    /// </summary>
+    /// <param name="configuration"><see cref="Configuration"/> to use internally</param>
+    /// <param name="destination">the destination span</param>
+    /// <param name="background">the background span</param>
+    /// <param name="source">the source color</param>
+    /// <param name="amount">
+    /// A span with values between 0 and 1 indicating the weight of the second source vector.
+    /// At amount = 0, "background" is returned, at amount = 1, "source" is returned.
+    /// </param>
+    public void Blend(
+        Configuration configuration,
+        Span<TPixel> destination,
+        ReadOnlySpan<TPixel> background,
+        TPixel source,
+        ReadOnlySpan<float> amount)
+    {
+        int maxLength = destination.Length;
+        Guard.MustBeGreaterThanOrEqualTo(background.Length, maxLength, nameof(background.Length));
+        Guard.MustBeGreaterThanOrEqualTo(amount.Length, maxLength, nameof(amount.Length));
+
+        using IMemoryOwner<Vector4> buffer = configuration.MemoryAllocator.Allocate<Vector4>(maxLength * 2);
+        Span<Vector4> destinationVectors = buffer.Slice(0, maxLength);
+        Span<Vector4> backgroundVectors = buffer.Slice(maxLength, maxLength);
+
+        PixelOperations<TPixel>.Instance.ToVector4(configuration, background[..maxLength], backgroundVectors, PixelConversionModifiers.Scale);
+
+        this.BlendFunction(destinationVectors, backgroundVectors, source.ToScaledVector4(), amount);
+
+        PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, destinationVectors[..maxLength], destination, PixelConversionModifiers.Scale);
+    }
+
     /// <summary>
     /// Blend 2 rows together.
     /// </summary>
@@ -137,6 +203,22 @@ protected abstract void BlendFunction(
         ReadOnlySpan<Vector4> source,
         float amount);
 
+    /// <summary>
+    /// Blend a row against a constant source color.
+    /// </summary>
+    /// <param name="destination">destination span</param>
+    /// <param name="background">the background span</param>
+    /// <param name="source">the source color vector</param>
+    /// <param name="amount">
+    /// A value between 0 and 1 indicating the weight of the second source vector.
+    /// At amount = 0, "background" is returned, at amount = 1, "source" is returned.
+    /// </param>
+    protected abstract void BlendFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        Vector4 source,
+        float amount);
+
     /// <summary>
     /// Blend 2 rows together.
     /// </summary>
@@ -152,4 +234,20 @@ protected abstract void BlendFunction(
         ReadOnlySpan<Vector4> background,
         ReadOnlySpan<Vector4> source,
         ReadOnlySpan<float> amount);
+
+    /// <summary>
+    /// Blend a row against a constant source color.
+    /// </summary>
+    /// <param name="destination">destination span</param>
+    /// <param name="background">the background span</param>
+    /// <param name="source">the source color vector</param>
+    /// <param name="amount">
+    /// A span with values between 0 and 1 indicating the weight of the second source vector.
+    /// At amount = 0, "background" is returned, at amount = 1, "source" is returned.
+    /// </param>
+    protected abstract void BlendFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        Vector4 source,
+        ReadOnlySpan<float> amount);
 }
diff --git a/src/ImageSharp/Primitives/Point.cs b/src/ImageSharp/Primitives/Point.cs
index 7660855479..99193e3bb0 100644
--- a/src/ImageSharp/Primitives/Point.cs
+++ b/src/ImageSharp/Primitives/Point.cs
@@ -233,7 +233,8 @@ public Point(Size size)
     /// <param name="matrix">The transformation matrix used.</param>
     /// <returns>The transformed <see cref="PointF"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Point Transform(Point point, Matrix3x2 matrix) => Round(Vector2.Transform(new Vector2(point.X, point.Y), matrix));
+    public static PointF Transform(Point point, Matrix3x2 matrix)
+        => Vector2.Transform(new Vector2(point.X, point.Y), matrix);
 
     /// <summary>
     /// Transforms a point by a specified 4x4 matrix, applying a projective transform
@@ -241,10 +242,10 @@ public Point(Size size)
     /// </summary>
     /// <param name="point">The point to transform.</param>
     /// <param name="matrix">The transformation matrix used.</param>
-    /// <returns>The transformed <see cref="Point"/>.</returns>
+    /// <returns>The transformed <see cref="PointF"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Point Transform(Point point, Matrix4x4 matrix)
-        => Round(TransformUtilities.ProjectiveTransform2D(point.X, point.Y, matrix));
+    public static PointF Transform(Point point, Matrix4x4 matrix)
+        => TransformUtilities.ProjectiveTransform2D(point.X, point.Y, matrix);
 
     /// <summary>
     /// Deconstructs this point into two integers.
diff --git a/src/ImageSharp/Primitives/Rectangle.cs b/src/ImageSharp/Primitives/Rectangle.cs
index 6494964412..26a94837fe 100644
--- a/src/ImageSharp/Primitives/Rectangle.cs
+++ b/src/ImageSharp/Primitives/Rectangle.cs
@@ -260,11 +260,7 @@ public static Rectangle Ceiling(RectangleF rectangle)
     /// <param name="matrix">The transformation matrix.</param>
     /// <returns>A transformed rectangle.</returns>
     public static RectangleF Transform(Rectangle rectangle, Matrix3x2 matrix)
-    {
-        PointF bottomRight = Point.Transform(new Point(rectangle.Right, rectangle.Bottom), matrix);
-        PointF topLeft = Point.Transform(rectangle.Location, matrix);
-        return new RectangleF(topLeft, new SizeF(bottomRight - topLeft));
-    }
+        => RectangleF.Transform(rectangle, matrix);
 
     /// <summary>
     /// Transforms a rectangle by the given 4x4 matrix, applying a projective transform
@@ -274,11 +270,7 @@ public static RectangleF Transform(Rectangle rectangle, Matrix3x2 matrix)
     /// <param name="matrix">The transformation matrix.</param>
     /// <returns>A transformed rectangle.</returns>
     public static RectangleF Transform(Rectangle rectangle, Matrix4x4 matrix)
-    {
-        PointF bottomRight = PointF.Transform(new PointF(rectangle.Right, rectangle.Bottom), matrix);
-        PointF topLeft = PointF.Transform(new PointF(rectangle.Location.X, rectangle.Location.Y), matrix);
-        return new RectangleF(topLeft, new SizeF(bottomRight - topLeft));
-    }
+        => RectangleF.Transform(rectangle, matrix);
 
     /// <summary>
     /// Converts a <see cref="RectangleF"/> to a <see cref="Rectangle"/> by performing a truncate operation on all the coordinates.
diff --git a/src/ImageSharp/Primitives/RectangleF.cs b/src/ImageSharp/Primitives/RectangleF.cs
index a66e3fcad6..3f41c2d073 100644
--- a/src/ImageSharp/Primitives/RectangleF.cs
+++ b/src/ImageSharp/Primitives/RectangleF.cs
@@ -236,9 +236,17 @@ public static RectangleF Inflate(RectangleF rectangle, float x, float y)
     /// <returns>A transformed <see cref="RectangleF"/>.</returns>
     public static RectangleF Transform(RectangleF rectangle, Matrix3x2 matrix)
     {
-        PointF bottomRight = PointF.Transform(new PointF(rectangle.Right, rectangle.Bottom), matrix);
         PointF topLeft = PointF.Transform(rectangle.Location, matrix);
-        return new RectangleF(topLeft, new SizeF(bottomRight - topLeft));
+        PointF topRight = PointF.Transform(new PointF(rectangle.Right, rectangle.Top), matrix);
+        PointF bottomLeft = PointF.Transform(new PointF(rectangle.Left, rectangle.Bottom), matrix);
+        PointF bottomRight = PointF.Transform(new PointF(rectangle.Right, rectangle.Bottom), matrix);
+
+        float left = MathF.Min(MathF.Min(topLeft.X, topRight.X), MathF.Min(bottomLeft.X, bottomRight.X));
+        float top = MathF.Min(MathF.Min(topLeft.Y, topRight.Y), MathF.Min(bottomLeft.Y, bottomRight.Y));
+        float right = MathF.Max(MathF.Max(topLeft.X, topRight.X), MathF.Max(bottomLeft.X, bottomRight.X));
+        float bottom = MathF.Max(MathF.Max(topLeft.Y, topRight.Y), MathF.Max(bottomLeft.Y, bottomRight.Y));
+
+        return FromLTRB(left, top, right, bottom);
     }
 
     /// <summary>
@@ -250,9 +258,17 @@ public static RectangleF Transform(RectangleF rectangle, Matrix3x2 matrix)
     /// <returns>A transformed <see cref="RectangleF"/>.</returns>
     public static RectangleF Transform(RectangleF rectangle, Matrix4x4 matrix)
     {
-        PointF bottomRight = PointF.Transform(new PointF(rectangle.Right, rectangle.Bottom), matrix);
         PointF topLeft = PointF.Transform(rectangle.Location, matrix);
-        return new RectangleF(topLeft, new SizeF(bottomRight - topLeft));
+        PointF topRight = PointF.Transform(new PointF(rectangle.Right, rectangle.Top), matrix);
+        PointF bottomLeft = PointF.Transform(new PointF(rectangle.Left, rectangle.Bottom), matrix);
+        PointF bottomRight = PointF.Transform(new PointF(rectangle.Right, rectangle.Bottom), matrix);
+
+        float left = MathF.Min(MathF.Min(topLeft.X, topRight.X), MathF.Min(bottomLeft.X, bottomRight.X));
+        float top = MathF.Min(MathF.Min(topLeft.Y, topRight.Y), MathF.Min(bottomLeft.Y, bottomRight.Y));
+        float right = MathF.Max(MathF.Max(topLeft.X, topRight.X), MathF.Max(bottomLeft.X, bottomRight.X));
+        float bottom = MathF.Max(MathF.Max(topLeft.Y, topRight.Y), MathF.Max(bottomLeft.Y, bottomRight.Y));
+
+        return FromLTRB(left, top, right, bottom);
     }
 
     /// <summary>
diff --git a/tests/ImageSharp.Tests/Primitives/PointTests.cs b/tests/ImageSharp.Tests/Primitives/PointTests.cs
index 22c18a1470..d2192f53bb 100644
--- a/tests/ImageSharp.Tests/Primitives/PointTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/PointTests.cs
@@ -159,9 +159,10 @@ public void RotateTest()
         Point p = new(13, 17);
         Matrix3x2 matrix = Matrix3x2Extensions.CreateRotationDegrees(45, Point.Empty);
 
-        Point pout = Point.Transform(p, matrix);
+        PointF pout = Point.Transform(p, matrix);
 
-        Assert.Equal(new Point(-3, 21), pout);
+        Assert.Equal(-2.828427F, pout.X, 4);
+        Assert.Equal(21.213203F, pout.Y, 4);
     }
 
     [Fact]
@@ -170,8 +171,9 @@ public void SkewTest()
         Point p = new(13, 17);
         Matrix3x2 matrix = Matrix3x2Extensions.CreateSkewDegrees(45, 45, Point.Empty);
 
-        Point pout = Point.Transform(p, matrix);
-        Assert.Equal(new Point(30, 30), pout);
+        PointF pout = Point.Transform(p, matrix);
+        Assert.Equal(30F, pout.X, 4);
+        Assert.Equal(30F, pout.Y, 4);
     }
 
     [Fact]
@@ -181,8 +183,8 @@ public void TransformMatrix4x4_AffineMatchesMatrix3x2()
         Matrix3x2 m3 = Matrix3x2Extensions.CreateRotationDegrees(45, Point.Empty);
         Matrix4x4 m4 = new(m3);
 
-        Point r3 = Point.Transform(p, m3);
-        Point r4 = Point.Transform(p, m4);
+        PointF r3 = Point.Transform(p, m3);
+        PointF r4 = Point.Transform(p, m4);
 
         Assert.Equal(r3, r4);
     }
@@ -191,9 +193,9 @@ public void TransformMatrix4x4_AffineMatchesMatrix3x2()
     public void TransformMatrix4x4_Identity()
     {
         Point p = new(42, -17);
-        Point result = Point.Transform(p, Matrix4x4.Identity);
+        PointF result = Point.Transform(p, Matrix4x4.Identity);
 
-        Assert.Equal(p, result);
+        Assert.Equal((PointF)p, result);
     }
 
     [Fact]
@@ -201,9 +203,10 @@ public void TransformMatrix4x4_Translation()
     {
         Point p = new(10, 20);
         Matrix4x4 m = Matrix4x4.CreateTranslation(5, -3, 0);
-        Point result = Point.Transform(p, m);
+        PointF result = Point.Transform(p, m);
 
-        Assert.Equal(new Point(15, 17), result);
+        Assert.Equal(15F, result.X, 4);
+        Assert.Equal(17F, result.Y, 4);
     }
 
     [Fact]
@@ -213,10 +216,11 @@ public void TransformMatrix4x4_Projective()
         Matrix4x4 m = Matrix4x4.Identity;
         m.M14 = 0.005F;
 
-        Point result = Point.Transform(p, m);
+        PointF result = Point.Transform(p, m);
 
-        // W = 100*0.005 + 1 = 1.5 => (100/1.5, 50/1.5) => rounded
-        Assert.Equal(Point.Round(new PointF(100F / 1.5F, 50F / 1.5F)), result);
+        // W = 100*0.005 + 1 = 1.5 => (100/1.5, 50/1.5)
+        Assert.Equal(100F / 1.5F, result.X, 4);
+        Assert.Equal(50F / 1.5F, result.Y, 4);
     }
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs b/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs
index e3a13618bd..9a6ff0957b 100644
--- a/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs
@@ -286,6 +286,19 @@ public void TransformMatrix4x4_Scale()
         Assert.Equal(new RectangleF(20, 60, 200, 150), result);
     }
 
+    [Fact]
+    public void TransformMatrix4x4_RotationReturnsBoundingBox()
+    {
+        RectangleF rect = new(10, 20, 100, 50);
+        Matrix4x4 m = Matrix4x4.CreateRotationZ(MathF.PI / 2F);
+        RectangleF result = RectangleF.Transform(rect, m);
+
+        Assert.Equal(-70F, result.X, 4);
+        Assert.Equal(10F, result.Y, 4);
+        Assert.Equal(50F, result.Width, 4);
+        Assert.Equal(100F, result.Height, 4);
+    }
+
     [Fact]
     public void ToStringTest()
     {
diff --git a/tests/ImageSharp.Tests/Primitives/RectangleTests.cs b/tests/ImageSharp.Tests/Primitives/RectangleTests.cs
index 104bce7541..a8ce990789 100644
--- a/tests/ImageSharp.Tests/Primitives/RectangleTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/RectangleTests.cs
@@ -327,6 +327,19 @@ public void TransformMatrix4x4_Translation()
         Assert.Equal(new RectangleF(15, 17, 100, 50), result);
     }
 
+    [Fact]
+    public void TransformMatrix4x4_RotationReturnsBoundingBox()
+    {
+        Rectangle rect = new(10, 20, 100, 50);
+        Matrix4x4 m = Matrix4x4.CreateRotationZ(MathF.PI / 2F);
+        RectangleF result = Rectangle.Transform(rect, m);
+
+        Assert.Equal(-70F, result.X, 4);
+        Assert.Equal(10F, result.Y, 4);
+        Assert.Equal(50F, result.Width, 4);
+        Assert.Equal(100F, result.Height, 4);
+    }
+
     [Fact]
     public void ToStringTest()
     {