public override void generate(RGBA_Bytes[] span, int spanIndex, int x, int y, int len)
{
ImageBuffer SourceRenderingBuffer = (ImageBuffer)GetImageBufferAccessor().SourceImage;
if (SourceRenderingBuffer.BitDepth != 24)
{
throw new NotSupportedException("The source is expected to be 32 bit.");
}
ISpanInterpolator spanInterpolator = interpolator();
spanInterpolator.begin(x + filter_dx_dbl(), y + filter_dy_dbl(), len);
int offset;
byte[] fg_ptr = SourceRenderingBuffer.GetBuffer(out offset);
do
{
int x_hr;
int y_hr;
spanInterpolator.coordinates(out x_hr, out y_hr);
int x_lr = x_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int y_lr = y_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int bufferIndex;
bufferIndex = SourceRenderingBuffer.GetBufferOffsetXY(x_lr, y_lr);
RGBA_Bytes color;
color.blue = fg_ptr[bufferIndex++];
color.green = fg_ptr[bufferIndex++];
color.red = fg_ptr[bufferIndex++];
color.alpha = 255;
span[spanIndex] = color;
spanIndex++;
spanInterpolator.Next();
} while (--len != 0);
}
public void Update(double NumSecondsPassed)
{
foreach (SequenceEntity aSequenceEntity in sequenceEntityList)
{
aSequenceEntity.Update(NumSecondsPassed);
}
foreach (Player aPlayer in playerList)
{
aPlayer.Update(NumSecondsPassed);
{
int offset;
byte[] buffer = levelMap.GetBuffer(out offset);
Vector2D newPosition = aPlayer.Position;
int xOnMap = ((int)(newPosition.x + .5)) / 16;
int yOnMap = ((int)(newPosition.y + .5)) / 16;
offset = levelMap.GetBufferOffsetXY(xOnMap, yOnMap);
if (aPlayer.hasKey && buffer[offset] == 43)
{
aPlayer.m_Score++;
aPlayer.hasKey = false;
aPlayer.entityHolding = null;
key.Position = keyStart;
}
}
}
RemoveDeadStuff(sequenceEntityList);
}
public static Bitmap ConvertImageToBitmap(ImageBuffer sourceImage)
{
var bitmap = new Bitmap(sourceImage.Width, sourceImage.Height, PixelFormat.Format32bppArgb);
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
int destIndex = 0;
unsafe
{
byte[] sourceBuffer = sourceImage.GetBuffer();
byte * pDestBuffer = (byte *)bitmapData.Scan0;
int scanlinePadding = bitmapData.Stride - bitmapData.Width * 4;
for (int y = 0; y < sourceImage.Height; y++)
{
int sourceIndex = sourceImage.GetBufferOffsetXY(0, sourceImage.Height - 1 - y);
for (int x = 0; x < sourceImage.Width; x++)
{
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
pDestBuffer[destIndex++] = sourceBuffer[sourceIndex++];
}
destIndex += scanlinePadding;
}
}
bitmap.UnlockBits(bitmapData);
return(bitmap);
}
void PlaceObjectsOnLevel()
{
ImageBuffer levelMap = LevelMap;
int offset;
byte[] buffer = levelMap.GetBuffer(out offset);
for (int y = 0; y < levelMap.Height(); y++)
{
for (int x = 0; x < levelMap.Width(); x++)
{
offset = levelMap.GetBufferOffsetXY(x, y);
switch (buffer[offset])
{
case 220:
// this is the sword.
sword = new Sword();
sword.Position = new Vector2D(x * 16 + 8, y * 16 + 8);
break;
case 170:
// this is the key.
key = new Key();
key.Position = new Vector2D(x * 16 + 8, y * 16 + 8);
keyStart = key.Position;
break;
case 2:
// this is the red player.
playerList[0].Position = new Vector2D(x * 16 + 8, y * 16 + 8);
break;
case 35:
// this is the green player.
playerList[1].Position = new Vector2D(x * 16 + 8, y * 16 + 8);
break;
case 251:
// this is the blue player.
playerList[2].Position = new Vector2D(x * 16 + 8, y * 16 + 8);
break;
case 5:
// this is the yellow player.
playerList[3].Position = new Vector2D(x * 16 + 8, y * 16 + 8);
break;
case 248:
// this is the shield.
shield = new Shield();
shield.Position = new Vector2D(x * 16 + 8, y * 16 + 8);
break;
default:
break;
}
}
}
}
public static void DoErode3x3MinValue(ImageBuffer source, ImageBuffer dest)
{
if (source.BitDepth != 32 || dest.BitDepth != 32)
{
throw new NotImplementedException("We only work with 32 bit at the moment.");
}
if (source.Width != dest.Width || source.Height != dest.Height)
{
throw new NotImplementedException("Source and Dest have to be the same size");
}
int height = source.Height;
int width = source.Width;
int sourceStrideInBytes = source.StrideInBytes();
int destStrideInBytes = dest.StrideInBytes();
byte[] sourceBuffer = source.GetBuffer();
byte[] destBuffer = dest.GetBuffer();
// This can be made much faster by holding the buffer pointer and offsets better // LBB 2013 06 09
for (int testY = 1; testY < height - 1; testY++)
{
for (int testX = 1; testX < width - 1; testX++)
{
Color minColor = Color.White;
int sourceOffset = source.GetBufferOffsetXY(testX, testY - 1);
// x-1, y-1
//minColor = MinColor(sourceBuffer, minColor, sourceOffset - 4);
// x0, y-1
minColor = MinColor(sourceBuffer, minColor, sourceOffset + 0);
// x1, y-1
//minColor = MinColor(sourceBuffer, minColor, sourceOffset + 4);
// x-1, y0
minColor = MinColor(sourceBuffer, minColor, sourceOffset + sourceStrideInBytes - 4);
// x0, y0
minColor = MinColor(sourceBuffer, minColor, sourceOffset + sourceStrideInBytes + 0);
// x+1, y0
minColor = MinColor(sourceBuffer, minColor, sourceOffset + sourceStrideInBytes + 4);
// x-1, y+1
//minColor = MinColor(sourceBuffer, minColor, sourceOffset + sourceStrideInBytes * 2 - 4);
// x0, y+1
minColor = MinColor(sourceBuffer, minColor, sourceOffset + sourceStrideInBytes * 2 + 0);
// x+1, y+1
//minColor = MinColor(sourceBuffer, minColor, sourceOffset + sourceStrideInBytes * 2 + 4);
int destOffset = dest.GetBufferOffsetXY(testX, testY);
destBuffer[destOffset + 2] = minColor.red;
destBuffer[destOffset + 1] = minColor.green;
destBuffer[destOffset + 0] = minColor.blue;
destBuffer[destOffset + 3] = 255;
}
}
}
public static void DoDilate3x3MaxValue(ImageBuffer source, ImageBuffer dest)
{
if (source.BitDepth != 32 || dest.BitDepth != 32)
{
throw new NotImplementedException("We only work with 32 bit at the moment.");
}
if (source.Width != dest.Width || source.Height != dest.Height)
{
throw new NotImplementedException("Source and Dest have to be the same size");
}
int height = source.Height;
int width = source.Width;
int sourceStrideInBytes = source.StrideInBytes();
int destStrideInBytes = dest.StrideInBytes();
byte[] sourceBuffer = source.GetBuffer();
byte[] destBuffer = dest.GetBuffer();
for (int testY = 1; testY < height - 1; testY++)
{
for (int testX = 1; testX < width - 1; testX++)
{
RGBA_Bytes maxColor = RGBA_Bytes.Black;
int sourceOffset = source.GetBufferOffsetXY(testX, testY - 1);
// x-1, y-1
//maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset - 4);
// x0, y-1
maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + 0);
// x1, y-1
//maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + 4);
// x-1, y0
maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + sourceStrideInBytes - 4);
// x0, y0
maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + sourceStrideInBytes + 0);
// x+1, y0
maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + sourceStrideInBytes + 4);
// x-1, y+1
//maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + sourceStrideInBytes * 2 - 4);
// x0, y+1
maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + sourceStrideInBytes * 2 + 0);
// x+1, y+1
//maxColor = MaxColor(sourceBuffer, maxColor, sourceOffset + sourceStrideInBytes * 2 + 4);
int destOffset = dest.GetBufferOffsetXY(testX, testY);
destBuffer[destOffset + 2] = maxColor.red;
destBuffer[destOffset + 1] = maxColor.green;
destBuffer[destOffset + 0] = maxColor.blue;
destBuffer[destOffset + 3] = 255;
}
}
}
void LinearFill(int x, int y)
{
int bytesPerPixel = destImage.GetBytesBetweenPixelsInclusive();
int imageWidth = destImage.Width;
int leftFillX = x;
int bufferOffset = destImage.GetBufferOffsetXY(x, y);
int pixelOffset = (imageWidth * y) + x;
while (true)
{
fillRule.SetPixel(destBuffer, bufferOffset);
pixelsChecked[pixelOffset] = true;
leftFillX--;
pixelOffset--;
bufferOffset -= bytesPerPixel;
if (leftFillX <= 0 || (pixelsChecked[pixelOffset]) || !fillRule.CheckPixel(destBuffer, bufferOffset))
{
break;
}
}
leftFillX++;
int rightFillX = x;
bufferOffset = destImage.GetBufferOffsetXY(x, y);
pixelOffset = (imageWidth * y) + x;
while (true)
{
fillRule.SetPixel(destBuffer, bufferOffset);
pixelsChecked[pixelOffset] = true;
rightFillX++;
pixelOffset++;
bufferOffset += bytesPerPixel;
if (rightFillX >= imageWidth || pixelsChecked[pixelOffset] || !fillRule.CheckPixel(destBuffer, bufferOffset))
{
break;
}
}
rightFillX--;
ranges.Enqueue(new Range(leftFillX, rightFillX, y));
}
public override void generate(RGBA_Bytes[] span, int spanIndex, int x, int y, int len)
{
ImageBuffer SourceRenderingBuffer = (ImageBuffer)GetImageBufferAccessor().SourceImage;
int bytesBetweenPixelsInclusive = SourceRenderingBuffer.GetBytesBetweenPixelsInclusive();
if (SourceRenderingBuffer.BitDepth != 8)
{
throw new NotSupportedException("The source is expected to be 32 bit.");
}
ISpanInterpolator spanInterpolator = interpolator();
spanInterpolator.begin(x + filter_dx_dbl(), y + filter_dy_dbl(), len);
int x_hr;
int y_hr;
spanInterpolator.coordinates(out x_hr, out y_hr);
int x_lr = x_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int y_lr = y_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int bufferIndex;
bufferIndex = SourceRenderingBuffer.GetBufferOffsetXY(x_lr, y_lr);
byte[] fg_ptr = SourceRenderingBuffer.GetBuffer();
#if USE_UNSAFE_CODE
unsafe
{
fixed(byte *pSource = fg_ptr)
{
do
{
span[spanIndex].red = pSource[bufferIndex];
span[spanIndex].green = pSource[bufferIndex];
span[spanIndex].blue = pSource[bufferIndex];
span[spanIndex].alpha = 255;
spanIndex++;
bufferIndex += bytesBetweenPixelsInclusive;
} while (--len != 0);
}
}
#else
do
{
throw new Exception("this code is for 32 bit");
RGBA_Bytes color;
color.blue = fg_ptr[bufferIndex++];
color.green = fg_ptr[bufferIndex++];
color.red = fg_ptr[bufferIndex++];
color.alpha = fg_ptr[bufferIndex++];
span[spanIndex++] = color;
} while (--len != 0);
#endif
}
public override void generate(Color[] span, int spanIndex, int x, int y, int len)
{
ImageBuffer SourceRenderingBuffer = (ImageBuffer)GetImageBufferAccessor().SourceImage;
if (SourceRenderingBuffer.BitDepth != 24)
{
throw new NotSupportedException("The source is expected to be 32 bit.");
}
ISpanInterpolator spanInterpolator = interpolator();
spanInterpolator.begin(x + filter_dx_dbl(), y + filter_dy_dbl(), len);
int x_hr;
int y_hr;
spanInterpolator.coordinates(out x_hr, out y_hr);
int x_lr = x_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int y_lr = y_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int bufferIndex;
bufferIndex = SourceRenderingBuffer.GetBufferOffsetXY(x_lr, y_lr);
byte[] fg_ptr = SourceRenderingBuffer.GetBuffer();
#if USE_UNSAFE_CODE
unsafe
{
fixed(byte *pSource = fg_ptr)
{
do
{
span[spanIndex++] = *(RGBA_Bytes *)&(pSource[bufferIndex]);
bufferIndex += 4;
} while (--len != 0);
}
}
#else
Color color = Color.White;
do
{
color.blue = fg_ptr[bufferIndex++];
color.green = fg_ptr[bufferIndex++];
color.red = fg_ptr[bufferIndex++];
span[spanIndex++] = color;
} while (--len != 0);
#endif
}
private bool IsCollision(Vector2D newPosition)
{
int offset;
byte[] buffer = levelMap.GetBuffer(out offset);
int xOnMap = ((int)(newPosition.x + .5)) / 16;
int yOnMap = ((int)(newPosition.y + .5)) / 16;
offset = levelMap.GetBufferOffsetXY(xOnMap, yOnMap);
if (buffer[offset] == 0 ||
!hasKey && buffer[offset] == 1)
{
return(true);
}
return(false);
}
public static void DoDilate3x3Binary(ImageBuffer source, ImageBuffer dest, int threshold)
{
if (source.BitDepth != 32 || dest.BitDepth != 32)
{
throw new NotImplementedException("We only work with 32 bit at the moment.");
}
if (source.Width != dest.Width || source.Height != dest.Height)
{
throw new NotImplementedException("Source and Dest have to be the same size");
}
int height = source.Height;
int width = source.Width;
int sourceStrideInBytes = source.StrideInBytes();
int destStrideInBytes = dest.StrideInBytes();
byte[] sourceBuffer = source.GetBuffer();
byte[] destBuffer = dest.GetBuffer();
for (int testY = 1; testY < height - 1; testY++)
{
for (int testX = 1; testX < width - 1; testX++)
{
for (int sourceY = -1; sourceY <= 1; sourceY++)
{
for (int sourceX = -1; sourceX <= 1; sourceX++)
{
int sourceOffset = source.GetBufferOffsetXY(testX + sourceX, testY + sourceY);
if (sourceBuffer[sourceOffset] > threshold)
{
int destOffset = dest.GetBufferOffsetXY(testX, testY);
destBuffer[destOffset++] = 255;
destBuffer[destOffset++] = 255;
destBuffer[destOffset++] = 255;
destBuffer[destOffset++] = 255;
}
}
}
}
}
}
// Create
//--------------------------------------------------------------------
public void create(IImageByte src)
{
// we are going to create a dilated image for filtering
// we add m_dilation pixels to every side of the image and then copy the image in the x
// direction into each end so that we can sample into this image to get filtering on x repeating
// if the original image look like this
//
// 123456
//
// the new image would look like this
//
// 0000000000
// 0000000000
// 5612345612
// 0000000000
// 0000000000
m_height = (int)agg_basics.uceil(src.Height);
m_width = (int)agg_basics.uceil(src.Width);
m_width_hr = (int)agg_basics.uround(src.Width * LineAABasics.line_subpixel_scale);
m_half_height_hr = (int)agg_basics.uround(src.Height * LineAABasics.line_subpixel_scale / 2);
m_offset_y_hr = m_dilation_hr + m_half_height_hr - LineAABasics.line_subpixel_scale / 2;
m_half_height_hr += LineAABasics.line_subpixel_scale / 2;
int bufferWidth = m_width + m_dilation * 2;
int bufferHeight = m_height + m_dilation * 2;
int bytesPerPixel = src.BitDepth / 8;
int NewSizeInBytes = bufferWidth * bufferHeight * bytesPerPixel;
if (m_DataSizeInBytes < NewSizeInBytes)
{
m_DataSizeInBytes = NewSizeInBytes;
m_data = new byte[m_DataSizeInBytes];
}
m_buf.AttachBuffer(m_data, 0, bufferWidth, bufferHeight, bufferWidth * bytesPerPixel, src.BitDepth, bytesPerPixel);
byte[] destBuffer = m_buf.GetBuffer();
byte[] sourceBuffer = src.GetBuffer();
// copy the image into the middle of the dest
for (int y = 0; y < m_height; y++)
{
for (int x = 0; x < m_width; x++)
{
int sourceOffset = src.GetBufferOffsetXY(x, y);
int destOffset = m_buf.GetBufferOffsetXY(m_dilation, y + m_dilation);
for (int channel = 0; channel < bytesPerPixel; channel++)
{
destBuffer[destOffset++] = sourceBuffer[sourceOffset++];
}
}
}
// copy the first two pixels form the end into the beginning and from the beginning into the end
for (int y = 0; y < m_height; y++)
{
int s1Offset = src.GetBufferOffsetXY(0, y);
int d1Offset = m_buf.GetBufferOffsetXY(m_dilation + m_width, y);
int s2Offset = src.GetBufferOffsetXY(m_width - m_dilation, y);
int d2Offset = m_buf.GetBufferOffsetXY(0, y);
for (int x = 0; x < m_dilation; x++)
{
for (int channel = 0; channel < bytesPerPixel; channel++)
{
destBuffer[d1Offset++] = sourceBuffer[s1Offset++];
destBuffer[d2Offset++] = sourceBuffer[s2Offset++];
}
}
}
}
public static bool ConvertBitmapToImage(ImageBuffer destImage, Bitmap bitmap)
{
if (bitmap != null)
{
switch (bitmap.PixelFormat)
{
case System.Drawing.Imaging.PixelFormat.Format32bppArgb:
{
destImage.Allocate(bitmap.Width, bitmap.Height, bitmap.Width * 4, 32);
if (destImage.GetRecieveBlender() == null)
{
destImage.SetRecieveBlender(new BlenderBGRA());
}
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmap.PixelFormat);
int sourceIndex = 0;
int destIndex = 0;
unsafe
{
byte[] destBuffer = destImage.GetBuffer(out int offset);
byte * pSourceBuffer = (byte *)bitmapData.Scan0;
for (int y = 0; y < destImage.Height; y++)
{
destIndex = destImage.GetBufferOffsetXY(0, destImage.Height - 1 - y);
for (int x = 0; x < destImage.Width; x++)
{
#if true
destBuffer[destIndex++] = pSourceBuffer[sourceIndex++];
destBuffer[destIndex++] = pSourceBuffer[sourceIndex++];
destBuffer[destIndex++] = pSourceBuffer[sourceIndex++];
destBuffer[destIndex++] = pSourceBuffer[sourceIndex++];
#else
Color notPreMultiplied = new Color(pSourceBuffer[sourceIndex + 0], pSourceBuffer[sourceIndex + 1], pSourceBuffer[sourceIndex + 2], pSourceBuffer[sourceIndex + 3]);
sourceIndex += 4;
Color preMultiplied = notPreMultiplied.ToColorF().premultiply().ToColor();
destBuffer[destIndex++] = preMultiplied.blue;
destBuffer[destIndex++] = preMultiplied.green;
destBuffer[destIndex++] = preMultiplied.red;
destBuffer[destIndex++] = preMultiplied.alpha;
#endif
}
}
}
bitmap.UnlockBits(bitmapData);
return(true);
}
case System.Drawing.Imaging.PixelFormat.Format24bppRgb:
{
destImage.Allocate(bitmap.Width, bitmap.Height, bitmap.Width * 4, 32);
if (destImage.GetRecieveBlender() == null)
{
destImage.SetRecieveBlender(new BlenderBGRA());
}
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmap.PixelFormat);
int sourceIndex = 0;
int destIndex = 0;
unsafe
{
byte[] destBuffer = destImage.GetBuffer(out int offset);
byte * pSourceBuffer = (byte *)bitmapData.Scan0;
for (int y = 0; y < destImage.Height; y++)
{
sourceIndex = y * bitmapData.Stride;
destIndex = destImage.GetBufferOffsetXY(0, destImage.Height - 1 - y);
for (int x = 0; x < destImage.Width; x++)
{
destBuffer[destIndex++] = pSourceBuffer[sourceIndex++];
destBuffer[destIndex++] = pSourceBuffer[sourceIndex++];
destBuffer[destIndex++] = pSourceBuffer[sourceIndex++];
destBuffer[destIndex++] = 255;
}
}
}
bitmap.UnlockBits(bitmapData);
return(true);
}
case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
{
Copy8BitDataToImage(destImage, bitmap);
return(true);
}
default:
// let this code fall through and return false
break;
}
}
return(false);
}
void CalculateSumResponseAtAllPixels(ImageBuffer imageBuffer, int totalResponseThreshold)
{
validResponsesBotomToTopList.Clear();
if (imageBuffer.GetBytesBetweenPixelsInclusive() != 1)
{
throw new NotImplementedException("We only process gray scale images that are packed");
}
int width = imageBuffer.Width;
int height = imageBuffer.Height;
byte[] buffer = imageBuffer.GetBuffer();
for (int y = trimPixels; y < height - trimPixels; y++)
{
int byteOffset = imageBuffer.GetBufferOffsetXY(trimPixels, y);
ValidResponseData[] totalResponseRow = allResponsesGrid.GetRow(y);
for (int x = trimPixels; x < width - trimPixels; x++)
{
int sumResponse = 0;
for (int angleToCheckIndex = 0; angleToCheckIndex < 4; angleToCheckIndex++)
{
int sum =
(buffer[byteOffset + byteOffsetToPixel[angleToCheckIndex]] + buffer[byteOffset + byteOffsetToPixel[angleToCheckIndex + 8]])
-
(buffer[byteOffset + byteOffsetToPixel[angleToCheckIndex + 4]] + buffer[byteOffset + byteOffsetToPixel[angleToCheckIndex + 12]]);
int absSum = Math.Abs(sum);
sumResponse += absSum;
}
int neighborMeanTotal = 0;
int diffResponse = 0;
for (int diffCheck = 0; diffCheck < 8; diffCheck++)
{
int testValue = buffer[byteOffset + byteOffsetToPixel[diffCheck]];
int oppositeValue = buffer[byteOffset + byteOffsetToPixel[diffCheck + 8]];
diffResponse += Math.Abs(testValue - oppositeValue);
neighborMeanTotal += testValue + oppositeValue;
}
int neighborMean = (neighborMeanTotal + 8) / 16;
int centerMeanTotal = buffer[byteOffset - 1] + buffer[byteOffset + 1] + buffer[byteOffset - width] + buffer[byteOffset - width];
int centerMean = (centerMeanTotal + 2) / 4;
int absMeanResponse = Math.Abs(neighborMean - centerMean);
ValidResponseData newResponse = new ValidResponseData();
int totalResponse = sumResponse - diffResponse - absMeanResponse;
if (totalResponse >= totalResponseThreshold)
{
newResponse.totalResponse = totalResponse;
newResponse.position = new Vector2(x, y);
newResponse.originalIndex = validResponsesBotomToTopList.Count;
// we are scanning pixels bottom to top so they go in the list bottom to top
validResponsesBotomToTopList.Add(newResponse);
}
totalResponseRow[x] = newResponse;
byteOffset++;
}
}
}
public override void OnDraw(RendererBase rendererToDrawWith)
{
ImageBuffer levelMap = playfield.LevelMap;
int offset;
byte[] buffer = levelMap.GetBuffer(out offset);
if (!haveDrawnWalls)
{
RendererBase backgroundRenderer = BackgroundImage.NewRenderer();
rect_i boundsI = BackgroundImage.GetBoundingRect();
rect_d bounds = new rect_d(boundsI.Left, boundsI.Bottom, boundsI.Right, boundsI.Top);
backgroundRenderer.SetClippingRect(bounds);
ImageSequence wallTileSequence = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "WallTile");
for (int y = 0; y < levelMap.Height(); y++)
{
for (int x = 0; x < levelMap.Width(); x++)
{
if (buffer[levelMap.GetBufferOffsetXY(x, y)] == 0)
{
int index = 0;
// what type of wall
if (x < levelMap.Width() - 1 &&
buffer[levelMap.GetBufferOffsetXY(x + 1, y + 0)] == 0)
{
index |= 8;
}
if (y < levelMap.Height() - 1 &&
buffer[levelMap.GetBufferOffsetXY(x + 0, y + 1)] == 0)
{
index |= 4;
}
if (x > 0 &&
buffer[levelMap.GetBufferOffsetXY(x - 1, y + 0)] == 0)
{
index |= 2;
}
if (y > 0 &&
buffer[levelMap.GetBufferOffsetXY(x + 0, y - 1)] == 0)
{
index |= 1;
}
backgroundRenderer.Render(wallTileSequence.GetImageByIndex(index), x * 16, y * 16);
}
}
}
haveDrawnWalls = true;
}
//for (int i = 0; i < 1; i++)
for (int i = 0; i < numPlayers; i++)
{
playerViews[i].SetRendererPreDraw(BackgroundImage, rendererToDrawWith, playfield.PlayerList[i]);
rendererToDrawWith.Render(BackgroundImage, 0, 0);
foreach (SequenceEntity aSequenceEntity in playfield.SequenceEntityList)
{
aSequenceEntity.Draw(rendererToDrawWith);
}
foreach (Player aPlayer in playfield.PlayerList)
{
aPlayer.Draw(rendererToDrawWith);
}
playfield.sword.Draw(rendererToDrawWith);
playfield.key.Draw(rendererToDrawWith);
playfield.shield.Draw(rendererToDrawWith);
playerViews[i].SetRendererPostDraw(rendererToDrawWith);
}
ImageSequence hud = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), (playfield.PlayerList.Count).ToString() + "PlayerHUD");
rendererToDrawWith.Render(hud.GetImageByIndex(0), 400, 300);
foreach (Player aPlayer in playfield.PlayerList)
{
aPlayer.DrawScore(rendererToDrawWith);
}
rendererToDrawWith.Line(0.5, 300.5, 800.5, 300.5, new RGBA_Bytes(255, 20, 20));
rendererToDrawWith.Line(400.5, 0.5, 400.5, 600.5, new RGBA_Bytes(255, 20, 20));
base.OnDraw(rendererToDrawWith);
}
public static void DoErode3x3Binary(ImageBuffer source, ImageBuffer dest, int threshold)
{
if (source.Width != dest.Width ||
source.Height != dest.Height ||
source.StrideInBytes() != dest.StrideInBytes())
{
throw new NotImplementedException("Source and Dest have to be the same size");
}
switch (source.BitDepth)
{
case 8:
{
int height = source.Height;
int width = source.Width;
int strideInBytes = source.StrideInBytes();
byte[] sourceBuffer = source.GetBuffer();
byte[] destBuffer = dest.GetBuffer();
System.Threading.Tasks.Parallel.For(1, height, y =>
//for (int y = 1; y < height - 1; y++)
{
int rowOffset = source.GetBufferOffsetY(y);
for (int x = 1; x < width - 1; x++)
{
int bufferOffset = rowOffset + x;
// make sure it is set to 1 if we don't change it to 0
destBuffer[bufferOffset] = 255;
// do the upper left
int checkOffset = bufferOffset - strideInBytes - 1;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the upper center
checkOffset = bufferOffset - strideInBytes + 0;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the upper right
checkOffset = bufferOffset - strideInBytes + 1;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the center left
checkOffset = bufferOffset + strideInBytes - 1;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the center center
checkOffset = bufferOffset + strideInBytes + 0;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the lower right
checkOffset = bufferOffset + strideInBytes + 1;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the lower left
checkOffset = bufferOffset + strideInBytes - 1;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the lower center
checkOffset = bufferOffset + strideInBytes + 0;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
// do the lower right
checkOffset = bufferOffset + strideInBytes + 1;
if (sourceBuffer[checkOffset] < threshold)
{
destBuffer[bufferOffset] = 0;
continue;
}
}
});
}
break;
case 32:
{
int height = source.Height;
int width = source.Width;
int sourceStrideInBytes = source.StrideInBytes();
int destStrideInBytes = dest.StrideInBytes();
byte[] sourceBuffer = source.GetBuffer();
byte[] destBuffer = dest.GetBuffer();
for (int destY = 1; destY < height - 1; destY++)
{
for (int destX = 1; destX < width - 1; destX++)
{
for (int sourceY = -1; sourceY <= 1; sourceY++)
{
for (int sourceX = -1; sourceX <= 1; sourceX++)
{
int sourceOffset = source.GetBufferOffsetXY(destX + sourceX, destY + sourceY);
if (sourceBuffer[sourceOffset] < threshold)
{
int destOffset = dest.GetBufferOffsetXY(destX, destY);
destBuffer[destOffset++] = 0;
destBuffer[destOffset++] = 0;
destBuffer[destOffset++] = 0;
destBuffer[destOffset++] = 255;
}
}
}
}
}
}
break;
default:
throw new NotImplementedException();
}
}
public void Fill(ImageBuffer bufferToFillOn, int x, int y)
{
unchecked // this way we can overflow the uint on negative and get a big number
{
if ((uint)x > bufferToFillOn.Width || (uint)y > bufferToFillOn.Height)
{
return;
}
}
destImage = bufferToFillOn;
imageStride = destImage.StrideInBytes();
destBuffer = destImage.GetBuffer();
int imageWidth = destImage.Width;
int imageHeight = destImage.Height;
pixelsChecked = new bool[destImage.Width * destImage.Height];
int startColorBufferOffset = destImage.GetBufferOffsetXY(x, y);
fillRule.SetStartColor(new Color(destImage.GetBuffer()[startColorBufferOffset + 2], destImage.GetBuffer()[startColorBufferOffset + 1], destImage.GetBuffer()[startColorBufferOffset]));
LinearFill(x, y);
while (ranges.Count > 0)
{
Range range = ranges.Dequeue();
int downY = range.y - 1;
int upY = range.y + 1;
int downPixelOffset = (imageWidth * (range.y - 1)) + range.startX;
int upPixelOffset = (imageWidth * (range.y + 1)) + range.startX;
for (int rangeX = range.startX; rangeX <= range.endX; rangeX++)
{
if (range.y > 0)
{
if (!pixelsChecked[downPixelOffset])
{
int bufferOffset = destImage.GetBufferOffsetXY(rangeX, downY);
if (fillRule.CheckPixel(destBuffer, bufferOffset))
{
LinearFill(rangeX, downY);
}
}
}
if (range.y < (imageHeight - 1))
{
if (!pixelsChecked[upPixelOffset])
{
int bufferOffset = destImage.GetBufferOffsetXY(rangeX, upY);
if (fillRule.CheckPixel(destBuffer, bufferOffset))
{
LinearFill(rangeX, upY);
}
}
}
upPixelOffset++;
downPixelOffset++;
}
}
}
public override void generate(RGBA_Bytes[] span, int spanIndex, int x, int y, int len)
{
base.interpolator().begin(x + base.filter_dx_dbl(), y + base.filter_dy_dbl(), len);
ImageBuffer SourceRenderingBuffer = (ImageBuffer)base.GetImageBufferAccessor().SourceImage;
ISpanInterpolator spanInterpolator = base.interpolator();
int bufferIndex;
byte[] fg_ptr = SourceRenderingBuffer.GetBuffer(out bufferIndex);
unchecked
{
do
{
int tempR;
int tempG;
int tempB;
int x_hr;
int y_hr;
spanInterpolator.coordinates(out x_hr, out y_hr);
x_hr -= base.filter_dx_int();
y_hr -= base.filter_dy_int();
int x_lr = x_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int y_lr = y_hr >> (int)image_subpixel_scale_e.image_subpixel_shift;
int weight;
tempR =
tempG =
tempB = (int)image_subpixel_scale_e.image_subpixel_scale * (int)image_subpixel_scale_e.image_subpixel_scale / 2;
x_hr &= (int)image_subpixel_scale_e.image_subpixel_mask;
y_hr &= (int)image_subpixel_scale_e.image_subpixel_mask;
bufferIndex = SourceRenderingBuffer.GetBufferOffsetXY(x_lr, y_lr);
weight = (((int)image_subpixel_scale_e.image_subpixel_scale - x_hr) *
((int)image_subpixel_scale_e.image_subpixel_scale - y_hr));
tempR += weight * fg_ptr[bufferIndex + ImageBuffer.OrderR];
tempG += weight * fg_ptr[bufferIndex + ImageBuffer.OrderG];
tempB += weight * fg_ptr[bufferIndex + ImageBuffer.OrderB];
bufferIndex += 3;
weight = (x_hr * ((int)image_subpixel_scale_e.image_subpixel_scale - y_hr));
tempR += weight * fg_ptr[bufferIndex + ImageBuffer.OrderR];
tempG += weight * fg_ptr[bufferIndex + ImageBuffer.OrderG];
tempB += weight * fg_ptr[bufferIndex + ImageBuffer.OrderB];
y_lr++;
bufferIndex = SourceRenderingBuffer.GetBufferOffsetXY(x_lr, y_lr);
weight = (((int)image_subpixel_scale_e.image_subpixel_scale - x_hr) * y_hr);
tempR += weight * fg_ptr[bufferIndex + ImageBuffer.OrderR];
tempG += weight * fg_ptr[bufferIndex + ImageBuffer.OrderG];
tempB += weight * fg_ptr[bufferIndex + ImageBuffer.OrderB];
bufferIndex += 3;
weight = (x_hr * y_hr);
tempR += weight * fg_ptr[bufferIndex + ImageBuffer.OrderR];
tempG += weight * fg_ptr[bufferIndex + ImageBuffer.OrderG];
tempB += weight * fg_ptr[bufferIndex + ImageBuffer.OrderB];
tempR >>= (int)image_subpixel_scale_e.image_subpixel_shift * 2;
tempG >>= (int)image_subpixel_scale_e.image_subpixel_shift * 2;
tempB >>= (int)image_subpixel_scale_e.image_subpixel_shift * 2;
RGBA_Bytes color;
color.red = (byte)tempR;
color.green = (byte)tempG;
color.blue = (byte)tempB;
color.alpha = 255;
span[spanIndex] = color;
spanIndex++;
spanInterpolator.Next();
} while (--len != 0);
}
}
void CalculateOrientationAtAllFeatures(ImageBuffer imageBuffer)
{
byte[] buffer = imageBuffer.GetBuffer();
foreach (ValidResponseData validResponse in validResponsesBotomToTopList)
{
if (validResponse.totalResponse <= 0)
{
throw new Exception("You should not have added a response below the threashold.");
}
int maxAbsSum = 0;
int byteOffset = imageBuffer.GetBufferOffsetXY((int)validResponse.position.x, (int)validResponse.position.y);
for (int angleToCheckIndex = 0; angleToCheckIndex < 4; angleToCheckIndex++)
{
int sum = 0;
for (int extraAngleToCheckIndex = angleToCheckIndex - 1; extraAngleToCheckIndex <= angleToCheckIndex + 1; extraAngleToCheckIndex++)
{
int check0 = extraAngleToCheckIndex; if (check0 < 0)
{
check0 += 16;
}
if (check0 > 15)
{
check0 -= 16;
}
int check1 = extraAngleToCheckIndex + 8; if (check1 < 0)
{
check1 += 16;
}
if (check1 > 15)
{
check1 -= 16;
}
int check2 = extraAngleToCheckIndex + 4; if (check2 < 0)
{
check2 += 16;
}
if (check2 > 15)
{
check2 -= 16;
}
int check3 = extraAngleToCheckIndex + 12; if (check3 < 0)
{
check3 += 16;
}
if (check3 > 15)
{
check3 -= 16;
}
sum +=
(buffer[byteOffset + byteOffsetToPixel[check0]] + buffer[byteOffset + byteOffsetToPixel[check1]])
-
(buffer[byteOffset + byteOffsetToPixel[check2]] + buffer[byteOffset + byteOffsetToPixel[check3]]);
}
int absSum = Math.Abs(sum);
if (absSum > maxAbsSum)
{
maxAbsSum = absSum;
if (sum > 0)
{
validResponse.orientation = angleToCheckIndex;
}
else
{
validResponse.orientation = (4 + angleToCheckIndex);
}
}
}
}
}
