public CharsetEditor(StudioCore Core)
{
this.Core = Core;
DocumentInfo.Type = ProjectElement.ElementType.CHARACTER_SET;
DocumentInfo.UndoManager.MainForm = Core.MainForm;
m_IsSaveable = true;
InitializeComponent();
characterEditor.Core = Core;
GR.Image.DPIHandler.ResizeControlsForDPI(this);
characterEditor.UndoManager = DocumentInfo.UndoManager;
characterEditor.Core = Core;
for (int i = 0; i < 256; ++i)
{
PaletteManager.ApplyPalette(m_Charset.Characters[i].Tile.Image);
}
comboExportRange.Items.Add("All");
comboExportRange.Items.Add("Selection");
comboExportRange.Items.Add("Range");
comboExportRange.SelectedIndex = 0;
checkExportToDataIncludeRes.Checked = true;
checkExportToDataWrap.Checked = true;
CreateDefaultUppercaseCharset();
Modified = false;
}
public override bool HandleExport(ExportSpriteInfo Info, TextBox EditOutput, DocumentInfo DocInfo)
{
System.Windows.Forms.SaveFileDialog saveDlg = new System.Windows.Forms.SaveFileDialog();
saveDlg.Title = "Export Sprites to Image";
saveDlg.Filter = Core.MainForm.FilterString(RetroDevStudio.Types.Constants.FILEFILTER_IMAGE_FILES);
if (saveDlg.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return(false);
}
GR.Image.MemoryImage targetImg = new GR.Image.MemoryImage(Info.Project.Sprites[0].Tile.Width * 4, ((Info.Project.TotalNumberOfSprites + 3) / 4) * Info.Project.Sprites[0].Tile.Height, Info.Project.Sprites[0].Tile.Image.PixelFormat);
PaletteManager.ApplyPalette(targetImg);
List <int> exportIndices = Info.ExportIndices;
foreach (int i in exportIndices)
{
Info.Project.Sprites[i].Tile.Image.DrawTo(targetImg,
(i % 4) * Info.Project.Sprites[i].Tile.Width,
(i / 4) * Info.Project.Sprites[i].Tile.Height);
}
System.Drawing.Bitmap bmpTarget = targetImg.GetAsBitmap();
bmpTarget.Save(saveDlg.FileName, System.Drawing.Imaging.ImageFormat.Png);
return(true);
}
public SpritePadProject()
{
for (int i = 0; i < 256; ++i)
{
Sprites.Add(new SpriteData());
PaletteManager.ApplyPalette(Sprites[i].Image);
}
}
public SpriteProject()
{
Colors.Palette = PaletteManager.PaletteFromMachine(MachineType.C64);
Colors.Palettes.Add(Colors.Palette);
for (int i = 0; i < TotalNumberOfSprites; ++i)
{
Sprites.Add(new SpriteData(Colors));
PaletteManager.ApplyPalette(Sprites[i].Tile.Image);
}
}
public void PaintHexData(HexBox Box, Graphics graphics, long _startByte, long intern_endByte, Rectangle _recHex)
{
//graphics.FillRectangle( new SolidBrush( Color.Beige ), _recHex );
if (Box.BytesPerLine == 8)
{
int spriteSize = (int)(Box.CharSize.Height * 8) - 2;
ByteBuffer spriteData = new ByteBuffer(64);
int firstSprite = (int)(_startByte / 64);
int firstTrueByte = firstSprite * 64;
int firstLineOffset = (int)(_startByte - firstTrueByte) / 8;
int lastTrueByte = (int)(intern_endByte - _startByte) + firstTrueByte;
int lastSprite = (int)lastTrueByte / 64;
if (lastSprite * 64 > intern_endByte)
{
++lastSprite;
}
var oldClip = graphics.Clip;
graphics.SetClip(_recHex);
for (int j = firstSprite; j <= lastSprite; ++j)
{
for (int i = 0; i < 64; ++i)
{
spriteData.SetU8At(i, Box.ByteProvider.ReadByte(firstTrueByte + (j - firstSprite) * 64 + i));
}
using (GR.Image.FastImage spriteImage = new GR.Image.FastImage(24, 21, System.Drawing.Imaging.PixelFormat.Format8bppIndexed))
{
spriteImage.Box(0, 0, 24, 21, 1);
PaletteManager.ApplyPalette(spriteImage);
if (MultiColor)
{
SpriteDisplayer.DisplayMultiColorSprite(spriteData, ConstantData.Palette, 24, 21, BackgroundColor, MultiColor1, MultiColor2, CustomColor, spriteImage, 0, 0);
}
else
{
SpriteDisplayer.DisplayHiResSprite(spriteData, ConstantData.Palette, 24, 21, BackgroundColor, CustomColor, spriteImage, 0, 0);
}
int offsetY = (int)(Box.CharSize.Height * (j - firstSprite) * 8 + (Box.CharSize.Height * 8 - spriteSize) / 2) - (int)(Box.CharSize.Height * firstLineOffset);
using (System.Drawing.Image img = spriteImage.GetAsBitmap())
{
graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
graphics.DrawImage(img, new Rectangle(_recHex.Left, _recHex.Top + offsetY, spriteSize, spriteSize));
}
}
}
graphics.Clip = oldClip;
}
}
public GraphicScreenProject()
{
PaletteManager.ApplyPalette(Image);
for (int i = 0; i < 16; ++i)
{
ColorMapping.Add(i, new List <ColorMappingTarget> {
ColorMappingTarget.ANY
});
}
}
public GraphicScreenProject()
{
PaletteManager.ApplyPalette(Image);
for (int i = 0; i < 16; ++i)
{
ColorMapping.Add(i, new List <ColorMappingTarget> {
ColorMappingTarget.ANY
});
}
Colors.Palette = PaletteManager.PaletteFromMachine(MachineType.C64);
}
public void PaintHexData(HexBox Box, Graphics graphics, long _startByte, long intern_endByte, Rectangle _recHex)
{
//if ( Box.BytesPerLine == 8 )
{
var oldClip = graphics.Clip;
graphics.SetClip(_recHex);
GR.Image.FastImage charImage = new GR.Image.FastImage(8, 8, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
PaletteManager.ApplyPalette(charImage);
for (int i = 0; i < intern_endByte - _startByte; ++i)
{
byte character = Box.ByteProvider.ReadByte(_startByte + i);
int displayColor = 0;
int bgColor = 1;
if ((_startByte + i >= Box.SelectionStart) &&
(_startByte + i < Box.SelectionStart + Box.SelectionLength))
{
displayColor = 1;
bgColor = 14;
}
switch (Mode)
{
case PETSCIIDisplay.UPPER_CASE:
CharacterDisplayer.DisplayHiResChar(ConstantData.UpperCaseCharsetC64.SubBuffer(character * 8, 8),
ConstantData.Palette,
bgColor, displayColor,
charImage, 0, 0);
break;
case PETSCIIDisplay.LOWER_CASE:
CharacterDisplayer.DisplayHiResChar(ConstantData.LowerCaseCharsetC64.SubBuffer(character * 8, 8),
ConstantData.Palette,
bgColor, displayColor,
charImage, 0, 0);
break;
}
charImage.DrawToHDC(graphics.GetHdc(),
new Rectangle(_recHex.Left + (int)Box.CharSize.Width * (i % 8),
(int)(_recHex.Top + (i / 8) * (int)Box.CharSize.Height + (Box.CharSize.Height - Box.CharSize.Width) / 2),
(int)Box.CharSize.Width,
(int)Box.CharSize.Width));
graphics.ReleaseHdc();
}
charImage.Dispose();
graphics.Clip = oldClip;
}
}
public void PaintHexData(HexBox Box, Graphics graphics, long _startByte, long intern_endByte, Rectangle _recHex)
{
if (Box.BytesPerLine == 8)
{
var oldClip = graphics.Clip;
graphics.SetClip(_recHex);
int boxSize = (int)Box.CharSize.Height - 2;
ByteBuffer charData = new ByteBuffer(8);
for (int j = 0; j < (intern_endByte - _startByte) / 8; ++j)
{
for (int i = 0; i < 8; ++i)
{
charData.SetU8At(i, Box.ByteProvider.ReadByte(_startByte + j * 8 + i));
}
using (GR.Image.FastImage charImage = new GR.Image.FastImage(8, 8, System.Drawing.Imaging.PixelFormat.Format8bppIndexed))
{
PaletteManager.ApplyPalette(charImage);
switch (Mode)
{
case TextMode.COMMODORE_40_X_25_HIRES:
CharacterDisplayer.DisplayHiResChar(charData, ConstantData.Palette, BackgroundColor, CustomColor, charImage, 0, 0);
break;
case TextMode.COMMODORE_40_X_25_MULTICOLOR:
CharacterDisplayer.DisplayMultiColorChar(charData, ConstantData.Palette, BackgroundColor, CustomColor, MultiColor1, MultiColor2, charImage, 0, 0);
break;
case TextMode.COMMODORE_40_X_25_ECM:
// TODO - not correct
CharacterDisplayer.DisplayHiResChar(charData, ConstantData.Palette, BackgroundColor, CustomColor, charImage, 0, 0);
break;
default:
Debug.Log("PaintHexData: Missing mode displayer");
break;
}
charImage.DrawToHDC(graphics.GetHdc(),
new Rectangle(_recHex.Left, (int)(_recHex.Top + Box.CharSize.Height * j + (Box.CharSize.Height - boxSize) / 2), boxSize, boxSize));
graphics.ReleaseHdc();
}
}
graphics.Clip = oldClip;
}
}
public CharsetEditor(StudioCore Core)
{
this.Core = Core;
DocumentInfo.Type = ProjectElement.ElementType.CHARACTER_SET;
DocumentInfo.UndoManager.MainForm = Core.MainForm;
m_IsSaveable = true;
InitializeComponent();
characterEditor.Core = Core;
GR.Image.DPIHandler.ResizeControlsForDPI(this);
characterEditor.UndoManager = DocumentInfo.UndoManager;
characterEditor.Core = Core;
for (int i = 0; i < 256; ++i)
{
PaletteManager.ApplyPalette(m_Charset.Characters[i].Tile.Image);
}
comboExportRange.Items.Add("All");
comboExportRange.Items.Add("Selection");
comboExportRange.Items.Add("Range");
comboExportRange.SelectedIndex = 0;
comboExportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("as assembly", typeof(ExportCharsetAsAssembly)));
comboExportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("to binary file", typeof(ExportCharsetAsBinaryFile)));
comboExportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("to image file", typeof(ExportCharsetAsImageFile)));
comboExportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("to image (clipboard)", typeof(ExportCharsetAsImage)));
comboExportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("as BASIC DATA statements", typeof(ExportCharsetAsBASICData)));
comboExportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("as BASIC CHARDEF statements", typeof(ExportCharsetAsBASICChardef)));
comboExportMethod.SelectedIndex = 0;
m_DefaultOutputFont = editDataExport.Font;
comboImportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("from character set/binary file", typeof(ImportCharsetFromBinaryFile)));
comboImportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("from image file", typeof(ImportCharsetFromImageFile)));
comboImportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("from assembly", typeof(ImportCharsetFromASM)));
comboImportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("from BASIC DATA statements", typeof(ImportCharsetFromBASICDATA)));
comboImportMethod.Items.Add(new GR.Generic.Tupel <string, Type>("set default character sets", typeof(ImportCharsetFromDefault)));
comboImportMethod.SelectedIndex = 0;
CreateDefaultUppercaseCharset();
Modified = false;
}
public override bool HandleExport(ExportCharsetInfo Info, TextBox EditOutput, DocumentInfo DocInfo)
{
GR.Image.MemoryImage targetImg = new GR.Image.MemoryImage(128, 128, Info.Charset.Characters[0].Tile.Image.PixelFormat);
PaletteManager.ApplyPalette(targetImg);
List <int> exportIndices = Info.ExportIndices;
foreach (int i in exportIndices)
{
Info.Charset.Characters[i].Tile.Image.DrawTo(targetImg, (i % 16) * 8, (i / 16) * 8);
}
System.Drawing.Bitmap bmpTarget = targetImg.GetAsBitmap();
Clipboard.SetImage(bmpTarget);
bmpTarget.Dispose();
return(true);
}
public override bool HandleExport(ExportSpriteInfo Info, TextBox EditOutput, DocumentInfo DocInfo)
{
GR.Image.MemoryImage targetImg = new GR.Image.MemoryImage(Info.Project.Sprites[0].Tile.Width * 4, ((Info.Project.TotalNumberOfSprites + 3) / 4) * Info.Project.Sprites[0].Tile.Height, Info.Project.Sprites[0].Tile.Image.PixelFormat);
PaletteManager.ApplyPalette(targetImg);
List <int> exportIndices = Info.ExportIndices;
foreach (int i in exportIndices)
{
Info.Project.Sprites[i].Tile.Image.DrawTo(targetImg,
(i % 4) * Info.Project.Sprites[i].Tile.Width,
(i / 4) * Info.Project.Sprites[i].Tile.Height);
}
var bmpTarget = targetImg.GetAsBitmap();
Clipboard.SetImage(bmpTarget);
bmpTarget.Dispose();
return(true);
}
private void btnExportCharsetToImage_Click(object sender, EventArgs e)
{
System.Windows.Forms.SaveFileDialog saveDlg = new System.Windows.Forms.SaveFileDialog();
saveDlg.Title = "Export Characters to Image";
saveDlg.Filter = Core.MainForm.FilterString(C64Studio.Types.Constants.FILEFILTER_IMAGE_FILES);
if (saveDlg.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return;
}
GR.Image.MemoryImage targetImg = new GR.Image.MemoryImage(128, 128, m_Charset.Characters[0].Tile.Image.PixelFormat);
PaletteManager.ApplyPalette(targetImg);
List <int> exportIndices = ListOfExportIndices();
foreach (int i in exportIndices)
{
m_Charset.Characters[i].Tile.Image.DrawTo(targetImg, (i % 16) * 8, (i / 16) * 8);
}
System.Drawing.Bitmap bmpTarget = targetImg.GetAsBitmap();
bmpTarget.Save(saveDlg.FileName, System.Drawing.Imaging.ImageFormat.Png);
}
public static GR.Image.MemoryImage BitmapFromKoala(GR.Memory.ByteBuffer koala)
{
byte fullValue;
byte value;
byte currentColor;
int xCooBase = 0;
int yCooBase = 0;
GR.Image.MemoryImage Image = new GR.Image.MemoryImage(320, 200, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
// Set the palette to the C64 one
PaletteManager.ApplyPalette(Image);
if (koala.Length >= 10002)
{
// Last Byte is Background Color and global
Byte backgroundColor = koala.ByteAt(10002);
for (int y = 0; y < 1000; y++)
{
// koala has 3 colors which can be selected for ech "cell" (8x8 pixel)
byte lowerNibbleColor = (byte)(((((koala.ByteAt(y + 8002)) << 4) & 0xFF) >> 4));
byte upperNibbleColor = (byte)(koala.ByteAt(y + 8002) >> 4);
byte colorRamColor = koala.ByteAt(y + 9002);
for (int x = 0; x < 8; x++)
{
fullValue = koala.ByteAt((8 * y) + x + 2);
for (int z = 0; z < 4; z++)
{
value = (byte)(((fullValue << (z * 2)) & 0xFF) >> 6);
switch (value)
{
case 0:
currentColor = backgroundColor;
break;
case 1:
currentColor = upperNibbleColor;
break;
case 2:
currentColor = lowerNibbleColor;
break;
default:
currentColor = colorRamColor;
break;
}
Image.SetPixel(((xCooBase * 4) * 2 + (z * 2)), yCooBase * 8 + x, currentColor);
// koala is doublepixel, so we repeat it for the right neighbour
Image.SetPixel(((xCooBase * 4) * 2 + (z * 2) + 1), yCooBase * 8 + x, currentColor);
}
}
xCooBase++;
if (xCooBase == 40)
{
xCooBase = 0;
yCooBase++;
}
}
}
return(Image);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
SpriteLayers.Clear();
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
GR.Memory.ByteBuffer header = new GR.Memory.ByteBuffer();
if (memIn.ReadBlock(header, 9) != 9)
{
return(false);
}
if ((header.ByteAt(0) != 0x53) ||
(header.ByteAt(1) != 0x50) ||
(header.ByteAt(2) != 0x44))
{
// no SPD
return(false);
}
NumSprites = header.ByteAt(4) + 1;
int numAnims = header.ByteAt(5) + 1;
BackgroundColor = header.ByteAt(6);
MultiColor1 = header.ByteAt(7);
MultiColor2 = header.ByteAt(8);
Sprites = new List <SpriteData>();
GR.Memory.ByteBuffer tempData = new GR.Memory.ByteBuffer();
for (int i = 0; i < NumSprites; ++i)
{
Sprites.Add(new SpriteData());
PaletteManager.ApplyPalette(Sprites[i].Image);
tempData.Clear();
memIn.ReadBlock(tempData, 63);
tempData.CopyTo(Sprites[i].Data, 0, 63);
Sprites[i].Color = memIn.ReadUInt8();
Sprites[i].Multicolor = (((Sprites[i].Color) & 0x80) != 0);
Sprites[i].Color &= 0x0f;
}
if (numAnims > 0)
{
GR.Memory.ByteBuffer animFrom = new GR.Memory.ByteBuffer();
GR.Memory.ByteBuffer animTo = new GR.Memory.ByteBuffer();
GR.Memory.ByteBuffer animNumFrames = new GR.Memory.ByteBuffer();
GR.Memory.ByteBuffer animAttributes = new GR.Memory.ByteBuffer();
memIn.ReadBlock(animFrom, (uint)numAnims);
memIn.ReadBlock(animTo, (uint)numAnims);
memIn.ReadBlock(animNumFrames, (uint)numAnims);
memIn.ReadBlock(animAttributes, (uint)numAnims);
}
UsedSprites = (uint)NumSprites;
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
SpriteLayers.Clear();
Sprites.Clear();
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
uint Version = memIn.ReadUInt32();
if (Version == 2)
{
Colors.Palettes.Clear();
GR.IO.FileChunk chunkMain = new GR.IO.FileChunk();
while (chunkMain.ReadFromStream(memIn))
{
switch (chunkMain.Type)
{
case FileChunkConstants.SPRITESET_PROJECT:
{
var chunkReader = chunkMain.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(chunkReader))
{
var subChunkReader = subChunk.MemoryReader();
switch (subChunk.Type)
{
case FileChunkConstants.SPRITESET_INFO:
TotalNumberOfSprites = subChunkReader.ReadInt32();
Name = subChunkReader.ReadString();
ExportFilename = subChunkReader.ReadString();
ExportStartIndex = subChunkReader.ReadInt32();
ExportSpriteCount = subChunkReader.ReadInt32();
break;
case FileChunkConstants.MULTICOLOR_DATA:
Mode = (SpriteProjectMode)subChunkReader.ReadInt32();
Colors.BackgroundColor = subChunkReader.ReadInt32();
Colors.MultiColor1 = subChunkReader.ReadInt32();
Colors.MultiColor2 = subChunkReader.ReadInt32();
Colors.ActivePalette = 0;
break;
case FileChunkConstants.PALETTE:
Colors.Palettes.Add(Palette.Read(subChunkReader));
break;
case FileChunkConstants.SPRITESET_SPRITE:
{
var sprite = new SpriteData(new ColorSettings(Colors));
sprite.Mode = (SpriteMode)subChunkReader.ReadInt32();
sprite.Tile.Mode = (GraphicTileMode)subChunkReader.ReadInt32();
sprite.Tile.CustomColor = subChunkReader.ReadInt32();
sprite.Tile.Width = subChunkReader.ReadInt32();
sprite.Tile.Height = subChunkReader.ReadInt32();
int dataLength = subChunkReader.ReadInt32();
sprite.Tile.Data = new GR.Memory.ByteBuffer();
subChunkReader.ReadBlock(sprite.Tile.Data, (uint)dataLength);
if (sprite.Tile.CustomColor == -1)
{
sprite.Tile.CustomColor = 1;
}
sprite.Tile.Colors.ActivePalette = subChunkReader.ReadInt32();
sprite.Tile.Image = new GR.Image.MemoryImage(sprite.Tile.Width, sprite.Tile.Height, GR.Drawing.PixelFormat.Format32bppRgb);
Sprites.Add(sprite);
}
break;
case FileChunkConstants.SPRITESET_LAYER:
{
Layer layer = new Layer();
SpriteLayers.Add(layer);
GR.IO.FileChunk subChunkL = new GR.IO.FileChunk();
while (subChunkL.ReadFromStream(subChunkReader))
{
var subChunkReaderL = subChunkL.MemoryReader();
if (subChunkL.Type == FileChunkConstants.SPRITESET_LAYER_ENTRY)
{
LayerSprite sprite = new LayerSprite();
sprite.Index = subChunkReaderL.ReadInt32();
sprite.Color = subChunkReaderL.ReadInt32();
sprite.X = subChunkReaderL.ReadInt32();
sprite.Y = subChunkReaderL.ReadInt32();
sprite.ExpandX = (subChunkReaderL.ReadInt32() != 0);
sprite.ExpandY = (subChunkReaderL.ReadInt32() != 0);
layer.Sprites.Add(sprite);
}
else if (subChunkL.Type == FileChunkConstants.SPRITESET_LAYER_INFO)
{
layer.Name = subChunkReaderL.ReadString();
layer.BackgroundColor = subChunkReaderL.ReadInt32();
layer.DelayMS = subChunkReaderL.ReadInt32();
}
}
}
break;
}
}
}
break;
default:
Debug.Log("SpriteProject.ReadFromBuffer unexpected chunk type " + chunkMain.Type.ToString("X"));
return(false);
}
}
return(true);
}
int numSprites = 256;
if (Version >= 1)
{
numSprites = memIn.ReadInt32();
}
Sprites = new List <SpriteData>();
for (int i = 0; i < numSprites; ++i)
{
Sprites.Add(new SpriteData(Colors));
PaletteManager.ApplyPalette(Sprites[i].Tile.Image);
}
string name = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Tile.CustomColor = memIn.ReadInt32();
}
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Mode = (SpriteMode)memIn.ReadUInt8();
Sprites[i].Tile.Mode = Lookup.GraphicTileModeFromSpriteMode(Sprites[i].Mode);
}
Colors.BackgroundColor = memIn.ReadInt32();
Colors.MultiColor1 = memIn.ReadInt32();
Colors.MultiColor2 = memIn.ReadInt32();
bool genericMultiColor = (memIn.ReadUInt32() != 0);
for (int i = 0; i < numSprites; ++i)
{
GR.Memory.ByteBuffer tempBuffer = new GR.Memory.ByteBuffer();
memIn.ReadBlock(tempBuffer, 64);
tempBuffer.CopyTo(Sprites[i].Tile.Data, 0, 63);
}
ExportSpriteCount = memIn.ReadInt32();
ExportFilename = memIn.ReadString();
string exportPathSpriteFile = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
string desc = memIn.ReadString();
}
int spriteTestCount = memIn.ReadInt32();
for (int i = 0; i < spriteTestCount; ++i)
{
int spriteIndex = memIn.ReadInt32();
byte spriteColor = memIn.ReadUInt8();
bool spriteMultiColor = (memIn.ReadUInt8() != 0);
int spriteX = memIn.ReadInt32();
int spriteY = memIn.ReadInt32();
}
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
switch (chunk.Type)
{
case FileChunkConstants.SPRITESET_LAYER:
{
Layer layer = new Layer();
SpriteLayers.Add(layer);
var chunkReader = chunk.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(chunkReader))
{
var subChunkReader = subChunk.MemoryReader();
if (subChunk.Type == FileChunkConstants.SPRITESET_LAYER_ENTRY)
{
LayerSprite sprite = new LayerSprite();
sprite.Index = subChunkReader.ReadInt32();
sprite.Color = subChunkReader.ReadUInt8();
sprite.X = subChunkReader.ReadInt32();
sprite.Y = subChunkReader.ReadInt32();
sprite.ExpandX = (subChunkReader.ReadUInt8() != 0);
sprite.ExpandY = (subChunkReader.ReadUInt8() != 0);
layer.Sprites.Add(sprite);
}
else if (subChunk.Type == FileChunkConstants.SPRITESET_LAYER_INFO)
{
layer.Name = subChunkReader.ReadString();
layer.BackgroundColor = subChunkReader.ReadUInt8();
layer.DelayMS = subChunkReader.ReadInt32();
}
}
}
break;
}
}
while (Sprites.Count > 256)
{
Sprites.RemoveAt(256);
}
return(true);
}
