/// <summary>
/// Fills the whole WriteableBitmap with a color.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <param name="color">The color used for filling.</param>
public static void Clear(this WriteableBitmap bmp, Color color)
{
var col = ConvertColor(color);
using (var context = bmp.GetBitmapContext())
{
var pixels = context.Pixels;
var w = context.Width;
var h = context.Height;
var len = w * SizeOfArgb;
// Fill first line
for (var x = 0; x < w; x++)
{
pixels[x] = col;
}
// Copy first line
var blockHeight = 1;
var y = 1;
while (y < h)
{
BitmapContext.BlockCopy(context, 0, context, y * len, blockHeight * len);
y += blockHeight;
blockHeight = Math.Min(2 * blockHeight, h - y);
}
}
}
/// <summary>
/// Copies color information from an ARGB byte array into this WriteableBitmap starting at a specific buffer index.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <param name="offset">The starting index in the buffer.</param>
/// <param name="count">The number of bytes to copy from the buffer.</param>
/// <param name="buffer">The color buffer as byte ARGB values.</param>
/// <returns>The WriteableBitmap that was passed as parameter.</returns>
public static WriteableBitmap FromByteArray(this WriteableBitmap bmp, byte[] buffer, int offset, int count)
{
using (var context = bmp.GetBitmapContext())
{
BitmapContext.BlockCopy(buffer, offset, context, 0, count);
return(bmp);
}
}
/// <summary>
/// Clones the specified WriteableBitmap.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <returns>A copy of the WriteableBitmap.</returns>
public static WriteableBitmap Clone(this WriteableBitmap bmp)
{
using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly))
{
var result = BitmapFactory.New(srcContext.Width, srcContext.Height);
using (var destContext = result.GetBitmapContext())
{
BitmapContext.BlockCopy(srcContext, 0, destContext, 0, srcContext.Length * SizeOfArgb);
}
return(result);
}
}
/// <summary>
/// Creates a new resized WriteableBitmap.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <param name="width">The new desired width.</param>
/// <param name="height">The new desired height.</param>
/// <param name="interpolation">The interpolation method that should be used.</param>
/// <returns>A new WriteableBitmap that is a resized version of the input.</returns>
public static WriteableBitmap Resize(this WriteableBitmap bmp, int width, int height, Interpolation interpolation)
{
using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly))
{
var pd = Resize(srcContext, srcContext.Width, srcContext.Height, width, height, interpolation);
var result = BitmapFactory.New(width, height);
using (var dstContext = result.GetBitmapContext())
{
BitmapContext.BlockCopy(pd, 0, dstContext, 0, SizeOfArgb * pd.Length);
}
return(result);
}
}
/// <summary>
/// Copies the Pixels from the WriteableBitmap into a ARGB byte array starting at a specific Pixels index.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <param name="offset">The starting Pixels index.</param>
/// <param name="count">The number of Pixels to copy, -1 for all</param>
/// <returns>The color buffer as byte ARGB values.</returns>
public static byte[] ToByteArray(this WriteableBitmap bmp, int offset, int count)
{
using (var context = bmp.GetBitmapContext(ReadWriteMode.ReadOnly))
{
if (count == -1)
{
// Copy all to byte array
count = context.Length;
}
var len = count * SizeOfArgb;
var result = new byte[len]; // ARGB
BitmapContext.BlockCopy(context, offset, result, 0, len);
return(result);
}
}
/// <summary>
/// Creates a new cropped WriteableBitmap.
/// </summary>
/// <param name="bmp">The WriteableBitmap.</param>
/// <param name="x">The x coordinate of the rectangle that defines the crop region.</param>
/// <param name="y">The y coordinate of the rectangle that defines the crop region.</param>
/// <param name="width">The width of the rectangle that defines the crop region.</param>
/// <param name="height">The height of the rectangle that defines the crop region.</param>
/// <returns>A new WriteableBitmap that is a cropped version of the input.</returns>
public static WriteableBitmap Crop(this WriteableBitmap bmp, int x, int y, int width, int height)
{
using (var srcContext = bmp.GetBitmapContext(ReadWriteMode.ReadOnly))
{
var srcWidth = srcContext.Width;
var srcHeight = srcContext.Height;
// If the rectangle is completely out of the bitmap
if (x > srcWidth || y > srcHeight)
{
return(BitmapFactory.New(0, 0));
}
// Clamp to boundaries
if (x < 0)
{
x = 0;
}
if (x + width > srcWidth)
{
width = srcWidth - x;
}
if (y < 0)
{
y = 0;
}
if (y + height > srcHeight)
{
height = srcHeight - y;
}
// Copy the pixels line by line using fast BlockCopy
var result = BitmapFactory.New(width, height);
using (var destContext = result.GetBitmapContext())
{
for (var line = 0; line < height; line++)
{
var srcOff = ((y + line) * srcWidth + x) * SizeOfArgb;
var dstOff = line * width * SizeOfArgb;
BitmapContext.BlockCopy(srcContext, srcOff, destContext, dstOff, width * SizeOfArgb);
}
return(result);
}
}
}
/// <summary>
/// Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
/// </summary>
/// <param name="bmp">The destination WriteableBitmap.</param>
/// <param name="destRect">The rectangle that defines the destination region.</param>
/// <param name="source">The source WriteableBitmap.</param>
/// <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
/// <param name="color">If not Colors.White, will tint the source image. A partially transparent color and the image will be drawn partially transparent. If the BlendMode is ColorKeying, this color will be used as color key to mask all pixels with this value out.</param>
/// <param name="blendMode">The blending mode <see cref="BlendMode"/>.</param>
internal static void Blit(this WriteableBitmap bmp, Rect destRect, WriteableBitmap source, Rect sourceRect, Color color, BlendMode blendMode)
{
if (color.A == 0)
{
return;
}
var dw = (int)destRect.Width;
var dh = (int)destRect.Height;
using (var srcContext = source.GetBitmapContext(ReadWriteMode.ReadOnly))
{
var isPrgba = srcContext.Format == PixelFormats.Pbgra32 || srcContext.Format == PixelFormats.Prgba64 || srcContext.Format == PixelFormats.Prgba128Float;
using (var destContext = bmp.GetBitmapContext())
{
var sourceWidth = srcContext.Width;
var dpw = destContext.Width;
var dph = destContext.Height;
var intersect = new Rect(0, 0, dpw, dph);
intersect.Intersect(destRect);
if (intersect.IsEmpty)
{
return;
}
var sourcePixels = srcContext.Pixels;
var destPixels = destContext.Pixels;
var sourceLength = srcContext.Length;
int sourceIdx = -1;
int px = (int)destRect.X;
int py = (int)destRect.Y;
int x;
int y;
int idx;
double ii;
double jj;
int sr = 0;
int sg = 0;
int sb = 0;
int dr, dg, db;
int sourcePixel;
int sa = 0;
int da;
int ca = color.A;
int cr = color.R;
int cg = color.G;
int cb = color.B;
bool tinted = color != Colors.White;
var sw = (int)sourceRect.Width;
var sdx = sourceRect.Width / destRect.Width;
var sdy = sourceRect.Height / destRect.Height;
int sourceStartX = (int)sourceRect.X;
int sourceStartY = (int)sourceRect.Y;
int lastii, lastjj;
lastii = -1;
lastjj = -1;
jj = sourceStartY;
y = py;
for (int j = 0; j < dh; j++)
{
if (y >= 0 && y < dph)
{
ii = sourceStartX;
idx = px + y * dpw;
x = px;
sourcePixel = sourcePixels[0];
// Scanline BlockCopy is much faster (3.5x) if no tinting and blending is needed,
// even for smaller sprites like the 32x32 particles.
if (blendMode == BlendMode.None && !tinted)
{
sourceIdx = (int)ii + (int)jj * sourceWidth;
var offset = x < 0 ? -x : 0;
var xx = x + offset;
var wx = sourceWidth - offset;
var len = xx + wx < dpw ? wx : dpw - xx;
if (len > sw)
{
len = sw;
}
if (len > dw)
{
len = dw;
}
BitmapContext.BlockCopy(srcContext, (sourceIdx + offset) * 4, destContext, (idx + offset) * 4, len * 4);
}
// Pixel by pixel copying
else
{
for (int i = 0; i < dw; i++)
{
if (x >= 0 && x < dpw)
{
if ((int)ii != lastii || (int)jj != lastjj)
{
sourceIdx = (int)ii + (int)jj * sourceWidth;
if (sourceIdx >= 0 && sourceIdx < sourceLength)
{
sourcePixel = sourcePixels[sourceIdx];
sa = ((sourcePixel >> 24) & 0xff);
sr = ((sourcePixel >> 16) & 0xff);
sg = ((sourcePixel >> 8) & 0xff);
sb = ((sourcePixel) & 0xff);
if (tinted && sa != 0)
{
sa = (((sa * ca) * 0x8081) >> 23);
sr = ((((((sr * cr) * 0x8081) >> 23) * ca) * 0x8081) >> 23);
sg = ((((((sg * cg) * 0x8081) >> 23) * ca) * 0x8081) >> 23);
sb = ((((((sb * cb) * 0x8081) >> 23) * ca) * 0x8081) >> 23);
sourcePixel = (sa << 24) | (sr << 16) | (sg << 8) | sb;
}
}
else
{
sa = 0;
}
}
if (blendMode == BlendMode.None)
{
destPixels[idx] = sourcePixel;
}
else if (blendMode == BlendMode.ColorKeying)
{
sr = ((sourcePixel >> 16) & 0xff);
sg = ((sourcePixel >> 8) & 0xff);
sb = ((sourcePixel) & 0xff);
if (sr != color.R || sg != color.G || sb != color.B)
{
destPixels[idx] = sourcePixel;
}
}
else if (blendMode == BlendMode.Mask)
{
int destPixel = destPixels[idx];
da = ((destPixel >> 24) & 0xff);
dr = ((destPixel >> 16) & 0xff);
dg = ((destPixel >> 8) & 0xff);
db = ((destPixel) & 0xff);
destPixel = ((((da * sa) * 0x8081) >> 23) << 24) |
((((dr * sa) * 0x8081) >> 23) << 16) |
((((dg * sa) * 0x8081) >> 23) << 8) |
((((db * sa) * 0x8081) >> 23));
destPixels[idx] = destPixel;
}
else if (sa > 0)
{
int destPixel = destPixels[idx];
da = ((destPixel >> 24) & 0xff);
if ((sa == 255 || da == 0) &&
blendMode != BlendMode.Additive &&
blendMode != BlendMode.Subtractive &&
blendMode != BlendMode.Multiply
)
{
destPixels[idx] = sourcePixel;
}
else
{
dr = ((destPixel >> 16) & 0xff);
dg = ((destPixel >> 8) & 0xff);
db = ((destPixel) & 0xff);
if (blendMode == BlendMode.Alpha)
{
var isa = 255 - sa;
if (isPrgba)
{
destPixel = ((da & 0xff) << 24) |
(((((sr << 8) + isa * dr) >> 8) & 0xff) << 16) |
(((((sg << 8) + isa * dg) >> 8) & 0xff) << 8) |
((((sb << 8) + isa * db) >> 8) & 0xff);
}
else
{
destPixel = ((da & 0xff) << 24) |
(((((sr * sa) + isa * dr) >> 8) & 0xff) << 16) |
(((((sg * sa) + isa * dg) >> 8) & 0xff) << 8) |
((((sb * sa) + isa * db) >> 8) & 0xff);
}
}
else if (blendMode == BlendMode.Additive)
{
int a = (255 <= sa + da) ? 255 : (sa + da);
destPixel = (a << 24) |
(((a <= sr + dr) ? a : (sr + dr)) << 16) |
(((a <= sg + dg) ? a : (sg + dg)) << 8) |
(((a <= sb + db) ? a : (sb + db)));
}
else if (blendMode == BlendMode.Subtractive)
{
int a = da;
destPixel = (a << 24) |
(((sr >= dr) ? 0 : (sr - dr)) << 16) |
(((sg >= dg) ? 0 : (sg - dg)) << 8) |
(((sb >= db) ? 0 : (sb - db)));
}
else if (blendMode == BlendMode.Multiply)
{
// Faster than a division like (s * d) / 255 are 2 shifts and 2 adds
int ta = (sa * da) + 128;
int tr = (sr * dr) + 128;
int tg = (sg * dg) + 128;
int tb = (sb * db) + 128;
int ba = ((ta >> 8) + ta) >> 8;
int br = ((tr >> 8) + tr) >> 8;
int bg = ((tg >> 8) + tg) >> 8;
int bb = ((tb >> 8) + tb) >> 8;
destPixel = (ba << 24) |
((ba <= br ? ba : br) << 16) |
((ba <= bg ? ba : bg) << 8) |
((ba <= bb ? ba : bb));
}
destPixels[idx] = destPixel;
}
}
}
x++;
idx++;
ii += sdx;
}
}
}
jj += sdy;
y++;
}
}
}
}
