public void DrawToUI(int[] pixelData, int x, int y, int width, int height, bool flipH = false, bool flipV = false, int colorOffset = 0)
{
// Update pixel data
y = _height - height - y;
// if (pixelData != null)
// {
if (flipH || flipV)
{
SpriteChipUtil.FlipSpriteData(ref pixelData, width, height, flipH, flipV);
}
// TODO Need to make sure we offset colors if a new offset is set
if (colorOffset > 0)
{
var total = pixelData.Length;
for (int i = 0; i < total; i++)
{
pixelData[i] += colorOffset;
}
}
uiLayer.SetPixels(x, y, width, height, pixelData);
}
public virtual void PrepareSprites()
{
cps = spriteChip.colorsPerSprite;
colorData = chips.GetChip(ColorMapParser.chipName, false) is ColorChip colorMapChip
? colorMapChip.colors
: chips.colorChip.colors;
maskColor = ColorUtils.HexToColor(chips.colorChip.maskColor);
maxSprites = SpriteChipUtil.CalculateTotalSprites(spriteChip.textureWidth, spriteChip.textureHeight,
spriteWidth, spriteHeight);
// Create tmp arrays for color and reference data
totalPixels = spriteChip.width * spriteChip.height;
tmpPixels = new Color[totalPixels];
spriteData = new int[totalPixels];
// Keep track of number of sprites added
spritesAdded = 0;
//TODO this should be set by the parser
srcColors = imageParser.colorPixels; //data.Select(c => new ColorAdapter(c) as Color).ToArray();
currentStep++;
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="colorOffset"></param>
public void DrawSprite(int id, int x, int y, int colorOffset = 0)
{
// This only works when the canvas has a reference to the gameChip
if (gameChip == null)
{
return;
}
var pixelData = gameChip.Sprite(id);
if (colorOffset > 0)
{
var total = pixelData.Length;
for (int i = 0; i < total; i++)
{
pixelData[i] = pixelData[i] + colorOffset;
}
}
// Canvas is reversed, so flip the pixel data
SpriteChipUtil.FlipSpriteData(ref pixelData, spriteSize.x, spriteSize.y);
SetPixels(x, y, spriteSize.x, spriteSize.y, pixelData);
}
public override void PrepareSprites()
{
// Get the total number of sprites
totalSpritesInTexture = SpriteChipUtil.CalculateTotalSprites(tex.width, tex.height, spriteChip.width, spriteChip.height);
ids = Enumerable.Repeat(-1, totalSpritesInTexture).ToArray();
base.PrepareSprites();
}
/// <summary>
/// Updates the sprite data at a given position in the
/// <see cref="texture" /> data.
/// </summary>
/// <param name="index"></param>
/// <param name="pixels"></param>
public void UpdateSpriteAt(int index, int[] pixels)
{
if (index < 0)
{
return;
}
SpriteChipUtil.AddSpriteToTextureData(index, pixels, _texture, width, height);
CacheSprite(index, pixels);
}
/// <summary>
/// This caches a sprite for easier look up and duplicate detection.
/// Each sprite is cached as a string.
/// </summary>
/// <param name="index">
/// Index where the sprite's cached value should be stored in the
/// <see cref="cache" /> array.
/// </param>
/// <param name="data">
/// An array of ints that represents the sprite's color data.
/// </param>
private void CacheSprite(int index, int[] data)
{
cache[index] = SpriteChipUtil.SpriteDataToString(data);
var totalPixels = width * height;
var tmpPixels = new int[totalPixels];
Array.Copy(data, tmpPixels, totalPixels);
pixelDataCache[index] = tmpPixels;
}
/// <summary>
/// Finds a sprite by looking it up against the cache. Returns -1 if no
/// sprite is found. This is used for insuring duplicate sprites aren't
/// added to the TextureData.
/// </summary>
/// <param name="pixels">
/// An array of ints representing the sprite's color data.
/// </param>
/// <returns>
/// </returns>
public int FindSprite(int[] pixels, bool emptyCheck = false)
{
if (emptyCheck)
{
if (IsEmpty(pixels))
{
return(-1);
}
}
var sprite = SpriteChipUtil.SpriteDataToString(pixels);
return(Array.IndexOf(cache, sprite));
}
public virtual void PrepareSprites()
{
cps = spriteChip.colorsPerSprite;
totalSprites = image.TotalSprites;
maxSprites = SpriteChipUtil.CalculateTotalSprites(spriteChip.textureWidth, spriteChip.textureHeight,
spriteWidth, spriteHeight);
// // Keep track of number of sprites added
spritesAdded = 0;
StepCompleted();
}
// TODO this should be a step in the exporter
public void ConfigurePixelData()
{
var spriteChip = engine.spriteChip;
var totalSprite = spriteChip.totalSprites - 1;
var width = spriteChip.textureWidth;
var height = spriteChip.textureHeight;
var sWidth = spriteChip.width;
var sHeight = spriteChip.height;
var emptyCount = 0;
var tmpData = new int[sWidth * sHeight];
var cols = (int)Math.Floor((float)width / sWidth);
for (int i = totalSprite; i > -1; i--)
{
spriteChip.ReadSpriteAt(i, tmpData);
if (spriteChip.IsEmpty(tmpData))
{
emptyCount++;
}
if (i % cols == 0)
{
if (emptyCount == cols)
{
height -= sHeight;
}
emptyCount = 0;
}
}
var pixelData = new int[width * height];
spriteChip.texture.CopyPixels(ref pixelData, 0, 0, width, height);
SpriteChipUtil.FlipSpriteData(ref pixelData, width, height, false, true);
var colorMapChip = engine.chipManager.GetChip(ColorMapParser.chipName, false) as ColorChip;
var colors = colorMapChip == null ? engine.colorChip.colors : colorMapChip.colors;
exporter = new PixelDataExporter(fullFileName, pixelData, width, height, colors, textureFactory);
}
/// <summary>
/// Returns an array of ints that represent a sprite. Each
/// int should be mapped to a color
/// <paramref name="index" /> to display in the renderer.
/// </summary>
/// <param name="index">
/// Anint representing the location in memory of the
/// sprite.
/// </param>
/// <param name="pixelData"></param>
/// <returns>
/// </returns>
public void ReadSpriteAt(int index, int[] pixelData)
{
// if (index > pixelDataCache.GetLength(0))
if (index == -1)
{
return;
}
// try
// {
var cachedSprite = pixelDataCache[index];
var totalSpritePixels = width * height;
if (cachedSprite == null)
{
var tmpPixelData = new int[totalSpritePixels];
SpriteChipUtil.CalculateSpritePos(index, _texture.width, _texture.height, width, height, out tmpX, out tmpY);
_texture.GetPixels(tmpX, tmpY, width, height, ref tmpPixelData);
pixelDataCache[index] = tmpPixelData;
cachedSprite = pixelDataCache[index];
}
// if(pixelData == null)
// Debug.Log("pixelData is null");
// Make sure that the pixelData array is the correct size.
if (pixelData.Length != cachedSprite.Length)
{
// Debug.Log("pixelData " + pixelData.Length + " cachedSprite " +cachedSprite.Length);
Array.Resize(ref pixelData, cachedSprite.Length);
}
// Copy the contents of the cached pixel data into the new array.
Array.Copy(cachedSprite, pixelData, totalSpritePixels);
// }
// catch (Exception e)
// {
// Debug.Log("Out of range" + pixelDataCache.GetLength(0) + " " + index);
// }
}
/// <summary>
/// Creates a new draw by copying the supplied pixel data over
/// to the Display's TextureData.
/// </summary>
/// <param name="pixelData"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="flipH"></param>
/// <param name="flipV"></param>
/// <param name="flipY"></param>
/// <param name="layerOrder"></param>
/// <param name="masked"></param>
/// <param name="colorOffset"></param>
public void NewDrawCall(int[] pixelData, int x, int y, int width, int height, bool flipH, bool flipV, bool flipY, int layerOrder = 0, bool masked = false, int colorOffset = 0)
{
var drawCalls = width / engine.spriteChip.width * (height / engine.spriteChip.height);
//currentSprites += drawCalls;
if (currentSprites + drawCalls > maxSpriteCount)
{
return;
}
currentSprites += drawCalls;
//TODO need to add in layer merge logic, -1 is behind, 0 is normal, 1 is above
//layerOrder = layerOrder.Clamp(-1, 1);
// flip y coordinate space
if (flipY)
{
y = _height - engine.spriteChip.height - y;
}
if (pixelData != null)
{
if (flipH || flipV)
{
SpriteChipUtil.FlipSpriteData(ref pixelData, width, height, flipH, flipV);
}
var draw = NextDrawRequest();
draw.x = x;
draw.y = y;
draw.width = width;
draw.height = height;
draw.pixelData = pixelData;
draw.order = layerOrder;
draw.colorOffset = colorOffset;
drawRequests.Add(draw);
//texturedata.MergePixels(x, y, width, height, pixelData);
}
}
public virtual void PrepareSprites()
{
cps = spriteChip.colorsPerSprite;
var colorMapChip = chips.chipManager.GetChip(ColorMapParser.chipName, false) as ColorChip;
colorData = colorMapChip != null ? colorMapChip.colors : chips.colorChip.colors;
maskColor = new ColorData(chips.colorChip.maskColor);
maxSprites = SpriteChipUtil.CalculateTotalSprites(spriteChip.textureWidth, spriteChip.textureHeight, sWidth, sHeight);
// Create tmp arrays for color and reference data
totalPixels = spriteChip.width * spriteChip.height;
tmpPixels = new IColor[totalPixels];
spriteData = new int[totalPixels];
// Keep track of number of sprites added
spritesAdded = 0;
currentStep++;
}
protected override void FlipPixels()
{
// TODO maybe the base class should just expect to have the pixel data so this doens't need to override it
SpriteChipUtil.FlipSpriteData(ref pixelData, width, height, false, true);
currentStep++;
}
protected virtual void FlipPixels()
{
pixelData = tmpTextureData.GetPixels();
SpriteChipUtil.FlipSpriteData(ref pixelData, width, height, false, true);
currentStep++;
}
