protected override TextureFormat CreateFrameForGeneralTexture(TacticsOgreEFXTexture texture, int frame, GenericDictionary formatSpecificData, IList <System.Drawing.Image> images, System.Drawing.Image referenceImage, int mipmapsCount)
{
if (referenceImage != null || images.Count > 1)
{
throw new TextureFormatException("EFX texture should not contain multiple palettes!");
}
TextureFormat segment = null;
var image = images.First();
byte entryType = formatSpecificData.Get <byte>(ENTRY_TYPE_KEY);
if (entryType != 0x52)
{
segment = new DummyTexture(string.Format("Data entry, type=0x{0:X}", entryType));
}
else
{
byte bpp = formatSpecificData.Get <byte>(BPP_KEY);
segment = new PalettedTextureFormat.Builder()
.SetIndexCodec(IndexCodec.FromBitPerPixel(bpp))
.SetImageFilter(new SwizzleFilter(image.Width, image.Height, bpp))
.SetPaletteCodec(ColorCodec.CODEC_32BIT_RGBA)
.SetColorComparer(new ARGBColorComparer())
.Build(image);
}
texture.TextureFormats.Add(segment);
return(segment);
}
internal TIM2Segment(Image image, IList <Color[]> palettes, TIM2SegmentParameters parameters)
{
this.parameters = parameters;
swizzleFilter = new SwizzleFilter(parameters.width, parameters.height, parameters.bpp);
paletteFilter = new TIM2PaletteFilter(parameters.bpp);
if (parameters.bpp > 8) //true color image
{
imageData = GetColorCodec(parameters.colorSize).EncodeColors(image.GetColorArray()); //I love extension methods. Hurray!
}
else
{
ImageEncoderIndexed encoder;
if (palettes != null)
{
encoder = new ImageEncoderIndexed(palettes, image, IndexCodec.FromBitPerPixel(parameters.bpp));
}
else
{
encoder = new ImageEncoderIndexed(image, IndexCodec.FromBitPerPixel(parameters.bpp), new ARGBColorComparer());
}
imageData = encoder.Encode();
this.palettes = new List <Color[]>(encoder.Palettes).ToArray();
}
CreateImageDecoder(imageData);
}
protected override System.Drawing.Image GetImage(int activeFrame, int activePalette)
{
ImageDecoderIndexed decoder = new ImageDecoderIndexed(imageData,
Width, Height,
IndexCodec.FromBitPerPixel(4), null,
new SwizzleFilter(Width, Height, 4));
return(decoder.DecodeImage());
}
public TextureFormat Open(System.IO.Stream formatData)
{
BinaryReader reader = new BinaryReader(formatData);
try
{
char[] magic = reader.ReadChars(MAGIC.Length);
if (new string(magic) != MAGIC)
{
throw new TextureFormatException("Not a valid TX48 Texture!");
}
int bpp = reader.ReadInt32();
if (bpp != 0 && bpp != 1)
{
throw new TextureFormatException("Illegal Bit per pixel value!");
}
bpp = (bpp + 1) * 4;
int width = reader.ReadInt32();
int height = reader.ReadInt32();
int paletteOffset = reader.ReadInt32();
if (paletteOffset != 0x40)
{
throw new TextureFormatException("TX48 Header is wrong!");
}
int paletteSize = reader.ReadInt32();
int imageOffset = reader.ReadInt32();
int imageSize = reader.ReadInt32();
reader.BaseStream.Position += 0x20;
byte[] paletteData = reader.ReadBytes(paletteSize);
byte[] imageData = reader.ReadBytes(imageSize);
PalettedTextureFormat.Builder builder = new PalettedTextureFormat.Builder();
builder.SetPaletteCodec(ColorCodec.CODEC_32BIT_RGBA)
.SetIndexCodec(IndexCodec.FromBitPerPixel(bpp));
PalettedTextureFormat segment = builder.Build(imageData, paletteData, width, height);
TX48Texture texture = new TX48Texture();
texture.TextureFormats.Add(segment);
return(texture);
}
catch (Exception e)
{
if (e is TextureFormatException)
{
throw;
}
throw new TextureFormatException(e.Message, e);
}
}
protected override System.Drawing.Image GetImage(int activeFrame, int activePalette)
{
IndexCodec codec = IndexCodec.FromBitPerPixel(bpps[activeFrame]);
ImageDecoderIndexed decoder = new ImageDecoderIndexed(imagesData[activeFrame],
widths[activeFrame],
heights[activeFrame],
codec, palettes[activeFrame],
new SwizzleFilter((int)widths[activeFrame], (int)heights[activeFrame], bpps[activeFrame]));
return(decoder.DecodeImage());
}
protected abstract void GetPalettedTools(ushort version,
byte clutFormat,
byte depth,
int colorsCount,
int width,
int height,
byte[] data,
byte[] userData,
out ColorCodec paletteCodec,
out IndexCodec indexCodec,
out ImageFilter imgFilter,
out PaletteFilter palFilter);
private void CreateImageDecoder(byte[] imageData)
{
if (Bpp <= 8) //here we have an Indexed TIM2
{
decoder = new ImageDecoderIndexed(imageData,
parameters.width, parameters.height,
IndexCodec.FromBitPerPixel(Bpp),
palettes[SelectedPalette]);
}
else //otherwise, we have a true color TIM2
{
decoder = new ImageDecoderDirectColor(imageData,
parameters.width, parameters.height,
GetColorCodec(parameters.colorSize));
}
}
protected override void GetPalettedTools(ushort version, byte clutFormat, byte depth, int colorsCount, int width, int height, byte[] data, byte[] userData,
out Encoding.ColorCodec paletteCodec,
out Encoding.IndexCodec indexCodec,
out Filters.ImageFilter imgFilter,
out Filters.PaletteFilter palFilter)
{
int bpp;
switch (depth)
{
case 5: //C4
bpp = 4;
break;
case 6: //C8
bpp = 8;
break;
default:
throw new TextureFormatException("Unsupported depth " + depth);
}
switch (clutFormat)
{
case 1:
paletteCodec = ColorCodec.CODEC_16BITBE_RGB565;
break;
case 2:
paletteCodec = ColorCodec.CODEC_16BITBE_RGB5A3;
break;
case 3:
paletteCodec = ColorCodec.CODEC_16BITBE_IA8;
break;
case 0xB: //not sure about this (FIX)
paletteCodec = ColorCodec.CODEC_16BITBE_IA8;
break;
default:
throw new TextureFormatException("Unsupported clut format " + clutFormat);
}
indexCodec = IndexCodec.FromBitPerPixel(bpp, ByteOrder.BigEndian);
imgFilter = new TileFilter(bpp, 8, 32 / bpp, width, height);
palFilter = null;
}
internal PE3SimpleDATTexture(byte[] rawHeader, Image img)
{
this.rawHeader = rawHeader;
if (img.Width != 512)
{
throw new TextureFormatException("Only a width of 512 pixel is allowed!");
}
width = img.Width;
height = img.Height;
ImageEncoderIndexed encoder = new ImageEncoderIndexed(img,
IndexCodec.FromBitPerPixel(4), null, null,
new SwizzleFilter(width, height, 4));
imageData = encoder.Encode();
}
internal PE3DATTexture(IList <Image> images, uint[] pos1, uint[] pos2, ushort[] w, ushort[] h, int[] bpps)
{
imagesData = new List <byte[]>(images.Count);
palettes = new List <Color[]>(images.Count);
positions1 = pos1;
positions2 = pos2;
widths = w;
heights = h;
this.bpps = bpps;
for (int i = 0; i < images.Count; i++)
{
if (bpps[i] != 8 && bpps[i] != 4)
{
throw new TextureFormatException("Illegal bpp value: " + bpps[i]);
}
Image img = images[i];
ImageEncoderIndexed encoder = new ImageEncoderIndexed(img, IndexCodec.FromBitPerPixel(bpps[i]), null, null, new SwizzleFilter(widths[i], heights[i], bpps[i]));
imagesData.Add(encoder.Encode());
palettes.Add(encoder.Palettes[0]);
}
}
public TextureFormat Import(MetadataReader metadata, string directory)
{
metadata.EnterSection("TX48Texture");
string basename = metadata.GetAttribute <string>("Basename");
metadata.EnterSection("TX48Segment");
int bpp = metadata.Get <int>("Bpp");
Image img = Image.FromFile(Path.Combine(directory, basename + ".png"));
metadata.ExitSection();
metadata.ExitSection();
PalettedTextureFormat segment = new PalettedTextureFormat.Builder()
.SetPaletteCodec(ColorCodec.CODEC_32BIT_RGBA)
.SetIndexCodec(IndexCodec.FromBitPerPixel(bpp))
.Build(img);
TX48Texture texture = new TX48Texture();
texture.TextureFormats.Add(segment);
return(texture);
}
public Builder SetIndexCodec(IndexCodec codec)
{
this.codec = codec;
return(this);
}
public override TextureFormat Open(System.IO.Stream formatData)
{
if (!IsValidFormat(formatData))
{
throw new TextureFormatException("Not a valid TPL Texture!");
}
BinaryReader reader = new BinaryReader(formatData);
reader.BaseStream.Position += 4;
ByteOrder order = ByteOrder.BigEndian;
int texturesCount = (int)reader.ReadUInt32(order);
uint imageTableOffset = reader.ReadUInt32(order);
reader.BaseStream.Position = imageTableOffset;
TPLTexture texture = new TPLTexture();
for (int i = 0; i < texturesCount; i++)
{
TextureFormat segment = null;
//image table
uint imageHeaderOffset = reader.ReadUInt32(order);
uint offsetPaletteHeader = reader.ReadUInt32(order);
long oldPos = reader.BaseStream.Position;
reader.BaseStream.Position = imageHeaderOffset;
int height = reader.ReadUInt16(order);
int width = reader.ReadUInt16(order);
uint format = reader.ReadUInt32(order);
uint imgDataOffset = reader.ReadUInt32(order);
ColorCodec colorCodec = null;
IndexCodec idxCodec = null;
ImageFilter imgFilter = null;
ushort entryCount = 0;
ushort unknown = 0;//this might be a set of flags denoting whether the palette is internal to the tpl image or external.
uint paletteFormat = 0;
uint palDataOffset = 0;
bool isIndexed = false;
int imgDataSize = 0;
int palDataSize = 0;
switch (format)
{
case 0: //I4
colorCodec = ColorCodec.CODEC_4BITBE_I4;
imgFilter = new TileFilter(4, 8, 8, width, height);
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 1: //I8
colorCodec = ColorCodec.CODEC_8BIT_I8;
imgFilter = new TileFilter(8, 8, 4, width, height);
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 2: //IA4
colorCodec = ColorCodec.CODEC_8BITBE_IA4;
imgFilter = new TileFilter(8, 8, 4, width, height);
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 3: //IA8
colorCodec = ColorCodec.CODEC_16BITBE_IA8;
imgFilter = new TileFilter(16, 4, 4, width, height);
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 4: //RGB565
colorCodec = ColorCodec.CODEC_16BITBE_RGB565;
imgFilter = new TileFilter(16, 4, 4, width, height);
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 5: //RGB5A3
colorCodec = ColorCodec.CODEC_16BITBE_RGB5A3;
imgFilter = new TileFilter(16, 4, 4, width, height);
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 6: //RGBA32 2 planes
colorCodec = ColorCodec.CODEC_32BIT_ARGB;
imgFilter = new ImageFilterComposer {
new GamecubePlanarFilter(),
new TileFilter(32, 4, 4, width, height)
};
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 8: //C4
case 9: //C8
isIndexed = true;
reader.BaseStream.Position = offsetPaletteHeader;
entryCount = reader.ReadUInt16(order);
unknown = reader.ReadUInt16(order);
paletteFormat = reader.ReadUInt32(order);
palDataOffset = reader.ReadUInt32(order);
switch (paletteFormat)
{
case 0:
colorCodec = ColorCodec.CODEC_16BITBE_IA8;
break;
case 1:
colorCodec = ColorCodec.CODEC_16BITBE_RGB565;
break;
case 2:
colorCodec = ColorCodec.CODEC_16BITBE_RGB5A3;
break;
default:
throw new TextureFormatException("Unsupported palette format " + paletteFormat);
}
palDataSize = colorCodec.GetBytesNeededForEncode(entryCount, 1);
if (format == 8)
{
idxCodec = IndexCodec.FromBitPerPixel(4, order);
imgFilter = new TileFilter(4, 8, 8, width, height);
}
else
{
idxCodec = IndexCodec.FromBitPerPixel(8, order);
imgFilter = new TileFilter(8, 8, 4, width, height);
}
imgDataSize = idxCodec.GetBytesNeededForEncode(width, height, imgFilter);
break;
case 0xA: //C14X2
throw new TextureFormatException("C14X2 not implemented yet!");
break;
case 0xE: //DXT1 (aka CMPR)
colorCodec = new ColorCodecDXT1Gamecube(width, height);
imgDataSize = colorCodec.GetBytesNeededForEncode(width, height);
break;
default:
throw new TextureFormatException("Unsupported TPL image format " + format);
}
reader.BaseStream.Position = imgDataOffset;
byte[] imgData = reader.ReadBytes(imgDataSize);
if (isIndexed)
{
reader.BaseStream.Position = palDataOffset;
byte[] palData = reader.ReadBytes(palDataSize);
PalettedTextureFormat.Builder builder = new PalettedTextureFormat.Builder();
segment = builder.SetIndexCodec(idxCodec)
.SetPaletteCodec(colorCodec)
.SetImageFilter(imgFilter)
.Build(imgData, palData, width, height);
}
else
{
GenericTextureFormat.Builder builder = new GenericTextureFormat.Builder();
segment = builder.SetColorCodec(colorCodec)
.SetImageFilter(imgFilter)
.Build(imgData, width, height);
}
segment.FormatSpecificData.Put <uint>(FORMAT_KEY, format)
.Put <uint>(UNKNOWN_KEY, unknown)
.Put <uint>(PALETTEFORMAT_KEY, paletteFormat);
texture.TextureFormats.Add(segment);
reader.BaseStream.Position = oldPos;
}
return(texture);
}
private TextureFormat ReadEntry(BinaryReader reader)
{
TextureFormat segment = null;
uint fullEntrySize = reader.ReadUInt32();
ushort unk1 = reader.ReadUInt16();
ushort unk2 = reader.ReadUInt16();
uint sizeEntryNotHeader = reader.ReadUInt32();
ushort id = reader.ReadUInt16();
byte entryType = reader.ReadByte();
byte unk3 = reader.ReadByte();
if (entryType != 0x52) // non-image entry
{
//let's copy the raw data and put it in a dummy texture
byte[] buf = reader.ReadBytes((int)fullEntrySize - 0x10);
segment = new DummyTexture(string.Format("Data entry, type=0x{0:X}", entryType));
segment.FormatSpecificData.Put <byte[]>(RAW_DATA_KEY, buf);
segment.FormatSpecificData.Put <uint>(ENTRY_NO_HEADER_KEY, sizeEntryNotHeader);
}
else //image data, let's read header 2 data
{
if (fullEntrySize - sizeEntryNotHeader != 0x10)
{
throw new TextureFormatException("Not a valid EFX file, full size and size without header 1 do not match!");
}
byte bpp = reader.ReadByte();
if (bpp != 4 && bpp != 8)
{
throw new TextureFormatException("Not a valid EFX file, unsupported bpp=" + bpp);
}
byte unk4 = reader.ReadByte();
if (unk4 != 0x20)
{
throw new TextureFormatException("Not a valid EFX file, unk3 not equal to 0x20!");
}
ushort unk5 = reader.ReadUInt16();
if (unk5 != 0x01)
{
throw new TextureFormatException("Not a valid EFX file, unk4 not equal to 0x01!");
}
ushort paletteColors = reader.ReadUInt16();
if (paletteColors != 1 << bpp)
{
throw new TextureFormatException("This EFX file contains more colors then requested by bpp. Is this a multi-palette texture?");
}
ushort width = reader.ReadUInt16();
ushort height = reader.ReadUInt16();
if (reader.ReadUInt16() != width)
{
throw new TextureFormatException("Not a valid EFX file, widths not corresponding!");
}
if (reader.ReadUInt16() != height)
{
throw new TextureFormatException("Not a valid EFX file, widths not corresponding!");
}
reader.ReadUInt16(); //pad
uint unk6 = reader.ReadUInt32();
if (unk6 != 0x20)
{
throw new TextureFormatException("Not a valid EFX file, unk5 not equal to 0x20!");
}
uint header2AndImgDataSize = reader.ReadUInt32();
uint imgSize = header2AndImgDataSize - 0x20;
int paletteSize = paletteColors * 4;
if (sizeEntryNotHeader - header2AndImgDataSize != paletteSize)
{
throw new TextureFormatException("Not a valid EFX file, size of image data not corresponding!");
}
if (reader.ReadUInt32() != sizeEntryNotHeader)
{
throw new TextureFormatException("Not a valid EFX file, size of entry without header 1 not corresponding in header 2!");
}
reader.ReadUInt32(); //pad
//retrieve image and palette data and construct texture
byte[] imgData = reader.ReadBytes((int)imgSize);
byte[] palData = reader.ReadBytes(paletteSize);
segment = new PalettedTextureFormat.Builder()
.SetIndexCodec(IndexCodec.FromBitPerPixel(bpp))
.SetImageFilter(new SwizzleFilter(width, height, bpp))
.SetPaletteCodec(ColorCodec.CODEC_32BIT_RGBA)
.SetColorComparer(new ARGBColorComparer())
.Build(imgData, palData, width, height);
segment.FormatSpecificData.Put <byte>(BPP_KEY, bpp);
segment.FormatSpecificData.Put <byte>(UNK4_KEY, unk4);
segment.FormatSpecificData.Put <ushort>(UNK5_KEY, unk5);
segment.FormatSpecificData.Put <uint>(UNK6_KEY, unk6);
}
segment.FormatSpecificData.Put <ushort>(UNK1_KEY, unk1);
segment.FormatSpecificData.Put <ushort>(UNK2_KEY, unk2);
segment.FormatSpecificData.Put <ushort>(ID_KEY, id);
segment.FormatSpecificData.Put <byte>(ENTRY_TYPE_KEY, entryType);
segment.FormatSpecificData.Put <byte>(UNK3_KEY, unk3);
return(segment);
}
