public void _1DarkBlueRect_2BlendBlackEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
{
using (Image <TPixel> dstImg = provider.GetImage(), srcImg = provider.GetImage())
{
int scaleX = dstImg.Width / 100;
int scaleY = dstImg.Height / 100;
dstImg.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
srcImg.Mutate(
x => x.Fill(
Color.Black,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
dstImg.Mutate(
x => x.DrawImage(srcImg, new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}));
VerifyImage(provider, blending, composition, dstImg);
}
}
#pragma warning disable IDE1006 // Naming Styles
#pragma warning disable SA1300 // Element should begin with upper-case letter
public void _1DarkBlueRect_2BlendHotPinkRect <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
#pragma warning restore SA1300 // Element should begin with upper-case letter
#pragma warning restore IDE1006 // Naming Styles
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY))
.Fill(
new ShapeGraphicsOptions
{
GraphicsOptions =
{
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
Color.HotPink,
new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY)));
VerifyImage(provider, blending, composition, img);
}
}
public void PorterDuffOutputIsCorrect(TestImageProvider <Rgba32> provider, PixelAlphaCompositionMode mode)
{
var srcFile = TestFile.Create(TestImages.Png.PDSrc);
using (Image <Rgba32> src = srcFile.CreateRgba32Image())
using (Image <Rgba32> dest = provider.GetImage())
{
var options = new GraphicsOptions
{
Antialias = false,
AlphaCompositionMode = mode
};
using (Image <Rgba32> res = dest.Clone(x => x.DrawImage(src, options)))
{
string combinedMode = mode.ToString();
if (combinedMode != "Src" && combinedMode.StartsWith("Src"))
{
combinedMode = combinedMode.Substring(3);
}
res.DebugSave(provider, combinedMode);
res.CompareToReferenceOutput(provider, combinedMode);
}
}
}
public void _1DarkBlueRect_2BlendHotPinkRect <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)
)
.Fill(
new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
},
Color.HotPink,
new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY))
);
VerifyImage(provider, blending, composition, img);
}
}
#pragma warning disable IDE1006 // Naming Styles
#pragma warning disable SA1300 // Element should begin with upper-case letter
public void _1DarkBlueRect_2BlendBlackEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
#pragma warning restore SA1300 // Element should begin with upper-case letter
#pragma warning restore IDE1006 // Naming Styles
{
using (Image <TPixel> dstImg = provider.GetImage(), srcImg = provider.GetImage())
{
int scaleX = dstImg.Width / 100;
int scaleY = dstImg.Height / 100;
dstImg.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
srcImg.Mutate(
x => x.Fill(
Color.Black,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
dstImg.Mutate(
x => x.DrawImage(srcImg, new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}));
VerifyImage(provider, blending, composition, dstImg);
}
}
public void _1DarkBlueRect_2BlendBlackEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> dstImg = provider.GetImage(), srcImg = provider.GetImage())
{
int scaleX = (dstImg.Width / 100);
int scaleY = (dstImg.Height / 100);
dstImg.Mutate(
x => x.Fill(
NamedColors <TPixel> .DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
srcImg.Mutate(
x => x.Fill(
NamedColors <TPixel> .Black,
new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
dstImg.Mutate(
x => x.DrawImage(srcImg, new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
})
);
VerifyImage(provider, blending, composition, dstImg);
}
}
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendTransparentEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
NamedColors <TPixel> .DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
NamedColors <TPixel> .HotPink,
new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY)));
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
NamedColors <TPixel> .Transparent,
new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY))
);
VerifyImage(provider, blending, composition, img);
}
}
public void DefaultGraphicsOptionsAlphaCompositionMode()
{
const PixelAlphaCompositionMode Expected = PixelAlphaCompositionMode.SrcOver;
Assert.Equal(Expected, this.newGraphicsOptions.AlphaCompositionMode);
Assert.Equal(Expected, this.cloneGraphicsOptions.AlphaCompositionMode);
}
/// <summary>
/// Draws the given image together with the current one by blending their pixels.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <param name="colorBlending">The color blending mode.</param>
/// <param name="alphaComposition">The alpha composition mode.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
/// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
public static IImageProcessingContext DrawImage(
this IImageProcessingContext source,
Image image,
PixelColorBlendingMode colorBlending,
PixelAlphaCompositionMode alphaComposition,
float opacity) =>
source.ApplyProcessor(new DrawImageProcessor(image, Point.Empty, colorBlending, alphaComposition, opacity));
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsOptions"/> struct.
/// </summary>
/// <param name="enableAntialiasing">If set to <c>true</c> [enable antialiasing].</param>
public GraphicsOptions(bool enableAntialiasing)
{
this.colorBlendingMode = PixelColorBlendingMode.Normal;
this.alphaCompositionMode = PixelAlphaCompositionMode.SrcOver;
this.blendPercentage = 1;
this.antialiasSubpixelDepth = 16;
this.antialias = enableAntialiasing;
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsOptions"/> struct.
/// </summary>
/// <param name="enableAntialiasing">If set to <c>true</c> [enable antialiasing].</param>
/// <param name="opacity">blending percentage to apply to the drawing operation</param>
/// <param name="blending">color blending mode to apply to the drawing operation</param>
/// <param name="composition">alpha composition mode to apply to the drawing operation</param>
public GraphicsOptions(bool enableAntialiasing, PixelColorBlendingMode blending, PixelAlphaCompositionMode composition, float opacity)
{
Guard.MustBeBetweenOrEqualTo(opacity, 0, 1, nameof(opacity));
this.colorBlendingMode = blending;
this.alphaCompositionMode = composition;
this.blendPercentage = opacity;
this.antialiasSubpixelDepth = 16;
this.antialias = enableAntialiasing;
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawImageProcessor"/> class.
/// </summary>
/// <param name="image">The image to blend.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
/// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
/// <param name="opacity">The opacity of the image to blend.</param>
public DrawImageProcessor(
Image image,
Point location,
PixelColorBlendingMode colorBlendingMode,
PixelAlphaCompositionMode alphaCompositionMode,
float opacity)
{
this.Image = image;
this.Location = location;
this.ColorBlendingMode = colorBlendingMode;
this.AlphaCompositionMode = alphaCompositionMode;
this.Opacity = opacity;
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawImageProcessor{TPixelDst, TPixelSrc}"/> class.
/// </summary>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
/// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
public DrawImageProcessor(
Image <TPixelFg> image,
Point location,
PixelColorBlendingMode colorBlendingMode,
PixelAlphaCompositionMode alphaCompositionMode,
float opacity)
{
Guard.MustBeBetweenOrEqualTo(opacity, 0, 1, nameof(opacity));
this.Image = image;
this.Opacity = opacity;
this.Blender = PixelOperations <TPixelBg> .Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
this.Location = location;
}
/// <summary>
/// Initializes a new instance of the <see cref="TextGraphicsOptions" /> struct.
/// </summary>
/// <param name="enableAntialiasing">If set to <c>true</c> [enable antialiasing].</param>
public TextGraphicsOptions(bool enableAntialiasing)
{
this.applyKerning = true;
this.tabWidth = 4;
this.wrapTextWidth = 0;
this.horizontalAlignment = HorizontalAlignment.Left;
this.verticalAlignment = VerticalAlignment.Top;
this.antialiasSubpixelDepth = 16;
this.colorBlendingMode = PixelColorBlendingMode.Normal;
this.alphaCompositionMode = PixelAlphaCompositionMode.SrcOver;
this.blendPercentage = 1;
this.antialias = enableAntialiasing;
this.dpiX = DefaultTextDpi;
this.dpiY = DefaultTextDpi;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SixLabors.ImageSharp.Processing.Processors.Drawing.DrawImageProcessor`2" /> class.
/// </summary>
/// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
/// <param name="image">The foreground <see cref="T:SixLabors.ImageSharp.Image`1" /> to blend with the currently processing image.</param>
/// <param name="source">The source <see cref="T:SixLabors.ImageSharp.Image`1" /> for the current processor instance.</param>
/// <param name="sourceRectangle">The source area to process for the current processor instance.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
/// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
/// <param name="interpolationValue">The interpolation progress. Must be between 0 and 1.</param>
public InterpolateProcessor(Configuration configuration,
SixLabors.ImageSharp.Image <TPixelFg> image,
SixLabors.ImageSharp.Image <TPixelBg> source,
SixLabors.ImageSharp.Rectangle sourceRectangle,
Point location,
PixelColorBlendingMode colorBlendingMode,
PixelAlphaCompositionMode alphaCompositionMode,
float interpolationValue) : base(configuration, source, sourceRectangle)
{
// Guard.MustBeBetweenOrEqualTo(opacity, 0.0f, 1f, nameof(opacity));
this.Image = image;
this.InterpolationValue = interpolationValue;
this.Blender = PixelOperations <TPixelBg> .Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
this.Location = location;
}
#pragma warning disable IDE1006 // Naming Styles
#pragma warning disable SA1300 // Element should begin with upper-case letter
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendSemiTransparentRedEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
#pragma warning restore SA1300 // Element should begin with upper-case letter
#pragma warning restore IDE1006 // Naming Styles
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new DrawingOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
Color.HotPink,
new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY)));
Color transparentRed = Color.Red.WithAlpha(0.5f);
img.Mutate(
x => x.Fill(
new DrawingOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
transparentRed,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
VerifyImage(provider, blending, composition, img);
}
}
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendSemiTransparentRedEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = (img.Width / 100);
int scaleY = (img.Height / 100);
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new ShapeGraphicsOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
Color.HotPink,
new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY)));
Color transparentRed = Color.Red.WithAlpha(0.5f);
img.Mutate(
x => x.Fill(
new ShapeGraphicsOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
transparentRed,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY))
);
VerifyImage(provider, blending, composition, img);;
}
}
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendSemiTransparentRedEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = (img.Width / 100);
int scaleY = (img.Height / 100);
img.Mutate(
x => x.Fill(
NamedColors <TPixel> .DarkBlue,
new Rectangle(0 * scaleX, 40, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
NamedColors <TPixel> .HotPink,
new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY)));
var c = NamedColors <TPixel> .Red.ToVector4();
c.W *= 0.5f;
var pixel = default(TPixel);
pixel.FromVector4(c);
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
pixel,
new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY))
);
VerifyImage(provider, blending, composition, img);;
}
}
private static void VerifyImage <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition,
Image <TPixel> img)
where TPixel : struct, IPixel <TPixel>
{
img.DebugSave(
provider,
new { composition, blending },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
var comparer = ImageComparer.TolerantPercentage(0.01f, 3);
img.CompareFirstFrameToReferenceOutput(comparer,
provider,
new { composition, blending },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
}
/// <summary>
/// Draws the given image together with the current one by blending their pixels.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlending">The color blending to apply.</param>
/// <param name="alphaComposition">The alpha composition mode.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static IImageProcessingContext <TPixel> DrawImage <TPixel>(this IImageProcessingContext <TPixel> source, Image <TPixel> image, Point location, PixelColorBlendingMode colorBlending, PixelAlphaCompositionMode alphaComposition, float opacity)
where TPixel : struct, IPixel <TPixel>
=> source.ApplyProcessor(new DrawImageProcessor <TPixel>(image, location, colorBlending, alphaComposition, opacity));
/// <summary>
/// Draws the given image together with the current one by blending their pixels.
/// </summary>
/// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
/// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <param name="colorBlending">The color blending mode.</param>
/// <param name="alphaComposition">The alpha composition mode.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
/// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
public static IImageProcessingContext <TPixelDst> DrawImage <TPixelDst, TPixelSrc>(this IImageProcessingContext <TPixelDst> source, Image <TPixelSrc> image, PixelColorBlendingMode colorBlending, PixelAlphaCompositionMode alphaComposition, float opacity)
where TPixelDst : struct, IPixel <TPixelDst>
where TPixelSrc : struct, IPixel <TPixelSrc>
=> source.ApplyProcessor(new DrawImageProcessor <TPixelDst, TPixelSrc>(image, Point.Empty, colorBlending, alphaComposition, opacity));
public void TestAlphaCompositionModes(Rgba32 backdrop, Rgba32 source, float opacity, PixelAlphaCompositionMode mode, Rgba32 expectedResult)
{
PixelBlender <Rgba32> blender = PixelOperations <Rgba32> .Instance.GetPixelBlender(PixelColorBlendingMode.Normal, mode);
Rgba32 actualResult = blender.Blend(backdrop, source, opacity);
// var str = actualResult.Rgba.ToString("X8"); // used to extract expectedResults
Assert.Equal(actualResult.ToVector4(), expectedResult.ToVector4());
}
public static IImageProcessingContext <TPixel> SetAlphaMask <TPixel>(this IImageProcessingContext <TPixel> source, Image <Alpha8> mask, PixelAlphaCompositionMode mode) where TPixel : struct, IPixel <TPixel>
{
if (mask == null)
{
return(source);
}
return(source.Apply
(
img =>
{
if (mask.Width == img.Width && mask.Height == img.Height)
{
using (var rmask = mask.CloneAs <TPixel>())
{
img.Mutate(dc => dc.DrawImage(rmask, PixelColorBlendingMode.Normal, mode, 1));
}
}
else
{
using (var rmask = mask.CloneAs <TPixel>())
{
rmask.Mutate(dc => dc.Resize(img.Width, img.Height));
img.Mutate(dc => dc.DrawImage(rmask, PixelColorBlendingMode.Normal, mode, 1));
}
}
}
));
}
/// <summary>
/// Find an instance of the pixel blender.
/// </summary>
/// <param name="colorMode">The color blending mode to apply</param>
/// <param name="alphaMode">The alpha composition mode to apply</param>
/// <returns>A <see cref="PixelBlender{TPixel}"/>.</returns>
public virtual PixelBlender <TPixel> GetPixelBlender(PixelColorBlendingMode colorMode, PixelAlphaCompositionMode alphaMode)
{
switch (alphaMode)
{
case PixelAlphaCompositionMode.Clear:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplyClear.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddClear.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractClear.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenClear.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenClear.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenClear.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlayClear.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightClear.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalClear.Instance);
}
case PixelAlphaCompositionMode.Xor:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplyXor.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddXor.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractXor.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenXor.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenXor.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenXor.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlayXor.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightXor.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalXor.Instance);
}
case PixelAlphaCompositionMode.Src:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplySrc.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddSrc.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractSrc.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenSrc.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenSrc.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenSrc.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlaySrc.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightSrc.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalSrc.Instance);
}
case PixelAlphaCompositionMode.SrcAtop:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplySrcAtop.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddSrcAtop.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractSrcAtop.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenSrcAtop.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenSrcAtop.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenSrcAtop.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlaySrcAtop.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightSrcAtop.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalSrcAtop.Instance);
}
case PixelAlphaCompositionMode.SrcIn:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplySrcIn.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddSrcIn.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractSrcIn.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenSrcIn.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenSrcIn.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenSrcIn.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlaySrcIn.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightSrcIn.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalSrcIn.Instance);
}
case PixelAlphaCompositionMode.SrcOut:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplySrcOut.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddSrcOut.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractSrcOut.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenSrcOut.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenSrcOut.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenSrcOut.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlaySrcOut.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightSrcOut.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalSrcOut.Instance);
}
case PixelAlphaCompositionMode.Dest:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplyDest.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddDest.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractDest.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenDest.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenDest.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenDest.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlayDest.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightDest.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalDest.Instance);
}
case PixelAlphaCompositionMode.DestAtop:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplyDestAtop.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddDestAtop.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractDestAtop.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenDestAtop.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenDestAtop.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenDestAtop.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlayDestAtop.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightDestAtop.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalDestAtop.Instance);
}
case PixelAlphaCompositionMode.DestIn:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplyDestIn.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddDestIn.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractDestIn.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenDestIn.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenDestIn.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenDestIn.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlayDestIn.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightDestIn.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalDestIn.Instance);
}
case PixelAlphaCompositionMode.DestOut:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplyDestOut.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddDestOut.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractDestOut.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenDestOut.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenDestOut.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenDestOut.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlayDestOut.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightDestOut.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalDestOut.Instance);
}
case PixelAlphaCompositionMode.DestOver:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplyDestOver.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddDestOver.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractDestOver.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenDestOver.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenDestOver.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenDestOver.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlayDestOver.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightDestOver.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalDestOver.Instance);
}
case PixelAlphaCompositionMode.SrcOver:
default:
switch (colorMode)
{
case PixelColorBlendingMode.Multiply: return(DefaultPixelBlenders <TPixel> .MultiplySrcOver.Instance);
case PixelColorBlendingMode.Add: return(DefaultPixelBlenders <TPixel> .AddSrcOver.Instance);
case PixelColorBlendingMode.Subtract: return(DefaultPixelBlenders <TPixel> .SubtractSrcOver.Instance);
case PixelColorBlendingMode.Screen: return(DefaultPixelBlenders <TPixel> .ScreenSrcOver.Instance);
case PixelColorBlendingMode.Darken: return(DefaultPixelBlenders <TPixel> .DarkenSrcOver.Instance);
case PixelColorBlendingMode.Lighten: return(DefaultPixelBlenders <TPixel> .LightenSrcOver.Instance);
case PixelColorBlendingMode.Overlay: return(DefaultPixelBlenders <TPixel> .OverlaySrcOver.Instance);
case PixelColorBlendingMode.HardLight: return(DefaultPixelBlenders <TPixel> .HardLightSrcOver.Instance);
case PixelColorBlendingMode.Normal:
default: return(DefaultPixelBlenders <TPixel> .NormalSrcOver.Instance);
}
}
}
