mirror of https://github.com/SixLabors/ImageSharp
Brian Popow
8 years ago
committed by
GitHub
GitHub
140 changed files with 7251 additions and 1756 deletions
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -1,112 +1,188 @@ |
|||
<# |
|||
// Copyright (c) Six Labors and contributors. |
|||
// Licensed under the Apache License, Version 2.0. |
|||
#> |
|||
<#@ template debug="false" hostspecific="false" language="C#" #> |
|||
<#@ assembly name="System.Core" #> |
|||
<#@ import namespace="System.Linq" #> |
|||
<#@ import namespace="System.Text" #> |
|||
<#@ import namespace="System.Collections.Generic" #> |
|||
<#@ output extension=".cs" #> |
|||
// Copyright (c) Six Labors and contributors. |
|||
// Licensed under the Apache License, Version 2.0. |
|||
|
|||
// <auto-generated /> |
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders |
|||
{ |
|||
internal static partial class PorterDuffFunctions |
|||
{ |
|||
<# |
|||
|
|||
void GeneratePixelBlender (string blender) |
|||
{ |
|||
#> |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static TPixel <#=blender#><TPixel>(TPixel backdrop, TPixel source, float amount) |
|||
where TPixel : struct, IPixel<TPixel> |
|||
{ |
|||
TPixel dest = default; |
|||
dest.PackFromVector4(<#=blender#>(backdrop.ToVector4(), source.ToVector4(), amount)); |
|||
return dest; |
|||
} |
|||
|
|||
<# |
|||
} |
|||
|
|||
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, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
<# if(sourceVar != "Vector4.Zero" ) { #> |
|||
source.W *= opacity; |
|||
<# } #> |
|||
|
|||
// 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 |
|||
Vector4 xform = ((<#=blendVar#> * xw) + (<#=destVar#> * bw) + (<#=sourceVar#> * sw)) / MathF.Max(fw, Constants.Epsilon); |
|||
xform.W = fw; |
|||
|
|||
return Vector4.Lerp(backdrop, xform, opacity); |
|||
} |
|||
|
|||
<# |
|||
} |
|||
GenerateVectorCompositor("Src", "source", "Vector4.Zero", "source"); |
|||
GenerateVectorCompositor("Atop", "Vector4.Zero", "backdrop", "source"); |
|||
GenerateVectorCompositor("Over", "source", "backdrop", "source"); |
|||
GenerateVectorCompositor("In", "Vector4.Zero", "Vector4.Zero", "source"); |
|||
GenerateVectorCompositor("Out", "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"); |
|||
|
|||
|
|||
GeneratePixelBlender("Normal"); |
|||
GeneratePixelBlender("Multiply"); |
|||
GeneratePixelBlender("Add"); |
|||
GeneratePixelBlender("Subtract"); |
|||
GeneratePixelBlender("Screen"); |
|||
GeneratePixelBlender("Darken"); |
|||
GeneratePixelBlender("Lighten"); |
|||
GeneratePixelBlender("Overlay"); |
|||
GeneratePixelBlender("HardLight"); |
|||
|
|||
GeneratePixelBlender("Src"); |
|||
GeneratePixelBlender("Atop"); |
|||
GeneratePixelBlender("Over"); |
|||
GeneratePixelBlender("In"); |
|||
GeneratePixelBlender("Out"); |
|||
GeneratePixelBlender("Dest"); |
|||
GeneratePixelBlender("DestAtop"); |
|||
GeneratePixelBlender("DestOver"); |
|||
GeneratePixelBlender("DestIn"); |
|||
GeneratePixelBlender("DestOut"); |
|||
GeneratePixelBlender("Clear"); |
|||
GeneratePixelBlender("Xor"); |
|||
|
|||
|
|||
#> |
|||
} |
|||
<# |
|||
// Copyright (c) Six Labors and contributors. |
|||
// Licensed under the Apache License, Version 2.0. |
|||
#> |
|||
<#@ template debug="false" hostspecific="false" language="C#" #> |
|||
<#@ assembly name="System.Core" #> |
|||
<#@ import namespace="System.Linq" #> |
|||
<#@ import namespace="System.Text" #> |
|||
<#@ import namespace="System.Collections.Generic" #> |
|||
<#@ output extension=".cs" #> |
|||
// Copyright (c) Six Labors and contributors. |
|||
// Licensed under the Apache License, Version 2.0. |
|||
|
|||
// <auto-generated /> |
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders |
|||
{ |
|||
internal static partial class PorterDuffFunctions |
|||
{ |
|||
|
|||
<# void GeneratePixelBlenders(string blender) { #> |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>Src(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return source; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>SrcAtop(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Atop(backdrop, source, <#=blender#>(backdrop, source)); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>SrcOver(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Over(backdrop, source, <#=blender#>(backdrop, source)); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>SrcIn(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return In(backdrop, source, <#=blender#>(backdrop, source)); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>SrcOut(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Out(backdrop, source); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
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) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Atop(source, backdrop, <#=blender#>(source, backdrop)); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>DestOver(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Over(source, backdrop, <#=blender#>(source, backdrop)); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>DestIn(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return In(source, backdrop, <#=blender#>(source, backdrop)); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>DestOut(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Out(source, backdrop); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>Xor(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Xor(backdrop, source); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 <#=blender#>Clear(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
opacity = opacity.Clamp(0, 1); |
|||
source.W *= opacity; |
|||
|
|||
return Clear(backdrop, source); |
|||
} |
|||
<# } #> |
|||
|
|||
|
|||
<# void GenerateGenericPixelBlender(string blender, string composer) { #> |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
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)); |
|||
return dest; |
|||
} |
|||
|
|||
<# } #> |
|||
|
|||
<# |
|||
|
|||
string[] composers = new []{ |
|||
"Src", |
|||
"SrcAtop", |
|||
"SrcOver", |
|||
"SrcIn", |
|||
"SrcOut", |
|||
"Dest", |
|||
"DestAtop", |
|||
"DestOver", |
|||
"DestIn", |
|||
"DestOut", |
|||
"Clear", |
|||
"Xor", |
|||
}; |
|||
|
|||
string[] blenders = new []{ |
|||
"Normal", |
|||
"Multiply", |
|||
"Add", |
|||
"Subtract", |
|||
"Screen", |
|||
"Darken", |
|||
"Lighten", |
|||
"Overlay", |
|||
"HardLight" |
|||
}; |
|||
|
|||
foreach(var blender in blenders) |
|||
{ |
|||
GeneratePixelBlenders(blender); |
|||
|
|||
foreach(var composer in composers) |
|||
{ |
|||
GenerateGenericPixelBlender(blender,composer); |
|||
} |
|||
} |
|||
|
|||
#> |
|||
} |
|||
} |
|||
@ -1,194 +1,257 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders |
|||
{ |
|||
/// <summary>
|
|||
/// Collection of Porter Duff alpha blending functions applying an the 'Over' composition model.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// These functions are designed to be a general solution for all color cases,
|
|||
/// that is, they take in account the alpha value of both the backdrop
|
|||
/// and source, and there's no need to alpha-premultiply neither the backdrop
|
|||
/// nor the source.
|
|||
/// Note there are faster functions for when the backdrop color is known
|
|||
/// to be opaque
|
|||
/// </remarks>
|
|||
internal static partial class PorterDuffFunctions |
|||
{ |
|||
/// <summary>
|
|||
/// Source over backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Normal(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
return Compose(backdrop, source, source); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Source multiplied by backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Multiply(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
return Compose(backdrop, source, backdrop * source); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Source added to backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Add(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
return Compose(backdrop, source, Vector4.Min(Vector4.One, backdrop + source)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Source subtracted from backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Subtract(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
return Compose(backdrop, source, Vector4.Max(Vector4.Zero, backdrop - source)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Complement of source multiplied by the complement of backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Screen(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
return Compose(backdrop, source, Vector4.One - ((Vector4.One - backdrop) * (Vector4.One - source))); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Per element, chooses the smallest value of source and backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Darken(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
return Compose(backdrop, source, Vector4.Min(backdrop, source)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Per element, chooses the largest value of source and backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Lighten(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
return Compose(backdrop, source, Vector4.Max(backdrop, source)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Overlays source over backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Overlay(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
float cr = OverlayValueFunction(backdrop.X, source.X); |
|||
float cg = OverlayValueFunction(backdrop.Y, source.Y); |
|||
float cb = OverlayValueFunction(backdrop.Z, source.Z); |
|||
|
|||
return Compose(backdrop, source, Vector4.Min(Vector4.One, new Vector4(cr, cg, cb, 0))); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Hard light effect
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <param name="opacity">Opacity applied to Source Alpha</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 HardLight(Vector4 backdrop, Vector4 source, float opacity) |
|||
{ |
|||
source.W *= opacity; |
|||
float cr = OverlayValueFunction(source.X, backdrop.X); |
|||
float cg = OverlayValueFunction(source.Y, backdrop.Y); |
|||
float cb = OverlayValueFunction(source.Z, backdrop.Z); |
|||
|
|||
return Compose(backdrop, source, Vector4.Min(Vector4.One, new Vector4(cr, cg, cb, 0))); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Helper function for Overlay andHardLight modes
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color element</param>
|
|||
/// <param name="source">Source color element</param>
|
|||
/// <returns>Overlay value</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
private static float OverlayValueFunction(float backdrop, float source) |
|||
{ |
|||
return backdrop <= 0.5f ? (2 * backdrop * source) : 1 - ((2 * (1 - source)) * (1 - backdrop)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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 Compose(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 a = xw + bw + sw; |
|||
|
|||
// calculate final value
|
|||
xform = ((xform * xw) + (backdrop * bw) + (source * sw)) / MathF.Max(a, Constants.Epsilon); |
|||
xform.W = a; |
|||
|
|||
return xform; |
|||
} |
|||
} |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders |
|||
{ |
|||
/// <summary>
|
|||
/// Collection of Porter Duff alpha blending functions applying an the 'Over' composition model.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// These functions are designed to be a general solution for all color cases,
|
|||
/// that is, they take in account the alpha value of both the backdrop
|
|||
/// and source, and there's no need to alpha-premultiply neither the backdrop
|
|||
/// nor the source.
|
|||
/// Note there are faster functions for when the backdrop color is known
|
|||
/// to be opaque
|
|||
/// </remarks>
|
|||
internal static partial class PorterDuffFunctions |
|||
{ |
|||
/// <summary>
|
|||
/// Source over backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Normal(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return source; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Source multiplied by backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Multiply(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return backdrop * source; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Source added to backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Add(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return Vector4.Min(Vector4.One, backdrop + source); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Source subtracted from backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Subtract(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return Vector4.Max(Vector4.Zero, backdrop - source); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Complement of source multiplied by the complement of backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Screen(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return Vector4.One - ((Vector4.One - backdrop) * (Vector4.One - source)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Per element, chooses the smallest value of source and backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Darken(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return Vector4.Min(backdrop, source); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Per element, chooses the largest value of source and backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Lighten(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return Vector4.Max(backdrop, source); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Overlays source over backdrop
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 Overlay(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
float cr = OverlayValueFunction(backdrop.X, source.X); |
|||
float cg = OverlayValueFunction(backdrop.Y, source.Y); |
|||
float cb = OverlayValueFunction(backdrop.Z, source.Z); |
|||
|
|||
return Vector4.Min(Vector4.One, new Vector4(cr, cg, cb, 0)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Hard light effect
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color</param>
|
|||
/// <param name="source">Source color</param>
|
|||
/// <returns>Output color</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Vector4 HardLight(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
float cr = OverlayValueFunction(source.X, backdrop.X); |
|||
float cg = OverlayValueFunction(source.Y, backdrop.Y); |
|||
float cb = OverlayValueFunction(source.Z, backdrop.Z); |
|||
|
|||
return Vector4.Min(Vector4.One, new Vector4(cr, cg, cb, 0)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Helper function for Overlay andHardLight modes
|
|||
/// </summary>
|
|||
/// <param name="backdrop">Backdrop color element</param>
|
|||
/// <param name="source">Source color element</param>
|
|||
/// <returns>Overlay value</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
private static float OverlayValueFunction(float backdrop, float source) |
|||
{ |
|||
return backdrop <= 0.5f ? (2 * backdrop * source) : 1 - ((2 * (1 - source)) * (1 - backdrop)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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 SrcOverReference(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 a = xw + bw + sw; |
|||
|
|||
// calculate final value
|
|||
xform = ((xform * xw) + (backdrop * bw) + (source * sw)) / MathF.Max(a, Constants.Epsilon); |
|||
xform.W = a; |
|||
|
|||
return xform; |
|||
} |
|||
|
|||
public static Vector4 Over(Vector4 dst, Vector4 src, Vector4 blend) |
|||
{ |
|||
// calculate weights
|
|||
float blendW = dst.W * src.W; |
|||
float dstW = dst.W - blendW; |
|||
float srcW = src.W - blendW; |
|||
|
|||
// calculate final alpha
|
|||
float alpha = dstW + srcW + blendW; |
|||
|
|||
// calculate final color
|
|||
Vector4 color = (dst * dstW) + (src * srcW) + (blend * blendW); |
|||
|
|||
// unpremultiply
|
|||
color /= MathF.Max(alpha, Constants.Epsilon); |
|||
color.W = alpha; |
|||
|
|||
return color; |
|||
} |
|||
|
|||
public static Vector4 Atop(Vector4 dst, Vector4 src, Vector4 blend) |
|||
{ |
|||
// calculate weights
|
|||
float blendW = dst.W * src.W; |
|||
float dstW = dst.W - blendW; |
|||
|
|||
// calculate final alpha
|
|||
float alpha = dstW + blendW; |
|||
|
|||
// calculate final color
|
|||
Vector4 color = (dst * dstW) + (blend * blendW); |
|||
|
|||
// unpremultiply
|
|||
color /= MathF.Max(alpha, Constants.Epsilon); |
|||
color.W = alpha; |
|||
|
|||
return color; |
|||
} |
|||
|
|||
public static Vector4 In(Vector4 dst, Vector4 src, Vector4 blend) |
|||
{ |
|||
float alpha = dst.W * src.W; |
|||
|
|||
Vector4 color = src * alpha; // premultiply
|
|||
color /= MathF.Max(alpha, Constants.Epsilon); // unpremultiply
|
|||
color.W = alpha; |
|||
|
|||
return color; |
|||
} |
|||
|
|||
public static Vector4 Out(Vector4 dst, Vector4 src) |
|||
{ |
|||
float alpha = (1 - dst.W) * src.W; |
|||
|
|||
Vector4 color = src * alpha; // premultiply
|
|||
color /= MathF.Max(alpha, Constants.Epsilon); // unpremultiply
|
|||
color.W = alpha; |
|||
|
|||
return color; |
|||
} |
|||
|
|||
public static Vector4 Xor(Vector4 dst, Vector4 src) |
|||
{ |
|||
float srcW = 1 - dst.W; |
|||
float dstW = 1 - src.W; |
|||
|
|||
float alpha = (src.W * srcW) + (dst.W * dstW); |
|||
Vector4 color = (src.W * src * srcW) + (dst.W * dst * dstW); |
|||
|
|||
// unpremultiply
|
|||
color /= MathF.Max(alpha, Constants.Epsilon); |
|||
color.W = alpha; |
|||
|
|||
return color; |
|||
} |
|||
|
|||
private static Vector4 Clear(Vector4 backdrop, Vector4 source) |
|||
{ |
|||
return Vector4.Zero; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,56 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.PixelFormats |
|||
{ |
|||
/// <summary>
|
|||
/// Enumerates the various color blending modes.
|
|||
/// </summary>
|
|||
public enum PixelColorBlendingMode |
|||
{ |
|||
/// <summary>
|
|||
/// Default blending mode, also known as "Normal" or "Alpha Blending"
|
|||
/// </summary>
|
|||
Normal = 0, |
|||
|
|||
/// <summary>
|
|||
/// Blends the 2 values by multiplication.
|
|||
/// </summary>
|
|||
Multiply, |
|||
|
|||
/// <summary>
|
|||
/// Blends the 2 values by addition.
|
|||
/// </summary>
|
|||
Add, |
|||
|
|||
/// <summary>
|
|||
/// Blends the 2 values by subtraction.
|
|||
/// </summary>
|
|||
Subtract, |
|||
|
|||
/// <summary>
|
|||
/// Multiplies the complements of the backdrop and source values, then complements the result.
|
|||
/// </summary>
|
|||
Screen, |
|||
|
|||
/// <summary>
|
|||
/// Selects the minimum of the backdrop and source values.
|
|||
/// </summary>
|
|||
Darken, |
|||
|
|||
/// <summary>
|
|||
/// Selects the max of the backdrop and source values.
|
|||
/// </summary>
|
|||
Lighten, |
|||
|
|||
/// <summary>
|
|||
/// Multiplies or screens the values, depending on the backdrop vector values.
|
|||
/// </summary>
|
|||
Overlay, |
|||
|
|||
/// <summary>
|
|||
/// Multiplies or screens the colors, depending on the source value.
|
|||
/// </summary>
|
|||
HardLight, |
|||
} |
|||
} |
|||
@ -1,50 +1,217 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.PixelFormats.PixelBlenders; |
|||
|
|||
namespace SixLabors.ImageSharp.PixelFormats |
|||
{ |
|||
/// <content>
|
|||
/// Provides access to pixel blenders
|
|||
/// </content>
|
|||
public partial class PixelOperations<TPixel> |
|||
where TPixel : struct, IPixel<TPixel> |
|||
{ |
|||
/// <summary>
|
|||
/// Find an instance of the pixel blender.
|
|||
/// </summary>
|
|||
/// <param name="mode">The blending mode to apply</param>
|
|||
/// <returns>A <see cref="PixelBlender{TPixel}"/>.</returns>
|
|||
internal virtual PixelBlender<TPixel> GetPixelBlender(PixelBlenderMode mode) |
|||
{ |
|||
switch (mode) |
|||
{ |
|||
case PixelBlenderMode.Multiply: return DefaultPixelBlenders<TPixel>.Multiply.Instance; |
|||
case PixelBlenderMode.Add: return DefaultPixelBlenders<TPixel>.Add.Instance; |
|||
case PixelBlenderMode.Subtract: return DefaultPixelBlenders<TPixel>.Subtract.Instance; |
|||
case PixelBlenderMode.Screen: return DefaultPixelBlenders<TPixel>.Screen.Instance; |
|||
case PixelBlenderMode.Darken: return DefaultPixelBlenders<TPixel>.Darken.Instance; |
|||
case PixelBlenderMode.Lighten: return DefaultPixelBlenders<TPixel>.Lighten.Instance; |
|||
case PixelBlenderMode.Overlay: return DefaultPixelBlenders<TPixel>.Overlay.Instance; |
|||
case PixelBlenderMode.HardLight: return DefaultPixelBlenders<TPixel>.HardLight.Instance; |
|||
case PixelBlenderMode.Src: return DefaultPixelBlenders<TPixel>.Src.Instance; |
|||
case PixelBlenderMode.Atop: return DefaultPixelBlenders<TPixel>.Atop.Instance; |
|||
case PixelBlenderMode.Over: return DefaultPixelBlenders<TPixel>.Over.Instance; |
|||
case PixelBlenderMode.In: return DefaultPixelBlenders<TPixel>.In.Instance; |
|||
case PixelBlenderMode.Out: return DefaultPixelBlenders<TPixel>.Out.Instance; |
|||
case PixelBlenderMode.Dest: return DefaultPixelBlenders<TPixel>.Dest.Instance; |
|||
case PixelBlenderMode.DestAtop: return DefaultPixelBlenders<TPixel>.DestAtop.Instance; |
|||
case PixelBlenderMode.DestOver: return DefaultPixelBlenders<TPixel>.DestOver.Instance; |
|||
case PixelBlenderMode.DestIn: return DefaultPixelBlenders<TPixel>.DestIn.Instance; |
|||
case PixelBlenderMode.DestOut: return DefaultPixelBlenders<TPixel>.DestOut.Instance; |
|||
case PixelBlenderMode.Clear: return DefaultPixelBlenders<TPixel>.Clear.Instance; |
|||
case PixelBlenderMode.Xor: return DefaultPixelBlenders<TPixel>.Xor.Instance; |
|||
|
|||
case PixelBlenderMode.Normal: |
|||
default: |
|||
return DefaultPixelBlenders<TPixel>.Normal.Instance; |
|||
} |
|||
} |
|||
} |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.PixelFormats.PixelBlenders; |
|||
|
|||
namespace SixLabors.ImageSharp.PixelFormats |
|||
{ |
|||
/// <content>
|
|||
/// Provides access to pixel blenders
|
|||
/// </content>
|
|||
public partial class PixelOperations<TPixel> |
|||
where TPixel : struct, IPixel<TPixel> |
|||
{ |
|||
/// <summary>
|
|||
/// Find an instance of the pixel blender.
|
|||
/// </summary>
|
|||
/// <param name="options">the blending and composition to apply</param>
|
|||
/// <returns>A <see cref="PixelBlender{TPixel}"/>.</returns>
|
|||
internal PixelBlender<TPixel> GetPixelBlender(GraphicsOptions options) |
|||
{ |
|||
return this.GetPixelBlender(options.ColorBlendingMode, options.AlphaCompositionMode); |
|||
} |
|||
|
|||
/// <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>
|
|||
internal 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; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue