public JBitmap CreateCopy()
{
JBitmap newBitmap = new JBitmap(w, h, format);
Blit(newBitmap, w, h);
return(newBitmap);
}
public JBitmap CreateCopy()
{
JBitmap newBitmap = new JBitmap(w, h, format);
Blit(newBitmap, w, h);
return newBitmap;
}
public void Blit(JBitmap target, int px, int py)
{
if (target.format != format)
{
throw new Exception("Attempted to blit between bitmaps not of the same format");
}
int bpp = (int)format;
int targetStartX, targetEndX;
int targetStartY, targetEndY;
int copyW, copyH;
targetStartX = Math.Max(px, 0);
targetEndX = Math.Min(px + bitmapData.Width, target.bitmapData.Width);
targetStartY = Math.Max(py, 0);
targetEndY = Math.Min(py + bitmapData.Height, target.bitmapData.Height);
copyW = targetEndX - targetStartX;
copyH = targetEndY - targetStartY;
if (copyW < 0)
{
return;
}
if (copyH < 0)
{
return;
}
int sourceStartX = targetStartX - px;
int sourceStartY = targetStartY - py;
unsafe
{
byte *sourcePtr = (byte *)(bitmapData.Scan0);
byte *targetPtr = (byte *)(target.bitmapData.Scan0);
byte *targetY = targetPtr + targetStartY * target.bitmapData.Stride;
byte *sourceY = sourcePtr + sourceStartY * bitmapData.Stride;
for (int y = 0; y < copyH; y++, targetY += target.bitmapData.Stride, sourceY += bitmapData.Stride)
{
byte *targetOffset = targetY + targetStartX * bpp;
byte *sourceOffset = sourceY + sourceStartX * bpp;
for (int x = 0; x < copyW * bpp; x++, targetOffset++, sourceOffset++)
{
*(targetOffset) = *(sourceOffset);
}
}
}
}
/// <summary>
/// Blits this bitmap onto the target - clips regions that are out of bounds.
///
/// Only supported for 8bbp
/// </summary>
/// <param name="target"></param>
/// <param name="targetX"></param>
/// <param name="targetY"></param>
public void BlitOLD(JBitmap target, int px, int py)
{
//currently only supported for 8 bpp source / target
if (bitmapData.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed &&
target.bitmapData.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
{
int targetStartX, targetEndX;
int targetStartY, targetEndY;
int copyW, copyH;
targetStartX = Math.Max(px, 0);
targetEndX = Math.Min(px + bitmapData.Width, target.bitmapData.Width);
targetStartY = Math.Max(py, 0);
targetEndY = Math.Min(py + bitmapData.Height, target.bitmapData.Height);
copyW = targetEndX - targetStartX;
copyH = targetEndY - targetStartY;
if (copyW < 0)
{
return;
}
if (copyH < 0)
{
return;
}
int sourceStartX = targetStartX - px;
int sourceStartY = targetStartY - py;
unsafe
{
byte *sourcePtr = (byte *)(bitmapData.Scan0);
byte *targetPtr = (byte *)(target.bitmapData.Scan0);
byte *targetY = targetPtr + targetStartY * target.bitmapData.Stride;
byte *sourceY = sourcePtr + sourceStartY * bitmapData.Stride;
for (int y = 0; y < copyH; y++, targetY += target.bitmapData.Stride, sourceY += bitmapData.Stride)
{
byte *targetOffset = targetY + targetStartX;
byte *sourceOffset = sourceY + sourceStartX;
for (int x = 0; x < copyW; x++, targetOffset++, sourceOffset++)
{
*(targetOffset) = *(sourceOffset);
}
}
}
}
}
public void Remove(JBitmap bmpToRemove)
{
bitmapList.Remove(bmpToRemove);
bmpToRemove.Free();
}
public JBitmap Add(JBitmap bmp)
{
bitmapList.Add(bmp);
return bmp;
}
/*
* Resizes this bitmap to a smaller size using area-weighted averaging.
*
*/
public void DownScale(int newWidth, int newHeight)
{
JBitmap newBitmap = new JBitmap(newWidth, newHeight, format);
float xscale = (float)bitmapData.Width / newWidth;
float yscale = (float)bitmapData.Height / newHeight;
byte r = 0, g = 0, b = 0, a = 0;
float summedR = 0f;
float summedG = 0f;
float summedB = 0f;
float summedA = 0f;
int left, right, top, bottom; //the area of old pixels covered by the new bitmap
float targetStartX, targetEndX;
float targetStartY, targetEndY;
float leftF, rightF, topF, bottomF; //edges of new pixel in old pixel coords
float weight;
float weightScale = xscale * yscale;
float weightTotalTest = 0f;
for (int m = 0; m < newHeight; m++)
{
for (int n = 0; n < newWidth; n++)
{
leftF = n * xscale;
rightF = (n + 1) * xscale;
topF = m * yscale;
bottomF = (m + 1) * yscale;
left = (int)leftF;
right = (int)rightF;
top = (int)topF;
bottom = (int)bottomF;
if (left < 0) left = 0;
if (top < 0) top = 0;
if (right >= bitmapData.Width) right = bitmapData.Width - 1;
if (bottom >= bitmapData.Height) bottom = bitmapData.Height - 1;
summedR = 0f;
summedG = 0f;
summedB = 0f;
summedA = 0f;
weightTotalTest = 0f;
for (int j = top; j <= bottom; j++)
{
for (int i = left; i <= right; i++)
{
targetStartX = Math.Max(leftF, i);
targetEndX = Math.Min(rightF, i + 1);
targetStartY = Math.Max(topF, j);
targetEndY = Math.Min(bottomF, j + 1);
weight = (targetEndX - targetStartX) * (targetEndY - targetStartY);
GetPixelFast(i, j, ref r, ref g, ref b, ref a);
summedR += weight * r;
summedG += weight * g;
summedB += weight * b;
summedA += weight * a;
weightTotalTest += weight;
}
}
summedR /= weightScale;
summedG /= weightScale;
summedB /= weightScale;
summedA /= weightScale;
if (summedR < 0) summedR = 0f;
if (summedG < 0) summedG = 0f;
if (summedB < 0) summedB = 0f;
if (summedA < 0) summedA = 0f;
if (summedR >= 256) summedR = 255;
if (summedG >= 256) summedG = 255;
if (summedB >= 256) summedB = 255;
if (summedA >= 256) summedA = 255;
newBitmap.PutPixelFast(n, m, (byte)summedR, (byte)summedG, (byte)summedB, (byte)summedA);
}
}
this.Free();
this.bitmap = newBitmap.bitmap;
this.bitmapData = newBitmap.bitmapData;
this.format = newBitmap.format;
}
public void BlitMax(JBitmap target, int px, int py, float strength)
{
//currently only supported for 8 bpp source / target
if (bitmapData.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed &&
target.bitmapData.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
{
int targetStartX, targetEndX;
int targetStartY, targetEndY;
int copyW, copyH;
targetStartX = Math.Max(px, 0);
targetEndX = Math.Min(px + bitmapData.Width, target.bitmapData.Width);
targetStartY = Math.Max(py, 0);
targetEndY = Math.Min(py + bitmapData.Height, target.bitmapData.Height);
copyW = targetEndX - targetStartX;
copyH = targetEndY - targetStartY;
if (copyW < 0)
{
return;
}
if (copyH < 0)
{
return;
}
int sourceStartX = targetStartX - px;
int sourceStartY = targetStartY - py;
unsafe
{
byte* sourcePtr = (byte*)(bitmapData.Scan0);
byte* targetPtr = (byte*)(target.bitmapData.Scan0);
int max;
byte* targetY = targetPtr + targetStartY * target.bitmapData.Stride;
byte* sourceY = sourcePtr + sourceStartY * bitmapData.Stride;
for (int y = 0; y < copyH; y++, targetY += target.bitmapData.Stride, sourceY += bitmapData.Stride)
{
byte* targetOffset = targetY + targetStartX;
byte* sourceOffset = sourceY + sourceStartX;
for (int x = 0; x < copyW; x++, targetOffset++, sourceOffset++)
{
max = Math.Max((int)*(targetOffset), (int) (*(sourceOffset) * strength));
if (*(sourceOffset) * strength > *(targetOffset))
{
max = (int) (*(sourceOffset) * strength );
if (max > 255)
{
*(targetOffset) = 255;
}
else
{
*(targetOffset) = (byte)max;
}
}
}
}
}
}
}
public void Blit(JBitmap target, int px, int py)
{
if (target.format != format)
{
throw new Exception("Attempted to blit between bitmaps not of the same format");
}
int bpp = (int)format;
int targetStartX, targetEndX;
int targetStartY, targetEndY;
int copyW, copyH;
targetStartX = Math.Max(px, 0);
targetEndX = Math.Min(px + bitmapData.Width, target.bitmapData.Width);
targetStartY = Math.Max(py, 0);
targetEndY = Math.Min(py + bitmapData.Height, target.bitmapData.Height);
copyW = targetEndX - targetStartX;
copyH = targetEndY - targetStartY;
if (copyW < 0)
{
return;
}
if (copyH < 0)
{
return;
}
int sourceStartX = targetStartX - px;
int sourceStartY = targetStartY - py;
unsafe
{
byte* sourcePtr = (byte*)(bitmapData.Scan0);
byte* targetPtr = (byte*)(target.bitmapData.Scan0);
byte* targetY = targetPtr + targetStartY * target.bitmapData.Stride;
byte* sourceY = sourcePtr + sourceStartY * bitmapData.Stride;
for (int y = 0; y < copyH; y++, targetY += target.bitmapData.Stride, sourceY += bitmapData.Stride)
{
byte* targetOffset = targetY + targetStartX*bpp;
byte* sourceOffset = sourceY + sourceStartX*bpp;
for (int x = 0; x < copyW*bpp; x++, targetOffset++, sourceOffset++)
{
*(targetOffset) = *(sourceOffset);
}
}
}
}
public void Remove(JBitmap bmpToRemove)
{
bitmapList.Remove(bmpToRemove);
bmpToRemove.Free();
}
public JTexture(JBitmap jbitmap, bool alpha)
{
JTextureConstructorHelper(jbitmap.bitmapData, alpha, false);
}
/*
* Resizes this bitmap to a smaller size using area-weighted averaging.
*
*/
public void DownScale(int newWidth, int newHeight)
{
JBitmap newBitmap = new JBitmap(newWidth, newHeight, format);
float xscale = (float)bitmapData.Width / newWidth;
float yscale = (float)bitmapData.Height / newHeight;
byte r = 0, g = 0, b = 0, a = 0;
float summedR = 0f;
float summedG = 0f;
float summedB = 0f;
float summedA = 0f;
int left, right, top, bottom; //the area of old pixels covered by the new bitmap
float targetStartX, targetEndX;
float targetStartY, targetEndY;
float leftF, rightF, topF, bottomF; //edges of new pixel in old pixel coords
float weight;
float weightScale = xscale * yscale;
float weightTotalTest = 0f;
for (int m = 0; m < newHeight; m++)
{
for (int n = 0; n < newWidth; n++)
{
leftF = n * xscale;
rightF = (n + 1) * xscale;
topF = m * yscale;
bottomF = (m + 1) * yscale;
left = (int)leftF;
right = (int)rightF;
top = (int)topF;
bottom = (int)bottomF;
if (left < 0)
{
left = 0;
}
if (top < 0)
{
top = 0;
}
if (right >= bitmapData.Width)
{
right = bitmapData.Width - 1;
}
if (bottom >= bitmapData.Height)
{
bottom = bitmapData.Height - 1;
}
summedR = 0f;
summedG = 0f;
summedB = 0f;
summedA = 0f;
weightTotalTest = 0f;
for (int j = top; j <= bottom; j++)
{
for (int i = left; i <= right; i++)
{
targetStartX = Math.Max(leftF, i);
targetEndX = Math.Min(rightF, i + 1);
targetStartY = Math.Max(topF, j);
targetEndY = Math.Min(bottomF, j + 1);
weight = (targetEndX - targetStartX) * (targetEndY - targetStartY);
GetPixelFast(i, j, ref r, ref g, ref b, ref a);
summedR += weight * r;
summedG += weight * g;
summedB += weight * b;
summedA += weight * a;
weightTotalTest += weight;
}
}
summedR /= weightScale;
summedG /= weightScale;
summedB /= weightScale;
summedA /= weightScale;
if (summedR < 0)
{
summedR = 0f;
}
if (summedG < 0)
{
summedG = 0f;
}
if (summedB < 0)
{
summedB = 0f;
}
if (summedA < 0)
{
summedA = 0f;
}
if (summedR >= 256)
{
summedR = 255;
}
if (summedG >= 256)
{
summedG = 255;
}
if (summedB >= 256)
{
summedB = 255;
}
if (summedA >= 256)
{
summedA = 255;
}
newBitmap.PutPixelFast(n, m, (byte)summedR, (byte)summedG, (byte)summedB, (byte)summedA);
}
}
this.Free();
this.bitmap = newBitmap.bitmap;
this.bitmapData = newBitmap.bitmapData;
this.format = newBitmap.format;
}
/// <summary>
/// Additively blits onto the target.
///
/// Supports just 24bpp (source and target)
/// </summary>
/// <param name="target"></param>
/// <param name="targetX"></param>
/// <param name="targetY"></param>
public void BlitAdditive24(JBitmap target, int px, int py, float strength)
{
//currently only supported for 8 bpp source / target
if (bitmapData.PixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb &&
target.bitmapData.PixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
{
int targetStartX, targetEndX;
int targetStartY, targetEndY;
int copyW, copyH;
targetStartX = Math.Max(px, 0);
targetEndX = Math.Min(px + bitmapData.Width, target.bitmapData.Width);
targetStartY = Math.Max(py, 0);
targetEndY = Math.Min(py + bitmapData.Height, target.bitmapData.Height);
copyW = targetEndX - targetStartX;
copyH = targetEndY - targetStartY;
if (copyW < 0)
{
return;
}
if (copyH < 0)
{
return;
}
int sourceStartX = targetStartX - px;
int sourceStartY = targetStartY - py;
unsafe
{
byte *sourcePtr = (byte *)(bitmapData.Scan0);
byte *targetPtr = (byte *)(target.bitmapData.Scan0);
int sum;
byte *targetY = targetPtr + targetStartY * target.bitmapData.Stride;
byte *sourceY = sourcePtr + sourceStartY * bitmapData.Stride;
for (int y = 0; y < copyH; y++, targetY += target.bitmapData.Stride, sourceY += bitmapData.Stride)
{
byte *targetOffset = targetY + targetStartX * 3;
byte *sourceOffset = sourceY + sourceStartX * 3;
for (int x = 0; x < copyW * 3; x++, targetOffset++, sourceOffset++)
{
sum = (int)*(targetOffset) + (int)(*(sourceOffset) * strength);
if (sum > 255)
{
*(targetOffset) = 255;
}
else
{
*(targetOffset) = (byte)sum;
}
}
}
}
}
}
public JTexture(JBitmap jbitmap, bool alpha, bool padToPowerOfTwo)
{
JTextureConstructorHelper(jbitmap.bitmapData, alpha, padToPowerOfTwo);
}
public JTexture(JBitmap jbitmap, bool alpha)
{
JTextureConstructorHelper(jbitmap.bitmapData, alpha, false);
}
public JTexture(JBitmap jbitmap, bool alpha, bool padToPowerOfTwo)
{
JTextureConstructorHelper(jbitmap.bitmapData, alpha, padToPowerOfTwo);
}
public JBitmap Add(JBitmap bmp)
{
bitmapList.Add(bmp);
return(bmp);
}
