diff --git a/src/ImageSharp.Drawing/Processing/GradientBrushBase{TPixel}.cs b/src/ImageSharp.Drawing/Processing/GradientBrushBase{TPixel}.cs
index fe997ed7f..897b3f384 100644
--- a/src/ImageSharp.Drawing/Processing/GradientBrushBase{TPixel}.cs
+++ b/src/ImageSharp.Drawing/Processing/GradientBrushBase{TPixel}.cs
@@ -111,7 +111,7 @@ namespace SixLabors.ImageSharp.Processing
                             throw new ArgumentOutOfRangeException();
                     }
 
-                    var (from, to) = this.GetGradientSegment(positionOnCompleteGradient);
+                    (ColorStop<TPixel> from, ColorStop<TPixel> to) = this.GetGradientSegment(positionOnCompleteGradient);
 
                     if (from.Color.Equals(to.Color))
                     {
@@ -124,7 +124,7 @@ namespace SixLabors.ImageSharp.Processing
                         float onLocalGradient = (positionOnCompleteGradient - from.Ratio) / to.Ratio;
 
                         // TODO: this should be changeble for different gradienting functions
-                        Vector4 result = PorterDuffFunctions.Normal_SrcOver(
+                        Vector4 result = PorterDuffFunctions.NormalSrcOver(
                             fromAsVector,
                             toAsVector,
                             onLocalGradient);
@@ -153,11 +153,11 @@ namespace SixLabors.ImageSharp.Processing
             private (ColorStop<TPixel> from, ColorStop<TPixel> to) GetGradientSegment(
                 float positionOnCompleteGradient)
             {
-                var localGradientFrom = this.colorStops[0];
+                ColorStop<TPixel> localGradientFrom = this.colorStops[0];
                 ColorStop<TPixel> localGradientTo = default;
 
                 // TODO: ensure colorStops has at least 2 items (technically 1 would be okay, but that's no gradient)
-                foreach (var colorStop in this.colorStops)
+                foreach (ColorStop<TPixel> colorStop in this.colorStops)
                 {
                     localGradientTo = colorStop;
 
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
index 1ee9848d6..b454349d7 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
@@ -24,17 +24,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         where TPixel : struct, IPixel<TPixel>
     {
 
-            internal class Normal_Src : PixelBlender<TPixel>
+            internal class NormalSrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_Src Instance { get; } = new Normal_Src();
+                public static NormalSrc Instance { get; } = new NormalSrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_Src(background, source, amount);
+                    return PorterDuffFunctions.NormalSrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -55,7 +55,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -63,17 +63,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_Src : PixelBlender<TPixel>
+            internal class MultiplySrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_Src Instance { get; } = new Multiply_Src();
+                public static MultiplySrc Instance { get; } = new MultiplySrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_Src(background, source, amount);
+                    return PorterDuffFunctions.MultiplySrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -94,7 +94,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplySrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -102,17 +102,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_Src : PixelBlender<TPixel>
+            internal class AddSrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_Src Instance { get; } = new Add_Src();
+                public static AddSrc Instance { get; } = new AddSrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_Src(background, source, amount);
+                    return PorterDuffFunctions.AddSrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -133,7 +133,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -141,17 +141,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_Src : PixelBlender<TPixel>
+            internal class SubtractSrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_Src Instance { get; } = new Subtract_Src();
+                public static SubtractSrc Instance { get; } = new SubtractSrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_Src(background, source, amount);
+                    return PorterDuffFunctions.SubtractSrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -172,7 +172,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -180,17 +180,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_Src : PixelBlender<TPixel>
+            internal class ScreenSrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_Src Instance { get; } = new Screen_Src();
+                public static ScreenSrc Instance { get; } = new ScreenSrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_Src(background, source, amount);
+                    return PorterDuffFunctions.ScreenSrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -211,7 +211,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -219,17 +219,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_Src : PixelBlender<TPixel>
+            internal class DarkenSrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_Src Instance { get; } = new Darken_Src();
+                public static DarkenSrc Instance { get; } = new DarkenSrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_Src(background, source, amount);
+                    return PorterDuffFunctions.DarkenSrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -250,7 +250,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -258,17 +258,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_Src : PixelBlender<TPixel>
+            internal class LightenSrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_Src Instance { get; } = new Lighten_Src();
+                public static LightenSrc Instance { get; } = new LightenSrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_Src(background, source, amount);
+                    return PorterDuffFunctions.LightenSrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -289,7 +289,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -297,17 +297,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_Src : PixelBlender<TPixel>
+            internal class OverlaySrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_Src Instance { get; } = new Overlay_Src();
+                public static OverlaySrc Instance { get; } = new OverlaySrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_Src(background, source, amount);
+                    return PorterDuffFunctions.OverlaySrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -328,7 +328,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlaySrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -336,17 +336,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_Src : PixelBlender<TPixel>
+            internal class HardLightSrc : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_Src Instance { get; } = new HardLight_Src();
+                public static HardLightSrc Instance { get; } = new HardLightSrc();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_Src(background, source, amount);
+                    return PorterDuffFunctions.HardLightSrc(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -367,7 +367,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_Src(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -375,17 +375,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_SrcAtop : PixelBlender<TPixel>
+            internal class NormalSrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_SrcAtop Instance { get; } = new Normal_SrcAtop();
+                public static NormalSrcAtop Instance { get; } = new NormalSrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.NormalSrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -406,7 +406,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -414,17 +414,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_SrcAtop : PixelBlender<TPixel>
+            internal class MultiplySrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_SrcAtop Instance { get; } = new Multiply_SrcAtop();
+                public static MultiplySrcAtop Instance { get; } = new MultiplySrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -445,7 +445,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -453,17 +453,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_SrcAtop : PixelBlender<TPixel>
+            internal class AddSrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_SrcAtop Instance { get; } = new Add_SrcAtop();
+                public static AddSrcAtop Instance { get; } = new AddSrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.AddSrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -484,7 +484,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -492,17 +492,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_SrcAtop : PixelBlender<TPixel>
+            internal class SubtractSrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_SrcAtop Instance { get; } = new Subtract_SrcAtop();
+                public static SubtractSrcAtop Instance { get; } = new SubtractSrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -523,7 +523,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -531,17 +531,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_SrcAtop : PixelBlender<TPixel>
+            internal class ScreenSrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_SrcAtop Instance { get; } = new Screen_SrcAtop();
+                public static ScreenSrcAtop Instance { get; } = new ScreenSrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -562,7 +562,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -570,17 +570,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_SrcAtop : PixelBlender<TPixel>
+            internal class DarkenSrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_SrcAtop Instance { get; } = new Darken_SrcAtop();
+                public static DarkenSrcAtop Instance { get; } = new DarkenSrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -601,7 +601,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -609,17 +609,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_SrcAtop : PixelBlender<TPixel>
+            internal class LightenSrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_SrcAtop Instance { get; } = new Lighten_SrcAtop();
+                public static LightenSrcAtop Instance { get; } = new LightenSrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.LightenSrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -640,7 +640,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -648,17 +648,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_SrcAtop : PixelBlender<TPixel>
+            internal class OverlaySrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_SrcAtop Instance { get; } = new Overlay_SrcAtop();
+                public static OverlaySrcAtop Instance { get; } = new OverlaySrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -679,7 +679,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -687,17 +687,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_SrcAtop : PixelBlender<TPixel>
+            internal class HardLightSrcAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_SrcAtop Instance { get; } = new HardLight_SrcAtop();
+                public static HardLightSrcAtop Instance { get; } = new HardLightSrcAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_SrcAtop(background, source, amount);
+                    return PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -718,7 +718,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_SrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -726,17 +726,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_SrcOver : PixelBlender<TPixel>
+            internal class NormalSrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_SrcOver Instance { get; } = new Normal_SrcOver();
+                public static NormalSrcOver Instance { get; } = new NormalSrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.NormalSrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -757,7 +757,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -765,17 +765,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_SrcOver : PixelBlender<TPixel>
+            internal class MultiplySrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_SrcOver Instance { get; } = new Multiply_SrcOver();
+                public static MultiplySrcOver Instance { get; } = new MultiplySrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.MultiplySrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -796,7 +796,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -804,17 +804,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_SrcOver : PixelBlender<TPixel>
+            internal class AddSrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_SrcOver Instance { get; } = new Add_SrcOver();
+                public static AddSrcOver Instance { get; } = new AddSrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.AddSrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -835,7 +835,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -843,17 +843,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_SrcOver : PixelBlender<TPixel>
+            internal class SubtractSrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_SrcOver Instance { get; } = new Subtract_SrcOver();
+                public static SubtractSrcOver Instance { get; } = new SubtractSrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.SubtractSrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -874,7 +874,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -882,17 +882,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_SrcOver : PixelBlender<TPixel>
+            internal class ScreenSrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_SrcOver Instance { get; } = new Screen_SrcOver();
+                public static ScreenSrcOver Instance { get; } = new ScreenSrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.ScreenSrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -913,7 +913,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -921,17 +921,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_SrcOver : PixelBlender<TPixel>
+            internal class DarkenSrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_SrcOver Instance { get; } = new Darken_SrcOver();
+                public static DarkenSrcOver Instance { get; } = new DarkenSrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.DarkenSrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -952,7 +952,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -960,17 +960,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_SrcOver : PixelBlender<TPixel>
+            internal class LightenSrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_SrcOver Instance { get; } = new Lighten_SrcOver();
+                public static LightenSrcOver Instance { get; } = new LightenSrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.LightenSrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -991,7 +991,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -999,17 +999,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_SrcOver : PixelBlender<TPixel>
+            internal class OverlaySrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_SrcOver Instance { get; } = new Overlay_SrcOver();
+                public static OverlaySrcOver Instance { get; } = new OverlaySrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.OverlaySrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1030,7 +1030,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1038,17 +1038,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_SrcOver : PixelBlender<TPixel>
+            internal class HardLightSrcOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_SrcOver Instance { get; } = new HardLight_SrcOver();
+                public static HardLightSrcOver Instance { get; } = new HardLightSrcOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_SrcOver(background, source, amount);
+                    return PorterDuffFunctions.HardLightSrcOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1069,7 +1069,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1077,17 +1077,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_SrcIn : PixelBlender<TPixel>
+            internal class NormalSrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_SrcIn Instance { get; } = new Normal_SrcIn();
+                public static NormalSrcIn Instance { get; } = new NormalSrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.NormalSrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1108,7 +1108,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1116,17 +1116,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_SrcIn : PixelBlender<TPixel>
+            internal class MultiplySrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_SrcIn Instance { get; } = new Multiply_SrcIn();
+                public static MultiplySrcIn Instance { get; } = new MultiplySrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.MultiplySrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1147,7 +1147,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1155,17 +1155,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_SrcIn : PixelBlender<TPixel>
+            internal class AddSrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_SrcIn Instance { get; } = new Add_SrcIn();
+                public static AddSrcIn Instance { get; } = new AddSrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.AddSrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1186,7 +1186,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1194,17 +1194,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_SrcIn : PixelBlender<TPixel>
+            internal class SubtractSrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_SrcIn Instance { get; } = new Subtract_SrcIn();
+                public static SubtractSrcIn Instance { get; } = new SubtractSrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.SubtractSrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1225,7 +1225,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1233,17 +1233,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_SrcIn : PixelBlender<TPixel>
+            internal class ScreenSrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_SrcIn Instance { get; } = new Screen_SrcIn();
+                public static ScreenSrcIn Instance { get; } = new ScreenSrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.ScreenSrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1264,7 +1264,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1272,17 +1272,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_SrcIn : PixelBlender<TPixel>
+            internal class DarkenSrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_SrcIn Instance { get; } = new Darken_SrcIn();
+                public static DarkenSrcIn Instance { get; } = new DarkenSrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.DarkenSrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1303,7 +1303,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1311,17 +1311,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_SrcIn : PixelBlender<TPixel>
+            internal class LightenSrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_SrcIn Instance { get; } = new Lighten_SrcIn();
+                public static LightenSrcIn Instance { get; } = new LightenSrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.LightenSrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1342,7 +1342,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1350,17 +1350,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_SrcIn : PixelBlender<TPixel>
+            internal class OverlaySrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_SrcIn Instance { get; } = new Overlay_SrcIn();
+                public static OverlaySrcIn Instance { get; } = new OverlaySrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.OverlaySrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1381,7 +1381,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1389,17 +1389,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_SrcIn : PixelBlender<TPixel>
+            internal class HardLightSrcIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_SrcIn Instance { get; } = new HardLight_SrcIn();
+                public static HardLightSrcIn Instance { get; } = new HardLightSrcIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_SrcIn(background, source, amount);
+                    return PorterDuffFunctions.HardLightSrcIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1420,7 +1420,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_SrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1428,17 +1428,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_SrcOut : PixelBlender<TPixel>
+            internal class NormalSrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_SrcOut Instance { get; } = new Normal_SrcOut();
+                public static NormalSrcOut Instance { get; } = new NormalSrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.NormalSrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1459,7 +1459,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1467,17 +1467,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_SrcOut : PixelBlender<TPixel>
+            internal class MultiplySrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_SrcOut Instance { get; } = new Multiply_SrcOut();
+                public static MultiplySrcOut Instance { get; } = new MultiplySrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.MultiplySrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1498,7 +1498,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1506,17 +1506,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_SrcOut : PixelBlender<TPixel>
+            internal class AddSrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_SrcOut Instance { get; } = new Add_SrcOut();
+                public static AddSrcOut Instance { get; } = new AddSrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.AddSrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1537,7 +1537,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1545,17 +1545,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_SrcOut : PixelBlender<TPixel>
+            internal class SubtractSrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_SrcOut Instance { get; } = new Subtract_SrcOut();
+                public static SubtractSrcOut Instance { get; } = new SubtractSrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.SubtractSrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1576,7 +1576,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1584,17 +1584,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_SrcOut : PixelBlender<TPixel>
+            internal class ScreenSrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_SrcOut Instance { get; } = new Screen_SrcOut();
+                public static ScreenSrcOut Instance { get; } = new ScreenSrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.ScreenSrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1615,7 +1615,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1623,17 +1623,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_SrcOut : PixelBlender<TPixel>
+            internal class DarkenSrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_SrcOut Instance { get; } = new Darken_SrcOut();
+                public static DarkenSrcOut Instance { get; } = new DarkenSrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.DarkenSrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1654,7 +1654,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1662,17 +1662,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_SrcOut : PixelBlender<TPixel>
+            internal class LightenSrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_SrcOut Instance { get; } = new Lighten_SrcOut();
+                public static LightenSrcOut Instance { get; } = new LightenSrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.LightenSrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1693,7 +1693,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1701,17 +1701,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_SrcOut : PixelBlender<TPixel>
+            internal class OverlaySrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_SrcOut Instance { get; } = new Overlay_SrcOut();
+                public static OverlaySrcOut Instance { get; } = new OverlaySrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.OverlaySrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1732,7 +1732,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1740,17 +1740,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_SrcOut : PixelBlender<TPixel>
+            internal class HardLightSrcOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_SrcOut Instance { get; } = new HardLight_SrcOut();
+                public static HardLightSrcOut Instance { get; } = new HardLightSrcOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_SrcOut(background, source, amount);
+                    return PorterDuffFunctions.HardLightSrcOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1771,7 +1771,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_SrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1779,17 +1779,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_Dest : PixelBlender<TPixel>
+            internal class NormalDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_Dest Instance { get; } = new Normal_Dest();
+                public static NormalDest Instance { get; } = new NormalDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_Dest(background, source, amount);
+                    return PorterDuffFunctions.NormalDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1810,7 +1810,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1818,17 +1818,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_Dest : PixelBlender<TPixel>
+            internal class MultiplyDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_Dest Instance { get; } = new Multiply_Dest();
+                public static MultiplyDest Instance { get; } = new MultiplyDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_Dest(background, source, amount);
+                    return PorterDuffFunctions.MultiplyDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1849,7 +1849,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplyDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1857,17 +1857,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_Dest : PixelBlender<TPixel>
+            internal class AddDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_Dest Instance { get; } = new Add_Dest();
+                public static AddDest Instance { get; } = new AddDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_Dest(background, source, amount);
+                    return PorterDuffFunctions.AddDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1888,7 +1888,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1896,17 +1896,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_Dest : PixelBlender<TPixel>
+            internal class SubtractDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_Dest Instance { get; } = new Subtract_Dest();
+                public static SubtractDest Instance { get; } = new SubtractDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_Dest(background, source, amount);
+                    return PorterDuffFunctions.SubtractDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1927,7 +1927,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1935,17 +1935,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_Dest : PixelBlender<TPixel>
+            internal class ScreenDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_Dest Instance { get; } = new Screen_Dest();
+                public static ScreenDest Instance { get; } = new ScreenDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_Dest(background, source, amount);
+                    return PorterDuffFunctions.ScreenDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -1966,7 +1966,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -1974,17 +1974,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_Dest : PixelBlender<TPixel>
+            internal class DarkenDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_Dest Instance { get; } = new Darken_Dest();
+                public static DarkenDest Instance { get; } = new DarkenDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_Dest(background, source, amount);
+                    return PorterDuffFunctions.DarkenDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2005,7 +2005,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2013,17 +2013,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_Dest : PixelBlender<TPixel>
+            internal class LightenDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_Dest Instance { get; } = new Lighten_Dest();
+                public static LightenDest Instance { get; } = new LightenDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_Dest(background, source, amount);
+                    return PorterDuffFunctions.LightenDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2044,7 +2044,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2052,17 +2052,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_Dest : PixelBlender<TPixel>
+            internal class OverlayDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_Dest Instance { get; } = new Overlay_Dest();
+                public static OverlayDest Instance { get; } = new OverlayDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_Dest(background, source, amount);
+                    return PorterDuffFunctions.OverlayDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2083,7 +2083,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlayDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2091,17 +2091,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_Dest : PixelBlender<TPixel>
+            internal class HardLightDest : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_Dest Instance { get; } = new HardLight_Dest();
+                public static HardLightDest Instance { get; } = new HardLightDest();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_Dest(background, source, amount);
+                    return PorterDuffFunctions.HardLightDest(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2122,7 +2122,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_Dest(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightDest(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2130,17 +2130,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_DestAtop : PixelBlender<TPixel>
+            internal class NormalDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_DestAtop Instance { get; } = new Normal_DestAtop();
+                public static NormalDestAtop Instance { get; } = new NormalDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.NormalDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2161,7 +2161,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2169,17 +2169,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_DestAtop : PixelBlender<TPixel>
+            internal class MultiplyDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_DestAtop Instance { get; } = new Multiply_DestAtop();
+                public static MultiplyDestAtop Instance { get; } = new MultiplyDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2200,7 +2200,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2208,17 +2208,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_DestAtop : PixelBlender<TPixel>
+            internal class AddDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_DestAtop Instance { get; } = new Add_DestAtop();
+                public static AddDestAtop Instance { get; } = new AddDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.AddDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2239,7 +2239,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2247,17 +2247,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_DestAtop : PixelBlender<TPixel>
+            internal class SubtractDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_DestAtop Instance { get; } = new Subtract_DestAtop();
+                public static SubtractDestAtop Instance { get; } = new SubtractDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.SubtractDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2278,7 +2278,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2286,17 +2286,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_DestAtop : PixelBlender<TPixel>
+            internal class ScreenDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_DestAtop Instance { get; } = new Screen_DestAtop();
+                public static ScreenDestAtop Instance { get; } = new ScreenDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.ScreenDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2317,7 +2317,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2325,17 +2325,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_DestAtop : PixelBlender<TPixel>
+            internal class DarkenDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_DestAtop Instance { get; } = new Darken_DestAtop();
+                public static DarkenDestAtop Instance { get; } = new DarkenDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.DarkenDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2356,7 +2356,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2364,17 +2364,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_DestAtop : PixelBlender<TPixel>
+            internal class LightenDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_DestAtop Instance { get; } = new Lighten_DestAtop();
+                public static LightenDestAtop Instance { get; } = new LightenDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.LightenDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2395,7 +2395,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2403,17 +2403,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_DestAtop : PixelBlender<TPixel>
+            internal class OverlayDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_DestAtop Instance { get; } = new Overlay_DestAtop();
+                public static OverlayDestAtop Instance { get; } = new OverlayDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.OverlayDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2434,7 +2434,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlayDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2442,17 +2442,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_DestAtop : PixelBlender<TPixel>
+            internal class HardLightDestAtop : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_DestAtop Instance { get; } = new HardLight_DestAtop();
+                public static HardLightDestAtop Instance { get; } = new HardLightDestAtop();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_DestAtop(background, source, amount);
+                    return PorterDuffFunctions.HardLightDestAtop(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2473,7 +2473,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_DestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2481,17 +2481,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_DestOver : PixelBlender<TPixel>
+            internal class NormalDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_DestOver Instance { get; } = new Normal_DestOver();
+                public static NormalDestOver Instance { get; } = new NormalDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_DestOver(background, source, amount);
+                    return PorterDuffFunctions.NormalDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2512,7 +2512,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2520,17 +2520,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_DestOver : PixelBlender<TPixel>
+            internal class MultiplyDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_DestOver Instance { get; } = new Multiply_DestOver();
+                public static MultiplyDestOver Instance { get; } = new MultiplyDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_DestOver(background, source, amount);
+                    return PorterDuffFunctions.MultiplyDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2551,7 +2551,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2559,17 +2559,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_DestOver : PixelBlender<TPixel>
+            internal class AddDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_DestOver Instance { get; } = new Add_DestOver();
+                public static AddDestOver Instance { get; } = new AddDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_DestOver(background, source, amount);
+                    return PorterDuffFunctions.AddDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2590,7 +2590,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2598,17 +2598,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_DestOver : PixelBlender<TPixel>
+            internal class SubtractDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_DestOver Instance { get; } = new Subtract_DestOver();
+                public static SubtractDestOver Instance { get; } = new SubtractDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_DestOver(background, source, amount);
+                    return PorterDuffFunctions.SubtractDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2629,7 +2629,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2637,17 +2637,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_DestOver : PixelBlender<TPixel>
+            internal class ScreenDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_DestOver Instance { get; } = new Screen_DestOver();
+                public static ScreenDestOver Instance { get; } = new ScreenDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_DestOver(background, source, amount);
+                    return PorterDuffFunctions.ScreenDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2668,7 +2668,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2676,17 +2676,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_DestOver : PixelBlender<TPixel>
+            internal class DarkenDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_DestOver Instance { get; } = new Darken_DestOver();
+                public static DarkenDestOver Instance { get; } = new DarkenDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_DestOver(background, source, amount);
+                    return PorterDuffFunctions.DarkenDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2707,7 +2707,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2715,17 +2715,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_DestOver : PixelBlender<TPixel>
+            internal class LightenDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_DestOver Instance { get; } = new Lighten_DestOver();
+                public static LightenDestOver Instance { get; } = new LightenDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_DestOver(background, source, amount);
+                    return PorterDuffFunctions.LightenDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2746,7 +2746,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2754,17 +2754,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_DestOver : PixelBlender<TPixel>
+            internal class OverlayDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_DestOver Instance { get; } = new Overlay_DestOver();
+                public static OverlayDestOver Instance { get; } = new OverlayDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_DestOver(background, source, amount);
+                    return PorterDuffFunctions.OverlayDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2785,7 +2785,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlayDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2793,17 +2793,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_DestOver : PixelBlender<TPixel>
+            internal class HardLightDestOver : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_DestOver Instance { get; } = new HardLight_DestOver();
+                public static HardLightDestOver Instance { get; } = new HardLightDestOver();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_DestOver(background, source, amount);
+                    return PorterDuffFunctions.HardLightDestOver(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2824,7 +2824,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_DestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2832,17 +2832,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_DestIn : PixelBlender<TPixel>
+            internal class NormalDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_DestIn Instance { get; } = new Normal_DestIn();
+                public static NormalDestIn Instance { get; } = new NormalDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_DestIn(background, source, amount);
+                    return PorterDuffFunctions.NormalDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2863,7 +2863,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2871,17 +2871,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_DestIn : PixelBlender<TPixel>
+            internal class MultiplyDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_DestIn Instance { get; } = new Multiply_DestIn();
+                public static MultiplyDestIn Instance { get; } = new MultiplyDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_DestIn(background, source, amount);
+                    return PorterDuffFunctions.MultiplyDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2902,7 +2902,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2910,17 +2910,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_DestIn : PixelBlender<TPixel>
+            internal class AddDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_DestIn Instance { get; } = new Add_DestIn();
+                public static AddDestIn Instance { get; } = new AddDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_DestIn(background, source, amount);
+                    return PorterDuffFunctions.AddDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2941,7 +2941,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2949,17 +2949,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_DestIn : PixelBlender<TPixel>
+            internal class SubtractDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_DestIn Instance { get; } = new Subtract_DestIn();
+                public static SubtractDestIn Instance { get; } = new SubtractDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_DestIn(background, source, amount);
+                    return PorterDuffFunctions.SubtractDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -2980,7 +2980,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -2988,17 +2988,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_DestIn : PixelBlender<TPixel>
+            internal class ScreenDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_DestIn Instance { get; } = new Screen_DestIn();
+                public static ScreenDestIn Instance { get; } = new ScreenDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_DestIn(background, source, amount);
+                    return PorterDuffFunctions.ScreenDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3019,7 +3019,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3027,17 +3027,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_DestIn : PixelBlender<TPixel>
+            internal class DarkenDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_DestIn Instance { get; } = new Darken_DestIn();
+                public static DarkenDestIn Instance { get; } = new DarkenDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_DestIn(background, source, amount);
+                    return PorterDuffFunctions.DarkenDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3058,7 +3058,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3066,17 +3066,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_DestIn : PixelBlender<TPixel>
+            internal class LightenDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_DestIn Instance { get; } = new Lighten_DestIn();
+                public static LightenDestIn Instance { get; } = new LightenDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_DestIn(background, source, amount);
+                    return PorterDuffFunctions.LightenDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3097,7 +3097,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3105,17 +3105,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_DestIn : PixelBlender<TPixel>
+            internal class OverlayDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_DestIn Instance { get; } = new Overlay_DestIn();
+                public static OverlayDestIn Instance { get; } = new OverlayDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_DestIn(background, source, amount);
+                    return PorterDuffFunctions.OverlayDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3136,7 +3136,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlayDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3144,17 +3144,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_DestIn : PixelBlender<TPixel>
+            internal class HardLightDestIn : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_DestIn Instance { get; } = new HardLight_DestIn();
+                public static HardLightDestIn Instance { get; } = new HardLightDestIn();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_DestIn(background, source, amount);
+                    return PorterDuffFunctions.HardLightDestIn(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3175,7 +3175,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_DestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3183,17 +3183,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_DestOut : PixelBlender<TPixel>
+            internal class NormalDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_DestOut Instance { get; } = new Normal_DestOut();
+                public static NormalDestOut Instance { get; } = new NormalDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_DestOut(background, source, amount);
+                    return PorterDuffFunctions.NormalDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3214,7 +3214,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3222,17 +3222,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_DestOut : PixelBlender<TPixel>
+            internal class MultiplyDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_DestOut Instance { get; } = new Multiply_DestOut();
+                public static MultiplyDestOut Instance { get; } = new MultiplyDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_DestOut(background, source, amount);
+                    return PorterDuffFunctions.MultiplyDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3253,7 +3253,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3261,17 +3261,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_DestOut : PixelBlender<TPixel>
+            internal class AddDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_DestOut Instance { get; } = new Add_DestOut();
+                public static AddDestOut Instance { get; } = new AddDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_DestOut(background, source, amount);
+                    return PorterDuffFunctions.AddDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3292,7 +3292,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3300,17 +3300,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_DestOut : PixelBlender<TPixel>
+            internal class SubtractDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_DestOut Instance { get; } = new Subtract_DestOut();
+                public static SubtractDestOut Instance { get; } = new SubtractDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_DestOut(background, source, amount);
+                    return PorterDuffFunctions.SubtractDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3331,7 +3331,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3339,17 +3339,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_DestOut : PixelBlender<TPixel>
+            internal class ScreenDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_DestOut Instance { get; } = new Screen_DestOut();
+                public static ScreenDestOut Instance { get; } = new ScreenDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_DestOut(background, source, amount);
+                    return PorterDuffFunctions.ScreenDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3370,7 +3370,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3378,17 +3378,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_DestOut : PixelBlender<TPixel>
+            internal class DarkenDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_DestOut Instance { get; } = new Darken_DestOut();
+                public static DarkenDestOut Instance { get; } = new DarkenDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_DestOut(background, source, amount);
+                    return PorterDuffFunctions.DarkenDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3409,7 +3409,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3417,17 +3417,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_DestOut : PixelBlender<TPixel>
+            internal class LightenDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_DestOut Instance { get; } = new Lighten_DestOut();
+                public static LightenDestOut Instance { get; } = new LightenDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_DestOut(background, source, amount);
+                    return PorterDuffFunctions.LightenDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3448,7 +3448,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3456,17 +3456,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_DestOut : PixelBlender<TPixel>
+            internal class OverlayDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_DestOut Instance { get; } = new Overlay_DestOut();
+                public static OverlayDestOut Instance { get; } = new OverlayDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_DestOut(background, source, amount);
+                    return PorterDuffFunctions.OverlayDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3487,7 +3487,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlayDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3495,17 +3495,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_DestOut : PixelBlender<TPixel>
+            internal class HardLightDestOut : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_DestOut Instance { get; } = new HardLight_DestOut();
+                public static HardLightDestOut Instance { get; } = new HardLightDestOut();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_DestOut(background, source, amount);
+                    return PorterDuffFunctions.HardLightDestOut(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3526,7 +3526,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_DestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3534,17 +3534,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_Clear : PixelBlender<TPixel>
+            internal class NormalClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_Clear Instance { get; } = new Normal_Clear();
+                public static NormalClear Instance { get; } = new NormalClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_Clear(background, source, amount);
+                    return PorterDuffFunctions.NormalClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3565,7 +3565,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3573,17 +3573,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_Clear : PixelBlender<TPixel>
+            internal class MultiplyClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_Clear Instance { get; } = new Multiply_Clear();
+                public static MultiplyClear Instance { get; } = new MultiplyClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_Clear(background, source, amount);
+                    return PorterDuffFunctions.MultiplyClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3604,7 +3604,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplyClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3612,17 +3612,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_Clear : PixelBlender<TPixel>
+            internal class AddClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_Clear Instance { get; } = new Add_Clear();
+                public static AddClear Instance { get; } = new AddClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_Clear(background, source, amount);
+                    return PorterDuffFunctions.AddClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3643,7 +3643,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3651,17 +3651,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_Clear : PixelBlender<TPixel>
+            internal class SubtractClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_Clear Instance { get; } = new Subtract_Clear();
+                public static SubtractClear Instance { get; } = new SubtractClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_Clear(background, source, amount);
+                    return PorterDuffFunctions.SubtractClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3682,7 +3682,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3690,17 +3690,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_Clear : PixelBlender<TPixel>
+            internal class ScreenClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_Clear Instance { get; } = new Screen_Clear();
+                public static ScreenClear Instance { get; } = new ScreenClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_Clear(background, source, amount);
+                    return PorterDuffFunctions.ScreenClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3721,7 +3721,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3729,17 +3729,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_Clear : PixelBlender<TPixel>
+            internal class DarkenClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_Clear Instance { get; } = new Darken_Clear();
+                public static DarkenClear Instance { get; } = new DarkenClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_Clear(background, source, amount);
+                    return PorterDuffFunctions.DarkenClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3760,7 +3760,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3768,17 +3768,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_Clear : PixelBlender<TPixel>
+            internal class LightenClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_Clear Instance { get; } = new Lighten_Clear();
+                public static LightenClear Instance { get; } = new LightenClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_Clear(background, source, amount);
+                    return PorterDuffFunctions.LightenClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3799,7 +3799,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3807,17 +3807,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_Clear : PixelBlender<TPixel>
+            internal class OverlayClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_Clear Instance { get; } = new Overlay_Clear();
+                public static OverlayClear Instance { get; } = new OverlayClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_Clear(background, source, amount);
+                    return PorterDuffFunctions.OverlayClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3838,7 +3838,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlayClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3846,17 +3846,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_Clear : PixelBlender<TPixel>
+            internal class HardLightClear : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_Clear Instance { get; } = new HardLight_Clear();
+                public static HardLightClear Instance { get; } = new HardLightClear();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_Clear(background, source, amount);
+                    return PorterDuffFunctions.HardLightClear(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3877,7 +3877,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_Clear(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightClear(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3885,17 +3885,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Normal_Xor : PixelBlender<TPixel>
+            internal class NormalXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Normal_Xor Instance { get; } = new Normal_Xor();
+                public static NormalXor Instance { get; } = new NormalXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Normal_Xor(background, source, amount);
+                    return PorterDuffFunctions.NormalXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3916,7 +3916,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Normal_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.NormalXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3924,17 +3924,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Multiply_Xor : PixelBlender<TPixel>
+            internal class MultiplyXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Multiply_Xor Instance { get; } = new Multiply_Xor();
+                public static MultiplyXor Instance { get; } = new MultiplyXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Multiply_Xor(background, source, amount);
+                    return PorterDuffFunctions.MultiplyXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3955,7 +3955,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Multiply_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.MultiplyXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -3963,17 +3963,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Add_Xor : PixelBlender<TPixel>
+            internal class AddXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Add_Xor Instance { get; } = new Add_Xor();
+                public static AddXor Instance { get; } = new AddXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Add_Xor(background, source, amount);
+                    return PorterDuffFunctions.AddXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -3994,7 +3994,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Add_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.AddXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -4002,17 +4002,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Subtract_Xor : PixelBlender<TPixel>
+            internal class SubtractXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Subtract_Xor Instance { get; } = new Subtract_Xor();
+                public static SubtractXor Instance { get; } = new SubtractXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Subtract_Xor(background, source, amount);
+                    return PorterDuffFunctions.SubtractXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -4033,7 +4033,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Subtract_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.SubtractXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -4041,17 +4041,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Screen_Xor : PixelBlender<TPixel>
+            internal class ScreenXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Screen_Xor Instance { get; } = new Screen_Xor();
+                public static ScreenXor Instance { get; } = new ScreenXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Screen_Xor(background, source, amount);
+                    return PorterDuffFunctions.ScreenXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -4072,7 +4072,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Screen_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.ScreenXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -4080,17 +4080,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Darken_Xor : PixelBlender<TPixel>
+            internal class DarkenXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Darken_Xor Instance { get; } = new Darken_Xor();
+                public static DarkenXor Instance { get; } = new DarkenXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Darken_Xor(background, source, amount);
+                    return PorterDuffFunctions.DarkenXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -4111,7 +4111,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Darken_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.DarkenXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -4119,17 +4119,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Lighten_Xor : PixelBlender<TPixel>
+            internal class LightenXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Lighten_Xor Instance { get; } = new Lighten_Xor();
+                public static LightenXor Instance { get; } = new LightenXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Lighten_Xor(background, source, amount);
+                    return PorterDuffFunctions.LightenXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -4150,7 +4150,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Lighten_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.LightenXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -4158,17 +4158,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class Overlay_Xor : PixelBlender<TPixel>
+            internal class OverlayXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static Overlay_Xor Instance { get; } = new Overlay_Xor();
+                public static OverlayXor Instance { get; } = new OverlayXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.Overlay_Xor(background, source, amount);
+                    return PorterDuffFunctions.OverlayXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -4189,7 +4189,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.Overlay_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.OverlayXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -4197,17 +4197,17 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 }
             }
 
-            internal class HardLight_Xor : PixelBlender<TPixel>
+            internal class HardLightXor : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static HardLight_Xor Instance { get; } = new HardLight_Xor();
+                public static HardLightXor Instance { get; } = new HardLightXor();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.HardLight_Xor(background, source, amount);
+                    return PorterDuffFunctions.HardLightXor(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -4228,7 +4228,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.HardLight_Xor(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.HardLightXor(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
index e60d8ca90..34fe4d4cd 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
@@ -36,51 +36,49 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
 <#
     string[] composers = new []{         
-        "Src"      ,
-        "SrcAtop"     ,
-        "SrcOver"     ,
-        "SrcIn"       ,
-        "SrcOut"      ,
-        "Dest"     ,
-        "DestAtop" ,
-        "DestOver" ,
-        "DestIn"   ,
-        "DestOut"  ,
-        "Clear"    ,
-        "Xor"      ,
+        "Src",
+        "SrcAtop",
+        "SrcOver",
+        "SrcIn",
+        "SrcOut",
+        "Dest",
+        "DestAtop",
+        "DestOver",
+        "DestIn",
+        "DestOut",
+        "Clear",
+        "Xor",
     };
 
     string[] blenders = new []{         
-        "Normal"      ,
-        "Multiply"     ,
-        "Add"     ,
-        "Subtract"       ,
-        "Screen"      ,
-        "Darken"     ,
-        "Lighten" ,
-        "Overlay" ,
+        "Normal",
+        "Multiply",
+        "Add",
+        "Subtract",
+        "Screen",
+        "Darken",
+        "Lighten",
+        "Overlay",
         "HardLight"
     };
 
- 
-
         foreach(var composer in composers) {
         foreach(var blender in blenders) {
 
-            string blender_composer= $"{blender}_{composer}";
+            string blender_composer= $"{blender}{composer}";
 
 #>
-            internal class <#=                blender_composer#> : PixelBlender<TPixel>
+            internal class <#= blender_composer#> : PixelBlender<TPixel>
             {
                 /// <summary>
                 /// Gets the static instance of this blender.
                 /// </summary>
-                public static <#=                blender_composer#> Instance { get; } = new <#=                blender_composer#>();
+                public static <#=blender_composer#> Instance { get; } = new <#=blender_composer#>();
 
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.<#=                blender_composer#>(background, source, amount);
+                    return PorterDuffFunctions.<#=blender_composer#>(background, source, amount);
                 }
 
                 /// <inheritdoc />
@@ -101,7 +99,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
                         for (int i = 0; i < destination.Length; i++)
                         {
-                            destinationSpan[i] = PorterDuffFunctions.<#=                blender_composer#>(backgroundSpan[i], sourceSpan[i], amount[i]);
+                            destinationSpan[i] = PorterDuffFunctions.<#=blender_composer#>(backgroundSpan[i], sourceSpan[i], amount[i]);
                         }
 
                         PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
index b8c3faf4f..4b0ffdd48 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
@@ -15,10 +15,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
 
 
-        #region Blenders
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -27,7 +26,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -36,7 +35,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -45,7 +44,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -54,7 +53,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -63,13 +62,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -78,7 +77,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -87,7 +86,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -96,7 +95,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -105,7 +104,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -114,7 +113,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Normal_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 NormalClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -124,138 +123,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Normal_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel NormalXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Normal_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(NormalXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplySrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -264,7 +263,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -273,7 +272,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplySrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -282,7 +281,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplySrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -291,7 +290,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplySrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -300,13 +299,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplyDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplyDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -315,7 +314,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplyDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -324,7 +323,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplyDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -333,7 +332,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplyDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -342,7 +341,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplyXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -351,7 +350,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Multiply_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 MultiplyClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -361,138 +360,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplySrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplySrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplySrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplySrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplySrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplySrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplySrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplySrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplySrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplySrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplyDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplyDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplyDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplyDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplyDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplyDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplyDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplyDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplyDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplyDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplyClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplyClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Multiply_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel MultiplyXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Multiply_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(MultiplyXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -501,7 +500,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -510,7 +509,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -519,7 +518,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -528,7 +527,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -537,13 +536,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -552,7 +551,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -561,7 +560,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -570,7 +569,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -579,7 +578,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -588,7 +587,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Add_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 AddClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -598,138 +597,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Add_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel AddXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Add_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(AddXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -738,7 +737,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -747,7 +746,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -756,7 +755,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -765,7 +764,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -774,13 +773,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -789,7 +788,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -798,7 +797,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -807,7 +806,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -816,7 +815,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -825,7 +824,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Subtract_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 SubtractClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -835,138 +834,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Subtract_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel SubtractXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Subtract_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(SubtractXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -975,7 +974,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -984,7 +983,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -993,7 +992,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1002,7 +1001,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1011,13 +1010,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1026,7 +1025,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1035,7 +1034,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1044,7 +1043,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1053,7 +1052,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1062,7 +1061,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Screen_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 ScreenClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1072,138 +1071,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Screen_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel ScreenXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Screen_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(ScreenXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1212,7 +1211,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1221,7 +1220,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1230,7 +1229,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1239,7 +1238,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1248,13 +1247,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1263,7 +1262,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1272,7 +1271,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1281,7 +1280,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1290,7 +1289,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1299,7 +1298,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Darken_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 DarkenClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1309,138 +1308,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Darken_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel DarkenXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Darken_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(DarkenXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1449,7 +1448,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1458,7 +1457,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1467,7 +1466,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1476,7 +1475,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1485,13 +1484,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1500,7 +1499,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1509,7 +1508,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1518,7 +1517,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1527,7 +1526,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1536,7 +1535,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Lighten_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 LightenClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1546,138 +1545,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Lighten_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel LightenXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Lighten_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(LightenXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlaySrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1686,7 +1685,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlaySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1695,7 +1694,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlaySrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1704,7 +1703,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlaySrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1713,7 +1712,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlaySrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1722,13 +1721,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlayDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlayDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1737,7 +1736,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlayDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1746,7 +1745,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlayDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1755,7 +1754,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlayDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1764,7 +1763,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlayXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1773,7 +1772,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Overlay_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 OverlayClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1783,138 +1782,138 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlaySrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlaySrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlaySrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlaySrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlaySrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlaySrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlaySrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlaySrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlaySrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlaySrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlayDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlayDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlayDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlayDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlayDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlayDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlayDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlayDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlayDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlayDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlayClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlayClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel Overlay_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel OverlayXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(Overlay_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(OverlayXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1923,7 +1922,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1932,7 +1931,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1941,7 +1940,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1950,7 +1949,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1959,13 +1958,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1974,7 +1973,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1983,7 +1982,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -1992,7 +1991,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -2001,7 +2000,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightXor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -2010,7 +2009,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 HardLight_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 HardLightClear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -2020,136 +2019,134 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_Src<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_Src(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_SrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_SrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_SrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_SrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_SrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_SrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_SrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_SrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_Dest<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_Dest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightDest(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_DestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_DestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_DestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_DestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_DestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_DestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_DestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_DestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_Clear<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_Clear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightClear(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
         
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel HardLight_Xor<TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel HardLightXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(HardLight_Xor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(HardLightXor(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
-
-        #endregion
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
index 3045b1e81..5e46a89a8 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
@@ -25,7 +25,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 <# void GeneratePixelBlenders(string blender) { #>
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_Src(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>Src(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -43,7 +43,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_SrcOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>SrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_SrcIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>SrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -61,7 +61,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_SrcOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>SrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -70,13 +70,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_Dest(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>Dest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_DestAtop(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>DestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -85,7 +85,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_DestOver(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>DestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -94,7 +94,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_DestIn(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>DestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -103,7 +103,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_DestOut(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>DestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -112,7 +112,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_Xor(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>Xor(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -121,7 +121,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_Clear(Vector4 backdrop, Vector4 source, float opacity)
+        public static Vector4 <#=blender#>Clear(Vector4 backdrop, Vector4 source, float opacity)
         {
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
@@ -134,43 +134,42 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 <# void GenerateGenericPixelBlender(string blender, string composer) { #>        
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static TPixel <#=blender#>_<#=composer#><TPixel>(TPixel backdrop, TPixel source, float opacity)
+        public static TPixel <#=blender#><#=composer#><TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel dest = default;
-            dest.PackFromVector4(<#=blender#>_<#=composer#>(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromVector4(<#=blender#><#=composer#>(backdrop.ToVector4(),source.ToVector4(),opacity));
             return dest;
         }
 
 <# } #>
 
-        #region Blenders
 <#
 
 string[] composers = new []{         
-    "Src"      ,
-    "SrcAtop"     ,
-    "SrcOver"     ,
-    "SrcIn"       ,
-    "SrcOut"      ,
-    "Dest"     ,
-    "DestAtop" ,
-    "DestOver" ,
-    "DestIn"   ,
-    "DestOut"  ,
-    "Clear"    ,
-    "Xor"      ,
+    "Src",
+    "SrcAtop",
+    "SrcOver",
+    "SrcIn",
+    "SrcOut",
+    "Dest",
+    "DestAtop",
+    "DestOver",
+    "DestIn",
+    "DestOut",
+    "Clear",
+    "Xor",
 };
 
 string[] blenders = new []{         
-    "Normal"      ,
-    "Multiply"     ,
-    "Add"     ,
-    "Subtract"       ,
-    "Screen"      ,
-    "Darken"     ,
-    "Lighten" ,
-    "Overlay" ,
+    "Normal",
+    "Multiply",
+    "Add",
+    "Subtract",
+    "Screen",
+    "Darken",
+    "Lighten",
+    "Overlay",
     "HardLight"
 }; 
 
@@ -185,7 +184,5 @@ string[] blenders = new []{
     }
 
 #>
-
-        #endregion
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
index c84cd9a7b..e10c8fe91 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
@@ -156,7 +156,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         /// <param name="xform">Desired transformed color, without taking Alpha channel in account</param>
         /// <returns>The final color</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector4 SrcOver_Reference(Vector4 backdrop, Vector4 source, Vector4 xform)
+        private static Vector4 SrcOverReference(Vector4 backdrop, Vector4 source, Vector4 xform)
         {
             // calculate weights
             float xw = backdrop.W * source.W;
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs
index ad9366bc5..ca6a28192 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.PixelBenders.cs
@@ -20,30 +20,30 @@ namespace SixLabors.ImageSharp.PixelFormats
         {
             switch (mode)
             {
-                case PixelBlenderMode.Multiply: return DefaultPixelBlenders<TPixel>.Multiply_SrcOver.Instance;
-                case PixelBlenderMode.Add: return DefaultPixelBlenders<TPixel>.Add_SrcOver.Instance;
-                case PixelBlenderMode.Subtract: return DefaultPixelBlenders<TPixel>.Subtract_SrcOver.Instance;
-                case PixelBlenderMode.Screen: return DefaultPixelBlenders<TPixel>.Screen_SrcOver.Instance;
-                case PixelBlenderMode.Darken: return DefaultPixelBlenders<TPixel>.Darken_SrcOver.Instance;
-                case PixelBlenderMode.Lighten: return DefaultPixelBlenders<TPixel>.Lighten_SrcOver.Instance;
-                case PixelBlenderMode.Overlay: return DefaultPixelBlenders<TPixel>.Overlay_SrcOver.Instance;
-                case PixelBlenderMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLight_SrcOver.Instance;
-                case PixelBlenderMode.Src: return DefaultPixelBlenders<TPixel>.Normal_Src.Instance;
-                case PixelBlenderMode.Atop: return DefaultPixelBlenders<TPixel>.Normal_SrcAtop.Instance;
-                case PixelBlenderMode.Over: return DefaultPixelBlenders<TPixel>.Normal_SrcOver.Instance;
-                case PixelBlenderMode.In: return DefaultPixelBlenders<TPixel>.Normal_SrcIn.Instance;
-                case PixelBlenderMode.Out: return DefaultPixelBlenders<TPixel>.Normal_SrcOut.Instance;
-                case PixelBlenderMode.Dest: return DefaultPixelBlenders<TPixel>.Normal_Dest.Instance;
-                case PixelBlenderMode.DestAtop: return DefaultPixelBlenders<TPixel>.Normal_DestAtop.Instance;
-                case PixelBlenderMode.DestOver: return DefaultPixelBlenders<TPixel>.Normal_DestOver.Instance;
-                case PixelBlenderMode.DestIn: return DefaultPixelBlenders<TPixel>.Normal_DestIn.Instance;
-                case PixelBlenderMode.DestOut: return DefaultPixelBlenders<TPixel>.Normal_DestOut.Instance;
-                case PixelBlenderMode.Clear: return DefaultPixelBlenders<TPixel>.Normal_Clear.Instance;
-                case PixelBlenderMode.Xor: return DefaultPixelBlenders<TPixel>.Normal_Xor.Instance;
+                case PixelBlenderMode.Multiply: return DefaultPixelBlenders<TPixel>.MultiplySrcOver.Instance;
+                case PixelBlenderMode.Add: return DefaultPixelBlenders<TPixel>.AddSrcOver.Instance;
+                case PixelBlenderMode.Subtract: return DefaultPixelBlenders<TPixel>.SubtractSrcOver.Instance;
+                case PixelBlenderMode.Screen: return DefaultPixelBlenders<TPixel>.ScreenSrcOver.Instance;
+                case PixelBlenderMode.Darken: return DefaultPixelBlenders<TPixel>.DarkenSrcOver.Instance;
+                case PixelBlenderMode.Lighten: return DefaultPixelBlenders<TPixel>.LightenSrcOver.Instance;
+                case PixelBlenderMode.Overlay: return DefaultPixelBlenders<TPixel>.OverlaySrcOver.Instance;
+                case PixelBlenderMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLightSrcOver.Instance;
+                case PixelBlenderMode.Src: return DefaultPixelBlenders<TPixel>.NormalSrc.Instance;
+                case PixelBlenderMode.Atop: return DefaultPixelBlenders<TPixel>.NormalSrcAtop.Instance;
+                case PixelBlenderMode.Over: return DefaultPixelBlenders<TPixel>.NormalSrcOver.Instance;
+                case PixelBlenderMode.In: return DefaultPixelBlenders<TPixel>.NormalSrcIn.Instance;
+                case PixelBlenderMode.Out: return DefaultPixelBlenders<TPixel>.NormalSrcOut.Instance;
+                case PixelBlenderMode.Dest: return DefaultPixelBlenders<TPixel>.NormalDest.Instance;
+                case PixelBlenderMode.DestAtop: return DefaultPixelBlenders<TPixel>.NormalDestAtop.Instance;
+                case PixelBlenderMode.DestOver: return DefaultPixelBlenders<TPixel>.NormalDestOver.Instance;
+                case PixelBlenderMode.DestIn: return DefaultPixelBlenders<TPixel>.NormalDestIn.Instance;
+                case PixelBlenderMode.DestOut: return DefaultPixelBlenders<TPixel>.NormalDestOut.Instance;
+                case PixelBlenderMode.Clear: return DefaultPixelBlenders<TPixel>.NormalClear.Instance;
+                case PixelBlenderMode.Xor: return DefaultPixelBlenders<TPixel>.NormalXor.Instance;
 
                 case PixelBlenderMode.Normal:
                 default:
-                    return DefaultPixelBlenders<TPixel>.Normal_SrcOver.Instance;
+                    return DefaultPixelBlenders<TPixel>.NormalSrcOver.Instance;
             }
         }
     }
diff --git a/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs b/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs
index a70d9fc11..3133e0b36 100644
--- a/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs
+++ b/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs
@@ -37,7 +37,7 @@ namespace SixLabors.ImageSharp.Benchmarks
 
                 for (int i = 0; i < destination.Length; i++)
                 {
-                    destinationSpan[i] = PorterDuffFunctions.Normal_SrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
+                    destinationSpan[i] = PorterDuffFunctions.NormalSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
                 }
 
                 PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
@@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.Benchmarks
 
             for (int i = 0; i < destination.Length; i++)
             {
-                destination[i] = PorterDuffFunctions.Normal_SrcOver(destination[i], source[i], amount[i]);
+                destination[i] = PorterDuffFunctions.NormalSrcOver(destination[i], source[i], amount[i]);
             }
         }
 
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs
index c34bdc56e..9a196d9d5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests.cs
@@ -1,10 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Collections.Generic;
 using System.Numerics;
-using System.Text;
 using SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 using SixLabors.ImageSharp.Tests.TestUtilities;
 using Xunit;
@@ -22,7 +19,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(NormalBlendFunctionData))]
         public void NormalBlendFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Normal_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.NormalSrcOver((Vector4)back, source, amount);
             Assert.Equal(expected, actual);
         }
 
@@ -41,7 +38,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(MultiplyFunctionData))]
         public void MultiplyFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Multiply_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.MultiplySrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
 
@@ -60,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(AddFunctionData))]
         public void AddFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Multiply_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.MultiplySrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
 
@@ -79,7 +76,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(SubstractFunctionData))]
         public void SubstractFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Subtract_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.SubtractSrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
 
@@ -98,7 +95,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(ScreenFunctionData))]
         public void ScreenFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Screen_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.ScreenSrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
 
@@ -117,7 +114,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(DarkenFunctionData))]
         public void DarkenFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Darken_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.DarkenSrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
 
@@ -136,7 +133,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(LightenFunctionData))]
         public void LightenFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Lighten_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.LightenSrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
 
@@ -155,7 +152,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(OverlayFunctionData))]
         public void OverlayFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.Overlay_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.OverlaySrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
 
@@ -174,7 +171,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         [MemberData(nameof(HardLightFunctionData))]
         public void HardLightFunction(TestVector4 back, TestVector4 source, float amount, TestVector4 expected)
         {
-            Vector4 actual = PorterDuffFunctions.HardLight_SrcOver((Vector4)back, source, amount);
+            Vector4 actual = PorterDuffFunctions.HardLightSrcOver((Vector4)back, source, amount);
             VectorAssert.Equal(expected, actual, 5);
         }
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests_TPixel.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests_TPixel.cs
index a53591dbc..3ea9bcad4 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests_TPixel.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTests_TPixel.cs
@@ -2,9 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Collections.Generic;
-using System.Numerics;
-using System.Text;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 using SixLabors.ImageSharp.Tests.TestUtilities;
@@ -14,7 +11,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
 {
     using SixLabors.Memory;
 
-    public class PorterDuffFunctionsTests_TPixel
+    public class PorterDuffFunctionsTestsTPixel
     {
         private static Span<T> AsSpan<T>(T value)
             where T : struct
@@ -34,26 +31,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void NormalBlendFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Normal_SrcOver((TPixel)(TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.NormalSrcOver((TPixel)(TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(NormalBlendFunctionData))]
-        public void NormalBlendFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void NormalBlendFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Normal_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.NormalSrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(NormalBlendFunctionData))]
-        public void NormalBlendFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void NormalBlendFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Normal_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.NormalSrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -73,26 +70,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void MultiplyFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Multiply_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.MultiplySrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(MultiplyFunctionData))]
-        public void MultiplyFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void MultiplyFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Multiply_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.MultiplySrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(MultiplyFunctionData))]
-        public void MultiplyFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void MultiplyFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Multiply_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.MultiplySrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -112,26 +109,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void AddFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Add_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.AddSrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(AddFunctionData))]
-        public void AddFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void AddFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Add_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.AddSrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(AddFunctionData))]
-        public void AddFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void AddFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Add_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.AddSrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -151,26 +148,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void SubstractFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Subtract_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.SubtractSrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(SubstractFunctionData))]
-        public void SubstractFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void SubstractFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Subtract_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.SubtractSrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(SubstractFunctionData))]
-        public void SubstractFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void SubstractFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Subtract_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.SubtractSrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -190,26 +187,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void ScreenFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Screen_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.ScreenSrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(ScreenFunctionData))]
-        public void ScreenFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void ScreenFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Screen_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.ScreenSrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(ScreenFunctionData))]
-        public void ScreenFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void ScreenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Screen_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.ScreenSrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -229,26 +226,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void DarkenFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Darken_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.DarkenSrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(DarkenFunctionData))]
-        public void DarkenFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void DarkenFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Darken_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.DarkenSrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(DarkenFunctionData))]
-        public void DarkenFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void DarkenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Darken_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.DarkenSrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -268,26 +265,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void LightenFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Lighten_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.LightenSrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(LightenFunctionData))]
-        public void LightenFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void LightenFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Lighten_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.LightenSrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(LightenFunctionData))]
-        public void LightenFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void LightenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Lighten_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.LightenSrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -307,26 +304,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void OverlayFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.Overlay_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.OverlaySrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(OverlayFunctionData))]
-        public void OverlayFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void OverlayFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.Overlay_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.OverlaySrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(OverlayFunctionData))]
-        public void OverlayFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void OverlayFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.Overlay_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.OverlaySrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
 
@@ -346,26 +343,26 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders
         public void HardLightFunction<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = PorterDuffFunctions.HardLight_SrcOver((TPixel)back, source, amount);
+            TPixel actual = PorterDuffFunctions.HardLightSrcOver((TPixel)back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(HardLightFunctionData))]
-        public void HardLightFunction_Blender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void HardLightFunctionBlender<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            TPixel actual = new DefaultPixelBlenders<TPixel>.HardLight_SrcOver().Blend(back, source, amount);
+            TPixel actual = new DefaultPixelBlenders<TPixel>.HardLightSrcOver().Blend(back, source, amount);
             VectorAssert.Equal(expected, actual, 2);
         }
 
         [Theory]
         [MemberData(nameof(HardLightFunctionData))]
