private static unsafe Bitmap SimpleRender(byte[] data, Palette256 palette, Rectangle frameRect)
{
try
{
Bitmap bitmap = new Bitmap(frameRect.Width + frameRect.X, frameRect.Height + frameRect.Y);
BitmapData bitmapdata = bitmap.LockBits(frameRect, ImageLockMode.WriteOnly, bitmap.PixelFormat);
for (int index1 = 0; index1 < frameRect.Height; ++index1)
{
byte *numPtr = (byte *)((IntPtr)(void *)bitmapdata.Scan0 + index1 * bitmapdata.Stride);
for (int index2 = 0; index2 < frameRect.Width; ++index2)
{
int index3 = (int)data[index1 * frameRect.Width + index2];
if (index3 > 0 && bitmapdata.PixelFormat == PixelFormat.Format32bppArgb)
{
numPtr[(index2 * 4)] = palette[index3].B;
numPtr[index2 * 4 + 1] = palette[index3].G;
numPtr[index2 * 4 + 2] = palette[index3].R;
numPtr[index2 * 4 + 3] = palette[index3].A;
}
}
}
bitmap.UnlockBits(bitmapdata);
return(bitmap);
}
catch (ArgumentException ex)
{
return(new Bitmap(1, 1));
}
}
private void spriteList_SelectedIndexChanged(object sender, EventArgs e)
{
mpf = mpfImages[(int)spriteList.SelectedItem];
pal = Palette256.FromArchive(mpf.Palette, DATArchive.Hades);
int maxThumbWidth = Math.Min(128, mpf.Width);
int maxThumbHeight = Math.Min(128, mpf.Height);
int thumbnailSize = Math.Max(maxThumbWidth, maxThumbHeight);
flowLayoutPanel1.Controls.Clear();
for (int i = 0; i < mpf.ExpectedFrames; ++i)
{
var frame = mpf.Frames[i];
var thumbnail = new PictureBox();
thumbnail.Size = new Size(128, 128);
thumbnail.SizeMode =
frame.Width > thumbnail.Width || frame.Height > thumbnail.Height
? PictureBoxSizeMode.Zoom
: PictureBoxSizeMode.CenterImage;
if (frame.Height > 0 && frame.Width > 0)
{
thumbnail.Image = DAGraphics.RenderImage(frame, pal);
}
thumbnail.BackColor = Color.Teal;
thumbnail.MouseClick += thumbnail_MouseClick;
flowLayoutPanel1.Controls.Add(thumbnail);
}
}
static SignForm()
{
var epf = EPFImage.FromArchive("woodbk.epf", DATArchive.Legend);
var pal = Palette256.FromArchive("legend.pal", DATArchive.Legend);
woodbk = DAGraphics.RenderImage(epf[0], pal);
}
public static Bitmap RenderImage(EPFFrame epf, Palette256 palette)
{
if (epf.Width == 1 && epf.Height == 1)
{
return(new Bitmap(1, 1));
}
return(DAGraphics.SimpleRender(epf.RawData, palette, new Rectangle(epf.Left, epf.Top, epf.Width, epf.Height)));
}
public SkillIconForm(int icon, string type)
{
InitializeComponent();
Text = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(type) + " Icon";
_icon = icon;
_epfImage = EPFImage.FromArchive(type + "001.epf", DATArchive.Setoa);
_palette = Palette256.FromArchive("gui06.pal", DATArchive.Setoa);
}
private void UpdateIcon()
{
string epfFilename;
switch (cmbBook.SelectedIndex)
{
case 0:
case 2:
case 4:
epfFilename = "skill001.epf";
break;
default:
epfFilename = "spell001.epf";
break;
}
var _epfImage = EPFImage.FromArchive(epfFilename, DATArchive.Setoa);
var _palette = Palette256.FromArchive("gui06.pal", DATArchive.Setoa);
var bitmap = DAGraphics.RenderImage(_epfImage[_skill.Icon], _palette);
imgIcon.Image = bitmap;
}
private unsafe void DrawBitmapData(Bitmap image, byte[] data, Palette256 pal, Rectangle rect, bool blend = false)
{
var bmd = image.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
for (int y = 0; y < bmd.Height; ++y)
{
byte *row = (byte *)bmd.Scan0 + (y * bmd.Stride);
for (int x = 0; x < bmd.Width; ++x)
{
int colorIndex = data[y * rect.Width + x];
if (colorIndex == 0)
{
continue;
}
if (blend)
{
row[x * 4] = (byte)Math.Min(pal[colorIndex].B + row[x * 4], 255);
row[x * 4 + 1] = (byte)Math.Min(pal[colorIndex].G + row[x * 4 + 1], 255);
row[x * 4 + 2] = (byte)Math.Min(pal[colorIndex].R + row[x * 4 + 2], 255);
row[x * 4 + 3] = (byte)Math.Min(pal[colorIndex].A + row[x * 4 + 3], 255);
}
else
{
row[x * 4] = pal[colorIndex].B;
row[x * 4 + 1] = pal[colorIndex].G;
row[x * 4 + 2] = pal[colorIndex].R;
row[x * 4 + 3] = pal[colorIndex].A;
}
}
}
image.UnlockBits(bmd);
}
private void DrawForeground(Bitmap image)
{
int xOrigin = ((image.Width / 2) - 1) - Tileset.HalfTileWidth + 1;
int yOrigin = 256;
for (int y = 0; y < map.Height; ++y)
{
for (int x = 0; x < map.Width; ++x)
{
var point = new Point(x, y);
int tileIndex = y * map.Width + x;
#region Npc
if (showNpcs && map.Npcs.ContainsKey(point))
{
var npc = map.Npcs[point];
string filename = string.Format("MNS{0:d3}.MPF", npc.Sprite);
var mpf = MPFImage.FromArchive(filename, DATArchive.Hades);
var pal = Palette256.FromArchive(mpf.Palette, DATArchive.Hades);
var frame = mpf[0];
DrawBitmapData(image, frame.RawData, pal, new Rectangle(
xOrigin + frame.Left + x * Tileset.HalfTileWidth,
yOrigin + frame.Top + (x + 1) * Tileset.HalfTileHeight - mpf.Height + Tileset.HalfTileHeight,
frame.Width, frame.Height));
}
#endregion
#region Left Wall
int leftWall = map.Tiles[tileIndex].LeftWall;
if (showLeftWalls && (leftWall % 10000) > 1)
{
string filename = string.Format("stc{0:d5}.hpf", leftWall);
var hpf = HPFImage.FromArchive(filename, DATArchive.Ia);
DrawBitmapData(image, hpf.RawData, stcPaletteTable[leftWall + 1], new Rectangle(
xOrigin + x * Tileset.HalfTileWidth,
yOrigin + (x + 1) * Tileset.HalfTileHeight - hpf.Height + Tileset.HalfTileHeight,
hpf.Width, hpf.Height), map.Tiles[tileIndex].LeftBlends);
}
#endregion
#region Right Wall
int rightWall = map.Tiles[tileIndex].RightWall;
if (showRightWalls && (rightWall % 10000) > 1)
{
string filename = string.Format("stc{0:d5}.hpf", rightWall);
var hpf = HPFImage.FromArchive(filename, DATArchive.Ia);
DrawBitmapData(image, hpf.RawData, stcPaletteTable[rightWall + 1], new Rectangle(
xOrigin + (x + 1) * Tileset.HalfTileWidth,
yOrigin + (x + 1) * Tileset.HalfTileHeight - hpf.Height + Tileset.HalfTileHeight,
hpf.Width, hpf.Height), map.Tiles[tileIndex].RightBlends);
}
#endregion
}
xOrigin -= Tileset.HalfTileWidth;
yOrigin += Tileset.HalfTileHeight;
}
}
public static SPFImage FromArchive(string file, DATArchive archive)
{
if (!archive.Contains(file))
{
return(null);
}
var stream = new MemoryStream(archive.ExtractFile(file));
var reader = new BinaryReader(stream);
var spf = new SPFImage();
int unknown1 = reader.ReadInt32();
int unknown2 = reader.ReadInt32();
spf.colorFormat = reader.ReadInt32();
if (spf.colorFormat == 0)
{
var palette = new Palette256();
byte[] alpha = reader.ReadBytes(512);
byte[] color = reader.ReadBytes(512);
for (int i = 0; i < 256; ++i)
{
ushort val = BitConverter.ToUInt16(color, i * 2);
int b = 8 * ((int)val % 32);
int g = 8 * ((int)val / 32 % 32);
int r = 8 * ((int)val / 32 / 32 % 32);
palette[i] = Color.FromArgb(r, g, b);
}
spf.palette = palette;
}
spf.expectedFrames = reader.ReadInt32();
spf.frames = new SPFFrame[spf.expectedFrames];
for (int i = 0; i < spf.expectedFrames; ++i)
{
int left = reader.ReadInt16();
int top = reader.ReadInt16();
int width = reader.ReadInt16();
int height = reader.ReadInt16();
int unknown3 = reader.ReadInt32();
int unknown4 = reader.ReadInt32();
int startAddress = reader.ReadInt32();
int byteWidth = reader.ReadInt32();
int length = reader.ReadInt32();
int semiLength = reader.ReadInt32();
spf.frames[i] = new SPFFrame(left, top, width, height, startAddress, byteWidth, length, semiLength);
}
spf.length = reader.ReadInt32();
for (int i = 0; i < spf.expectedFrames; ++i)
{
int length = spf.frames[i].Length;
byte[] data = reader.ReadBytes(length);
spf.frames[i].SetData(data);
}
reader.Close();
return(spf);
}
