static void ExtractFontPack(string pakPath, string txmPath, string basePath)
{
if (basePath == null)
{
basePath = pakPath + "_extracted";
}
using (Stream fs = Utils.CheckDecompress(File.OpenRead(txmPath)))
using (Stream datFs = Utils.CheckDecompress(File.OpenRead(pakPath)))
{
var fontTxmHeader = new TxmHeader();
BinaryReader br = new BinaryReader(fs);
fontTxmHeader.Read(br);
var palette = TxmConversion.ReadRgba32Palette(br, fontTxmHeader.ClutWidth, fontTxmHeader.ClutHeight);
var fontPak = new FontPack();
fontPak.Read(datFs);
Directory.CreateDirectory(basePath);
foreach (var ch in fontPak.Characters)
{
using MemoryStream ms = new MemoryStream(fontPak[ch]);
BinaryReader charBr = new BinaryReader(ms);
using (var img = TxmConversion.ConvertTxmIndexed4bpp(charBr, 24, 22, palette))
{
img.SaveAsPng(Path.Combine(basePath, $"{ch}.png"));
}
}
}
}
void FillTxm(Db2Element elem, TxmHeader txm)
{
Tex0 tex0 = new Tex0 {
Packed = BitConverter.ToUInt64(elem.GsRegs, 0x10)
};
txm.ImageSourcePixelFormat = (TxmPixelFormat)tex0.Psm;
txm.ImageVideoPixelFormat = txm.ImageSourcePixelFormat;
txm.ImageWidth = (short)(1 << tex0.Tw);
txm.ImageHeight = (short)(1 << tex0.Th);
txm.Misc = tex0.Tbw;
if (txm.ImageSourcePixelFormat == TxmPixelFormat.PSMT4 || txm.ImageSourcePixelFormat == TxmPixelFormat.PSMT8)
{
txm.ClutPixelFormat = (TxmPixelFormat)tex0.Cpsm;
if (txm.ImageSourcePixelFormat == TxmPixelFormat.PSMT4)
{
txm.ClutWidth = 8;
txm.ClutHeight = 2;
}
else
{
txm.ClutWidth = 16;
txm.ClutHeight = 16;
}
}
else
{
txm.ClutPixelFormat = TxmPixelFormat.None;
}
}
void CopyTexelsClut(BinaryReader br, BinaryWriter bw, TxmHeader pakTxm, TxmHeader textureTxm)
{
if (pakTxm.ClutPixelFormat != TxmPixelFormat.None)
{
throw new ArgumentException("Cannot operate on source TXM with CLUT.", nameof(pakTxm));
}
if (textureTxm.ClutPixelFormat == TxmPixelFormat.None)
{
return;
}
var destColumnParams = GsMemoryUtils.GetColumnParams(textureTxm.ClutPixelFormat);
int copyLength = textureTxm.GetClutByteSize();
int baseBlockNumber = textureTxm.ClutBufferBase - pakTxm.ImageBufferBase;
int srcBase = 0x10 + pakTxm.GetClutByteSize();
var destBase = 0x10;
int bytesPerSrcLine = pakTxm.GetImageByteSize() / pakTxm.ImageHeight;
int bytesPerDestLine = textureTxm.GetClutByteSize() / textureTxm.ClutHeight;
bw.Write(new byte[copyLength]);
int numXBlocks = textureTxm.ClutWidth / destColumnParams.Width;
if (numXBlocks == 0)
{
numXBlocks = 1;
}
int numYBlocks = textureTxm.ClutHeight / (destColumnParams.Height * GsMemoryUtils.COLUMNS_PER_BLOCK);
if (numYBlocks == 0)
{
numYBlocks = 1;
}
int destBlock = 0;
for (int blockY = 0; blockY < numYBlocks; ++blockY)
{
for (int blockX = 0; blockX < numXBlocks; ++blockX)
{
int blockNumber = baseBlockNumber + GsMemoryUtils.CalcBlockNumber(textureTxm.ClutPixelFormat, blockX, blockY, 1);
br.BaseStream.Seek(srcBase + GsMemoryUtils.CalcBlockMemoryOffset(pakTxm.ImageSourcePixelFormat, blockNumber),
SeekOrigin.Begin);
bw.BaseStream.Seek(destBase + GsMemoryUtils.CalcTxmImageOffset(destColumnParams, destBlock, textureTxm.ClutWidth),
SeekOrigin.Begin);
for (int i = 0; i < GsMemoryUtils.COLUMNS_PER_BLOCK; ++i)
{
byte[] col = GsMemoryUtils.ReadColumn(br, pakTxm.ImageSourcePixelFormat, bytesPerSrcLine);
GsMemoryUtils.WriteColumn(bw, textureTxm.ClutPixelFormat, bytesPerDestLine, col);
}
++destBlock;
}
}
// Dump palette
//bw.BaseStream.Seek(destBase, SeekOrigin.Begin);
//BinaryReader palBr = new BinaryReader(bw.BaseStream);
//using (var palette = TxmConversion.ConvertTxmRgba32(palBr, textureTxm.ClutWidth, textureTxm.ClutHeight))
//{
// palette.SaveAsPng($"palette_{numWrittenTextures}.png");
//}
}
public static Image <Rgba32> ConvertTxmToImage(Stream stream)
{
BinaryReader br = new BinaryReader(stream);
TxmHeader imageHeader = new TxmHeader();
imageHeader.Read(br);
Console.WriteLine(imageHeader);
//if (imageHeader.Misc != 1)
// Console.WriteLine("Different level!");
Image <Rgba32> image;
if (imageHeader.ImageSourcePixelFormat == TxmPixelFormat.PSMT8 || imageHeader.ImageSourcePixelFormat == TxmPixelFormat.PSMT4)
{
Rgba32[] palette = null;
if (imageHeader.ClutPixelFormat == TxmPixelFormat.PSMCT32)
{
stream.Seek(16, SeekOrigin.Begin);
palette = ReadRgba32Palette(br, imageHeader.ClutWidth, imageHeader.ClutHeight);
//fs.Seek(16, SeekOrigin.Begin);
//using (var palImage = ConvertTxmRgba32(br, imageHeader.ClutWidth, imageHeader.ClutHeight))
//{
// palImage.SaveAsPng(Path.ChangeExtension(outPath, ".pal.png"));
//}
}
else
{
throw new NotSupportedException("Unsupported pixel format from second texture");
}
stream.Seek(16 + (imageHeader.GetClutByteSize() + 15) / 16 * 16, SeekOrigin.Begin);
if (imageHeader.ImageSourcePixelFormat == TxmPixelFormat.PSMT8)
{
image = ConvertTxmIndexed8bpp(br, imageHeader.ImageWidth, imageHeader.ImageHeight, palette);
}
else
{
image = ConvertTxmIndexed4bpp(br, imageHeader.ImageWidth, imageHeader.ImageHeight, palette);
}
}
else if (imageHeader.ImageSourcePixelFormat == TxmPixelFormat.PSMCT32)
{
stream.Seek(16, SeekOrigin.Begin);
image = ConvertTxmRgba32(br, imageHeader.ImageWidth, imageHeader.ImageHeight);
}
else
{
throw new NotSupportedException("Unsupported pixel format");
}
return(image);
}
void CopyTexels(BinaryReader br, BinaryWriter bw, TxmHeader pakTxm, TxmHeader textureTxm)
{
if (pakTxm.ClutPixelFormat != TxmPixelFormat.None)
{
throw new ArgumentException("Cannot operate on source TXM with CLUT.", nameof(pakTxm));
}
var destColumnParams = GsMemoryUtils.GetColumnParams(textureTxm.ImageSourcePixelFormat);
int copyLength = textureTxm.GetImageByteSize();
int srcBase = 0x10 + pakTxm.GetClutByteSize();
int baseBlockNumber = textureTxm.ImageBufferBase - pakTxm.ImageBufferBase;
int destBase = 0x10 + textureTxm.GetClutByteSize();
int bytesPerSrcLine = pakTxm.GetImageByteSize() / pakTxm.ImageHeight;
int bytesPerDestLine = copyLength / textureTxm.ImageHeight;
bw.Write(new byte[copyLength]);
int numXBlocks = textureTxm.ImageWidth / destColumnParams.Width;
if (numXBlocks == 0)
{
numXBlocks = 1;
}
int numYBlocks = textureTxm.ImageHeight / (destColumnParams.Height * GsMemoryUtils.COLUMNS_PER_BLOCK);
if (numYBlocks == 0)
{
numYBlocks = 1;
}
int destBlock = 0;
for (int blockY = 0; blockY < numYBlocks; ++blockY)
{
for (int blockX = 0; blockX < numXBlocks; ++blockX)
{
int blockNumber = baseBlockNumber + GsMemoryUtils.CalcBlockNumber(textureTxm.ImageSourcePixelFormat, blockX, blockY, textureTxm.Misc);
br.BaseStream.Seek(srcBase + GsMemoryUtils.CalcBlockMemoryOffset(pakTxm.ImageSourcePixelFormat, blockNumber),
SeekOrigin.Begin);
bw.BaseStream.Seek(destBase + GsMemoryUtils.CalcTxmImageOffset(destColumnParams, destBlock, textureTxm.ImageWidth),
SeekOrigin.Begin);
for (int i = 0; i < GsMemoryUtils.COLUMNS_PER_BLOCK; ++i)
{
byte[] col = GsMemoryUtils.ReadColumn(br, pakTxm.ImageSourcePixelFormat, bytesPerSrcLine);
if (pakTxm.ImageSourcePixelFormat != textureTxm.ImageSourcePixelFormat)
{
col = PsmtMixer.MixColumn(col, pakTxm.ImageSourcePixelFormat, textureTxm.ImageSourcePixelFormat, i % 2 != 0);
}
GsMemoryUtils.WriteColumn(bw, textureTxm.ImageSourcePixelFormat, bytesPerDestLine, col);
}
++destBlock;
}
}
}
TxmHeader CreateTexture(Tdb tdb, int index, out ulong textureId)
{
var tdbTexture = tdb.Textures[index];
textureId = ((ulong)tdbTexture.DatIndex << 32) | ((ulong)tdbTexture.ImageBufferBase << 16) | tdbTexture.ClutBufferBase;
if (!textureCache.ContainsKey(textureId))
{
TxmHeader txm = new TxmHeader();
txm.ImageBufferBase = tdbTexture.ImageBufferBase;
txm.ClutBufferBase = tdbTexture.ClutBufferBase;
textureCache.Add(textureId, txm);
return(txm);
}
return(null);
}
static void ReplaceDatImages(string srcDatPath, string destDatPath, string replacementList)
{
List <string> tempPaths = new List <string>();
try
{
using (DatReader dat = new DatReader(File.OpenRead(srcDatPath)))
{
DatBuilder builder = new DatBuilder(dat);
using (StreamReader sr = File.OpenText(replacementList))
{
while (!sr.EndOfStream)
{
var line = sr.ReadLine().Trim();
if (line.Length == 0 || line.StartsWith("#"))
{
continue;
}
var lineSplit = line.Split(' ', 2, StringSplitOptions.RemoveEmptyEntries);
if (lineSplit.Length != 2)
{
throw new InvalidDataException($"Invalid line \"{line}\".");
}
if (!int.TryParse(lineSplit[0], out var imageIndex))
{
throw new InvalidDataException($"Invalid index on line \"{line}\".");
}
byte level = 1;
ushort bufferBase = 0;
ushort paletteBufferBase = 0;
if (imageIndex < dat.EntriesCount)
{
using (MemoryStream ms = new MemoryStream(dat.GetData(imageIndex)))
{
TxmHeader txm = new TxmHeader();
txm.Read(new BinaryReader(ms));
level = (byte)(txm.Misc & 0x0f);
bufferBase = txm.ImageBufferBase;
paletteBufferBase = txm.ClutBufferBase;
}
}
string tempPath = Path.GetTempFileName();
tempPaths.Add(tempPath);
using (FileStream fs = File.Create(tempPath))
{
TxmConversion.ConvertImageToTxm(lineSplit[1], fs, level, bufferBase, paletteBufferBase);
}
builder.ReplacementEntries.Add(new DatBuilder.ReplacementEntry
{
Index = imageIndex,
SourceFile = tempPath
});
}
}
using (FileStream fs = File.Create(destDatPath))
{
builder.Build(fs);
}
}
}
finally
{
foreach (var path in tempPaths)
{
File.Delete(path);
}
}
}
public static void ConvertImageToTxm(string inPath, Stream outStream, byte level = 1, ushort bufferBase = 0, ushort paletteBufferBase = 0)
{
using (var image = Image.Load <Rgba32>(inPath))
{
// Gather all colors to see if it would fit in PSMT8
TxmPixelFormat pixelFormat = TxmPixelFormat.None;
HashSet <Rgba32> colorSet = new HashSet <Rgba32>();
List <Rgba32> palette = null;
for (int y = 0; y < image.Height; ++y)
{
var row = image.GetPixelRowSpan(y);
for (int x = 0; x < image.Width; ++x)
{
colorSet.Add(row[x]);
if (colorSet.Count > 256)
{
pixelFormat = TxmPixelFormat.PSMCT32;
y = image.Height;
break;
}
}
}
short paletteWidth = 0;
short paletteHeight = 0;
if (pixelFormat == TxmPixelFormat.None)
{
// Palette check passed, assign palettized pixel format
if (colorSet.Count > 16)
{
pixelFormat = TxmPixelFormat.PSMT8;
paletteWidth = 16;
paletteHeight = 16;
}
else
{
pixelFormat = TxmPixelFormat.PSMT4;
paletteWidth = 8;
paletteHeight = 2;
}
palette = new List <Rgba32>(colorSet);
}
// Write header
BinaryWriter bw = new BinaryWriter(outStream);
TxmHeader txmHeader = new TxmHeader
{
ImageSourcePixelFormat = pixelFormat,
ImageVideoPixelFormat = pixelFormat,
ImageWidth = (short)image.Width,
ImageHeight = (short)image.Height,
ImageBufferBase = bufferBase,
ClutPixelFormat = palette != null ? TxmPixelFormat.PSMCT32 : TxmPixelFormat.None,
Misc = (byte)(level & 0x0f),
ClutWidth = paletteWidth,
ClutHeight = paletteHeight,
ClutBufferBase = paletteBufferBase
};
txmHeader.Write(bw);
// Write palette
int palettePixelsWritten = 0;
if (pixelFormat == TxmPixelFormat.PSMT4)
{
foreach (var color in palette)
{
bw.Write(color.R);
bw.Write(color.G);
bw.Write(color.B);
bw.Write((byte)((color.A + 1) >> 1));
++palettePixelsWritten;
}
}
else if (pixelFormat == TxmPixelFormat.PSMT8)
{
int baseOffset = 0;
Rgba32 black = new Rgba32();
int[] order = new int[]
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
};
while (palettePixelsWritten < palette.Count)
{
foreach (var offset in order)
{
var palOffset = baseOffset + offset;
var color = palOffset < palette.Count ? palette[palOffset] : black;
bw.Write(color.R);
bw.Write(color.G);
bw.Write(color.B);
bw.Write((byte)((color.A + 1) >> 1));
++palettePixelsWritten;
}
baseOffset += order.Length;
}
}
// Pad out rest of palette
int targetOffset = 16 + (txmHeader.GetClutByteSize() + 15) / 16 * 16;
while (outStream.Position < targetOffset)
{
bw.Write((byte)0);
}
// Write main image data
byte pal4BppBuffer = 0;
bool odd = false;
for (int y = 0; y < image.Height; ++y)
{
var row = image.GetPixelRowSpan(y);
for (int x = 0; x < image.Width; ++x)
{
var pixel = row[x];
if (pixelFormat == TxmPixelFormat.PSMCT32)
{
bw.Write(pixel.R);
bw.Write(pixel.G);
bw.Write(pixel.B);
bw.Write(pixel.A); // Should be halved, but full range is used on PC
}
else
{
var palIndex = palette.IndexOf(pixel);
if (pixelFormat == TxmPixelFormat.PSMT4)
{
pal4BppBuffer <<= 4;
pal4BppBuffer |= (byte)(palIndex & 0x0f);
odd = !odd;
if (!odd)
{
bw.Write(pal4BppBuffer);
pal4BppBuffer = 0;
}
}
else
{
bw.Write((byte)palIndex);
}
}
}
}
}
}
public void ExportTextures(StreamWriter mtlWriter, string outputPath, bool forceDirect = false)
{
if (disposedValue)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (textureDat == null)
{
throw new InvalidOperationException("No texture pack supplied.");
}
int i = 0;
numWrittenTextures = 0;
foreach (var pair in textureCache.OrderBy(p => p.Key))
{
string pngPath = $"{outputPath}{i}.png";
string alphaPath = $"{outputPath}{i}_alpha.png";
TxmHeader textureTxm = pair.Value;
int txmIndex = (int)(pair.Key >> 32);
using (var txmMs = new MemoryStream(textureDat.GetData(txmIndex)))
{
BinaryReader txmBr = new BinaryReader(txmMs);
TxmHeader pakTxm = new TxmHeader();
pakTxm.Read(txmBr);
Image <Rgba32> img = null;
try
{
// Check if TXM is already suitable
if (forceDirect ||
/*pakTxm.ImageSourcePixelFormat == textureTxm.ImageSourcePixelFormat &&*/
pakTxm.ImageBufferBase == textureTxm.ImageBufferBase &&
pakTxm.ClutPixelFormat == textureTxm.ClutPixelFormat &&
pakTxm.ClutBufferBase == textureTxm.ClutBufferBase)
{
// Use TXM as-is
txmMs.Seek(0, SeekOrigin.Begin);
if (new string(txmBr.ReadChars(4)) == "DAT\0")
{
// Unwrap DAT
txmMs.Seek(0, SeekOrigin.Begin);
using (DatReader txmDat = new DatReader(txmMs))
{
if (txmDat.EntriesCount != 1)
{
throw new InvalidDataException("Nested texture DAT contains more than one file.");
}
using (MemoryStream innerStream = new MemoryStream(txmDat.GetData(0)))
{
img = TxmConversion.ConvertTxmToImage(innerStream);
}
}
}
else
{
txmMs.Seek(0, SeekOrigin.Begin);
img = TxmConversion.ConvertTxmToImage(txmMs);
// Dump palette
//if (pakTxm.ClutPixelFormat != TxmPixelFormat.None)
//{
// txmMs.Seek(0x10, SeekOrigin.Begin);
// using (var palette = TxmConversion.ConvertTxmRgba32(txmBr, pakTxm.ClutWidth, pakTxm.ClutHeight))
// {
// palette.SaveAsPng($"palette_{numWrittenTextures}.png");
// }
//}
}
}
else
{
// Generate new TXM
using (MemoryStream ms = new MemoryStream())
{
BinaryWriter bw = new BinaryWriter(ms);
textureTxm.Write(bw);
CopyTexelsClut(txmBr, bw, pakTxm, textureTxm);
CopyTexels(txmBr, bw, pakTxm, textureTxm);
bw.Flush();
ms.Seek(0, SeekOrigin.Begin);
img = TxmConversion.ConvertTxmToImage(ms);
}
}
// Save out color texture
using (var img24bpp = img.CloneAs <Rgb24>())
{
img24bpp.SaveAsPng(pngPath);
}
// Extract alpha channel as a separate image
using (var alphaImg = new Image <L8>(img.Width, img.Height))
{
for (int y = 0; y < alphaImg.Height; ++y)
{
var srcSpan = img.GetPixelRowSpan(y);
var destSpan = alphaImg.GetPixelRowSpan(y);
for (int x = 0; x < alphaImg.Width; ++x)
{
var srcAlpha = srcSpan[x].A;
destSpan[x] = new L8(srcAlpha);
}
}
alphaImg.SaveAsPng(alphaPath);
}
}
finally
{
if (img != null)
{
img.Dispose();
}
}
}
mtlWriter.WriteLine($"newmtl tex_{pair.Key:x12}");
mtlWriter.WriteLine("Kd 0.80000000 0.80000000 0.80000000");
mtlWriter.WriteLine("Ka 0 0 0");
mtlWriter.WriteLine("Ke 0 0 0");
mtlWriter.WriteLine("Ks 0 0 0");
mtlWriter.WriteLine("d 1");
mtlWriter.WriteLine("illum 2");
mtlWriter.WriteLine($"map_Kd {Path.GetFileName(pngPath)}");
mtlWriter.WriteLine($"map_d {Path.GetFileName(alphaPath)}");
mtlWriter.WriteLine();
++i;
++numWrittenTextures;
}
}
int WriteObj(Tdb tdb, StreamWriter sw, int startVert)
{
for (int i = 0; i < tdb.Mesh.Elements.Count; ++i)
{
var elem = tdb.Mesh.Elements[i];
sw.WriteLine($"g elem_{i}");
TxmHeader txm = CreateTexture(tdb, elem.TextureIndex, out var textureId);
sw.WriteLine($"usemtl tex_{textureId:x12}");
if (txm != null)
{
FillTxm(elem, txm);
}
// Write vertices
foreach (var vert in elem.Vertices)
{
sw.WriteLine($"v {(double)vert.X} {(double)vert.Y} {(double)vert.Z}");
}
foreach (var norm in elem.VertexNormals)
{
sw.WriteLine($"vn {norm.Item1} {norm.Item2} {norm.Item3}");
}
foreach (var uv in elem.STCoordinates)
{
sw.WriteLine($"vt {uv.Item1} {1 - uv.Item2}");
}
// Write faces
int[] initVerts = new int[2];
bool clockwise = true;
if (elem.GifTagIndex == 3) // Triangle fans
{
int initVertPos = 0;
for (int j = 0; j < elem.Vertices.Count; ++j)
{
if ((elem.Vertices[j].W.Packed & 0x00008000) != 0)
{
initVerts[initVertPos++] = startVert + j;
}
else
{
int currVert = startVert + j;
if (clockwise)
{
sw.WriteLine($"f {initVerts[0]}/{initVerts[0]}/{initVerts[0]} {initVerts[1]}/{initVerts[1]}/{initVerts[1]} {currVert}/{currVert}/{currVert}");
}
else
{
sw.WriteLine($"f {currVert}/{currVert}/{currVert} {initVerts[1]}/{initVerts[1]}/{initVerts[1]} {initVerts[0]}/{initVerts[0]}/{initVerts[0]}");
}
initVerts[1] = currVert;
initVertPos = 0;
}
clockwise = !clockwise;
}
}
else if (elem.GifTagIndex == 4) // Triangle strips
{
for (int j = 0; j < elem.Vertices.Count; ++j)
{
int currVert = startVert + j;
if ((elem.Vertices[j].W.Packed & 0x00008000) == 0)
{
if (clockwise)
{
sw.WriteLine($"f {initVerts[0]}/{initVerts[0]}/{initVerts[0]} {initVerts[1]}/{initVerts[1]}/{initVerts[1]} {currVert}/{currVert}/{currVert}");
}
else
{
sw.WriteLine($"f {currVert}/{currVert}/{currVert} {initVerts[1]}/{initVerts[1]}/{initVerts[1]} {initVerts[0]}/{initVerts[0]}/{initVerts[0]}");
}
}
initVerts[0] = initVerts[1];
initVerts[1] = currVert;
clockwise = !clockwise;
}
}
else
{
throw new NotSupportedException("Unknown face construction type");
}
startVert += elem.Vertices.Count;
sw.WriteLine();
}
return(startVert);
}