progress on pixel conposer/blender combinations

src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt

@@ -22,36 +22,6 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
     internal static partial class PorterDuffFunctions
     {
 
-
-<# void GenerateVectorCompositor(string name, string sourceVar, string destVar, string blendVar)
-    {
-        int a_s = sourceVar == "Vector4.Zero" ? 0 : 1;
-        int a_b = destVar == "Vector4.Zero" ? 0 : 1;
-        int a_x = blendVar == "Vector4.Zero" ? 0 : 1;
-#>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=name#>(Vector4 backdrop, Vector4 source, Vector4 xform)
-        {
-            // calculate weights
-            float xw = backdrop.W * source.W;
-            float bw = backdrop.W - xw;
-            float sw = source.W - xw;
-
-            // calculate final alpha
-            float fw = (sw * <#=a_s#>) + (bw * <#=a_b#>) + (xw * <#=a_x#>);
-
-            // calculate final value
-            xform = ((<#=blendVar#> * xw) + (<#=destVar#> * bw) + (<#=sourceVar#> * sw)) / MathF.Max(fw, Constants.Epsilon);
-            xform.W = fw;
-
-            return xform;
-        }
-<# } #>
-
-
-
-
-
 <# void GeneratePixelBlenders(string blender) { #>
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -60,7 +30,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return Src(backdrop, source, <#=blender#>(backdrop, source));
+            return source;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -69,7 +39,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return SrcAtop(backdrop, source, <#=blender#>(backdrop, source));
+            return Atop(backdrop, source, <#=blender#>(backdrop, source));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -78,7 +48,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return SrcOver(backdrop, source, <#=blender#>(backdrop, source));
+            return Over(backdrop, source, <#=blender#>(backdrop, source));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -87,7 +57,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return SrcIn(backdrop, source, <#=blender#>(backdrop, source));
+            return In(backdrop, source, <#=blender#>(backdrop, source));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -96,16 +66,13 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return SrcOut(backdrop, source, <#=blender#>(backdrop, source));
+            return Out(backdrop, source);
         }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector4 <#=blender#>_Dest(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
+            return backdrop;
-            source.W *= opacity;          
-
-            return Dest(backdrop, source, <#=blender#>(backdrop, source));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -114,7 +81,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return DestAtop(backdrop, source, <#=blender#>(backdrop, source));
+            return Atop(source, backdrop, <#=blender#>(source, backdrop));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -123,7 +90,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return DestOver(backdrop, source, <#=blender#>(backdrop, source));
+            return Over(source, backdrop, <#=blender#>(source, backdrop));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -132,7 +99,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return DestIn(backdrop, source, <#=blender#>(backdrop, source));
+            return In(source, backdrop, <#=blender#>(source, backdrop));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -141,26 +108,26 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             opacity = opacity.Clamp(0, 1);
             source.W *= opacity;          
 
-            return DestOut(backdrop, source, <#=blender#>(backdrop, source));
+            return Out(source, backdrop);
         }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_Clear(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;          
 
-            return Clear(backdrop, source, source);
+            return Xor(backdrop, source);
         }   
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 <#=blender#>_Xor(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;          
 
-            return Xor(backdrop, source, source);
+            return Clear(backdrop, source);
         }
-
 <# } #>
 
 
@@ -180,19 +147,6 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         #region Blenders
 <#
 
-// GenerateVectorCompositor("Src",      "source",       "Vector4.Zero", "xform");
-GenerateVectorCompositor("SrcAtop",     "Vector4.Zero", "backdrop",     "xform");
-GenerateVectorCompositor("SrcOver",     "source",       "backdrop",     "xform");
-// GenerateVectorCompositor("SrcIn",       "Vector4.Zero", "Vector4.Zero", "xform");
-// GenerateVectorCompositor("SrcOut",      "source",       "Vector4.Zero", "Vector4.Zero");
-GenerateVectorCompositor("Dest",     "Vector4.Zero", "backdrop",     "backdrop");
-// GenerateVectorCompositor("DestAtop", "source",       "Vector4.Zero", "backdrop");
-// GenerateVectorCompositor("DestOver", "source",       "backdrop",     "backdrop");
-// GenerateVectorCompositor("DestIn",   "Vector4.Zero", "Vector4.Zero", "backdrop");
-GenerateVectorCompositor("DestOut",  "Vector4.Zero", "backdrop",     "Vector4.Zero");
-// GenerateVectorCompositor("Clear",    "Vector4.Zero", "Vector4.Zero", "Vector4.Zero");
-GenerateVectorCompositor("Xor", "source", "backdrop", "Vector4.Zero");
-
 string[] composers = new []{         
     "Src"      ,
     "SrcAtop"     ,

src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs

@@ -179,125 +179,78 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             return xform;
         }
 
-
+        public static Vector4 Over(Vector4 dst, Vector4 src, Vector4 blend)
-
-
-
-
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector4 Src(Vector4 backdrop, Vector4 source, Vector4 xform)
         {
             // calculate weights
-            float xw = backdrop.W * source.W;
+            float blendW = dst.W * src.W;
-            float bw = backdrop.W - xw;
+            float dstW = dst.W - blendW;
-            float sw = source.W - xw;
+            float srcW = src.W - blendW;
 
             // calculate final alpha
-            float fw = (sw * 1) + (bw * 0) + (xw * 1);
+            float alpha = dstW + srcW + blendW;
 
-            // calculate final value
+            // calculate final color
-            xform = ((xform * xw) + (Vector4.Zero * bw) + (source * sw)) / MathF.Max(fw, Constants.Epsilon);
+            Vector4 color = dst * dstW + src * srcW + blend * blendW;
-            xform.W = fw;
 
-            return Vector4.Lerp(backdrop, xform, source.W);
+            // unpremultiply
-        }
+            color /= MathF.Max(alpha, Constants.Epsilon);
+            color.W = alpha;
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            return color;
-        public static Vector4 SrcIn(Vector4 backdrop, Vector4 source, Vector4 xform)
-        {
-            // calculate weights
-            float xw = backdrop.W * source.W;
-
-            // calculate final value
-            xform.W = xw;
-
-            return Vector4.Lerp(backdrop, xform, source.W);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector4 Atop(Vector4 dst, Vector4 src, Vector4 blend)
-        public static Vector4 SrcOut(Vector4 backdrop, Vector4 source, Vector4 xform)
         {
             // calculate weights
-            float xw = backdrop.W * source.W;
+            float blendW = dst.W * src.W;
-            float bw = backdrop.W - xw;
+            float dstW = dst.W - blendW;
-            float sw = source.W - xw;
 
             // calculate final alpha
-            float fw = sw;
+            float alpha = dstW + blendW;
 
-            // calculate final value
+            // calculate final color
-            xform = source;
+            Vector4 color = dst * dstW + blend * blendW;
-            xform.W = fw;
 
-            return Vector4.Lerp(backdrop, xform, source.W);
+            // unpremultiply
+            color /= MathF.Max(alpha, Constants.Epsilon);
+            color.W = alpha;
+
+            return color;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector4 In(Vector4 dst, Vector4 src, Vector4 blend)
-        public static Vector4 DestAtop(Vector4 backdrop, Vector4 source, Vector4 xform)
         {
-            // calculate weights
+            blend.W = dst.W * src.W;
-            float xw = backdrop.W * source.W;
-            float bw = backdrop.W - xw;
-            float sw = source.W - xw;
-
-            // calculate final alpha
-            float fw = (sw * 1) + (bw * 0) + (xw * 1);
 
-            // calculate final value
+            return blend;
-            xform = ((backdrop * xw) + (Vector4.Zero * bw) + (source * sw)) / MathF.Max(fw, Constants.Epsilon);
-            xform.W = fw;
-
-            return Vector4.Lerp(backdrop, xform, source.W);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector4 Out(Vector4 dst, Vector4 src)
-        public static Vector4 DestOver(Vector4 backdrop, Vector4 source, Vector4 xform)
         {
-            // calculate weights
-            float xw = backdrop.W * source.W;
-            float bw = backdrop.W - xw;
-            float sw = source.W - xw;
-
             // calculate final alpha
-            float fw = (sw * 1) + (bw * 1) + (xw * 1);
+            src.W = (1 - dst.W) * src.W;
 
-            // calculate final value
+            return src;
-            xform = ((backdrop * xw) + (backdrop * bw) + (source * sw)) / MathF.Max(fw, Constants.Epsilon);
-            xform.W = fw;
-
-            return Vector4.Lerp(backdrop, xform, source.W);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector4 Xor(Vector4 dst, Vector4 src)
-        public static Vector4 DestIn(Vector4 backdrop, Vector4 source, Vector4 xform)
         {
-            // calculate weights
+            float srcW = 1 - dst.W;
-            float xw = backdrop.W * source.W;
+            float dstW = 1 - src.W;
-            float bw = backdrop.W - xw;
-            float sw = source.W - xw;
 
-            // calculate final alpha
+            float alpha = src.W * srcW + dst.W * dstW;
-            float fw = (sw * 0) + (bw * 0) + (xw * 1);
+            Vector4 color = src.W * src * srcW + dst.W * dst * dstW;
 
-            // calculate final value
+            // unpremultiply
-            xform = ((backdrop * xw) + (Vector4.Zero * bw) + (Vector4.Zero * sw)) / MathF.Max(fw, Constants.Epsilon);
+            color /= MathF.Max(alpha, Constants.Epsilon);
-            xform.W = fw;
+            color.W = alpha;
 
-            return Vector4.Lerp(backdrop, xform, source.W);
+            return color;
         }
 
-        /// <summary>
+        private static Vector4 Clear(Vector4 backdrop, Vector4 source)
-        /// General composition function for all modes, with a general solution for alpha channel
-        /// </summary>
-        /// <param name="backdrop">Original Backdrop color</param>
-        /// <param name="source">Original source color</param>
-        /// <param name="xform">Desired transformed color, without taking Alpha channel in account</param>
-        /// <returns>The final color</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector4 Clear(Vector4 backdrop, Vector4 source, Vector4 xform)
         {
-            return Vector4.Lerp(backdrop, Vector4.Zero, xform.W);
+            return Vector4.Lerp(backdrop, Vector4.Zero, source.W);
         }
 
         #endregion

tests/ImageSharp.Tests/Drawing/SolidFillBlendedShapesTests.cs

@@ -116,21 +116,26 @@ namespace SixLabors.ImageSharp.Tests.Drawing
         public void _1DarkBlueRect_2BlendBlackEllipse<TPixel>(TestImageProvider<TPixel> provider, PixelBlenderMode mode)
             where TPixel : struct, IPixel<TPixel>
         {
-            using (Image<TPixel> img = provider.GetImage())
+            using(Image<TPixel> dstImg = provider.GetImage(), srcImg = provider.GetImage())
             {
-                int scaleX = (img.Width / 100);
+                int scaleX = (dstImg.Width / 100);
-                int scaleY = (img.Height / 100);
+                int scaleY = (dstImg.Height / 100);
-                img.Mutate(
+
+                dstImg.Mutate(
                     x => x.Fill(
                         NamedColors<TPixel>.DarkBlue,
                         new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
-                img.Mutate(
+
+                srcImg.Mutate(
                     x => x.Fill(
-                        new GraphicsOptions(true) { BlenderMode = mode },
                         NamedColors<TPixel>.Black,
                         new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
 
-                VerifyImage(provider, mode, img);
+                dstImg.Mutate(
+                    x => x.DrawImage(new GraphicsOptions(true) { BlenderMode = mode }, srcImg)
+                    );                
+
+                VerifyImage(provider, mode, dstImg);
             }
         }