-        public void HardLightFunction_Blender_Bulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
+        public void HardLightFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
             where TPixel : struct, IPixel<TPixel>
         {
-            Span<TPixel> dest = new Span<TPixel>(new TPixel[1]);
-            new DefaultPixelBlenders<TPixel>.HardLight_SrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
+            var dest = new Span<TPixel>(new TPixel[1]);
+            new DefaultPixelBlenders<TPixel>.HardLightSrcOver().Blend(this.MemoryAllocator, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
             VectorAssert.Equal(expected, dest[0], 2);
         }
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs
index 1a4121c97..3923a5675 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs
@@ -17,50 +17,50 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
 
         public static TheoryData<object, Type, PixelBlenderMode> BlenderMappings = new TheoryData<object, Type, PixelBlenderMode>()
         {
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_SrcOver), PixelBlenderMode.Normal },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Screen_SrcOver), PixelBlenderMode.Screen },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.HardLight_SrcOver), PixelBlenderMode.HardLight },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Overlay_SrcOver), PixelBlenderMode.Overlay },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Darken_SrcOver), PixelBlenderMode.Darken },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Lighten_SrcOver), PixelBlenderMode.Lighten },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Add_SrcOver), PixelBlenderMode.Add },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Subtract_SrcOver), PixelBlenderMode.Subtract },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Multiply_SrcOver), PixelBlenderMode.Multiply },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalSrcOver), PixelBlenderMode.Normal },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.ScreenSrcOver), PixelBlenderMode.Screen },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.HardLightSrcOver), PixelBlenderMode.HardLight },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.OverlaySrcOver), PixelBlenderMode.Overlay },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.DarkenSrcOver), PixelBlenderMode.Darken },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.LightenSrcOver), PixelBlenderMode.Lighten },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.AddSrcOver), PixelBlenderMode.Add },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.SubtractSrcOver), PixelBlenderMode.Subtract },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.MultiplySrcOver), PixelBlenderMode.Multiply },
 
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_Src), PixelBlenderMode.Src },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_SrcAtop), PixelBlenderMode.Atop },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_SrcOver), PixelBlenderMode.Over },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_SrcIn), PixelBlenderMode.In },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_SrcOut), PixelBlenderMode.Out },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_Dest), PixelBlenderMode.Dest },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_DestAtop), PixelBlenderMode.DestAtop },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_DestOver), PixelBlenderMode.DestOver },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_DestIn), PixelBlenderMode.DestIn },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_DestOut), PixelBlenderMode.DestOut },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_Clear), PixelBlenderMode.Clear },
-            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.Normal_Xor), PixelBlenderMode.Xor },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalSrc), PixelBlenderMode.Src },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalSrcAtop), PixelBlenderMode.Atop },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalSrcOver), PixelBlenderMode.Over },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalSrcIn), PixelBlenderMode.In },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalSrcOut), PixelBlenderMode.Out },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalDest), PixelBlenderMode.Dest },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalDestAtop), PixelBlenderMode.DestAtop },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalDestOver), PixelBlenderMode.DestOver },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalDestIn), PixelBlenderMode.DestIn },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalDestOut), PixelBlenderMode.DestOut },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalClear), PixelBlenderMode.Clear },
+            { new TestPixel<Rgba32>(), typeof(DefaultPixelBlenders<Rgba32>.NormalXor), PixelBlenderMode.Xor },
 
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_SrcOver), PixelBlenderMode.Normal },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Screen_SrcOver), PixelBlenderMode.Screen },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.HardLight_SrcOver), PixelBlenderMode.HardLight },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Overlay_SrcOver), PixelBlenderMode.Overlay },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Darken_SrcOver), PixelBlenderMode.Darken },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Lighten_SrcOver), PixelBlenderMode.Lighten },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Add_SrcOver), PixelBlenderMode.Add },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Subtract_SrcOver), PixelBlenderMode.Subtract },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Multiply_SrcOver), PixelBlenderMode.Multiply },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_Src), PixelBlenderMode.Src },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_SrcAtop), PixelBlenderMode.Atop },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_SrcOver), PixelBlenderMode.Over },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_SrcIn), PixelBlenderMode.In },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_SrcOut), PixelBlenderMode.Out },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_Dest), PixelBlenderMode.Dest },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_DestAtop), PixelBlenderMode.DestAtop },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_DestOver), PixelBlenderMode.DestOver },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_DestIn), PixelBlenderMode.DestIn },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_DestOut), PixelBlenderMode.DestOut },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_Clear), PixelBlenderMode.Clear },
-            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.Normal_Xor), PixelBlenderMode.Xor },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalSrcOver), PixelBlenderMode.Normal },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.ScreenSrcOver), PixelBlenderMode.Screen },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.HardLightSrcOver), PixelBlenderMode.HardLight },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.OverlaySrcOver), PixelBlenderMode.Overlay },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.DarkenSrcOver), PixelBlenderMode.Darken },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.LightenSrcOver), PixelBlenderMode.Lighten },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.AddSrcOver), PixelBlenderMode.Add },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.SubtractSrcOver), PixelBlenderMode.Subtract },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.MultiplySrcOver), PixelBlenderMode.Multiply },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalSrc), PixelBlenderMode.Src },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalSrcAtop), PixelBlenderMode.Atop },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalSrcOver), PixelBlenderMode.Over },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalSrcIn), PixelBlenderMode.In },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalSrcOut), PixelBlenderMode.Out },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalDest), PixelBlenderMode.Dest },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalDestAtop), PixelBlenderMode.DestAtop },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalDestOver), PixelBlenderMode.DestOver },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalDestIn), PixelBlenderMode.DestIn },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalDestOut), PixelBlenderMode.DestOut },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalClear), PixelBlenderMode.Clear },
+            { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.NormalXor), PixelBlenderMode.Xor },
 
         };