No underscores!

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;
 

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

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

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;

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

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

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

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

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