protected override IList <TF.Core.TranslationEntities.Subtitle> GetSubtitles()
{
var result = new List <TF.Core.TranslationEntities.Subtitle>();
using (var fs = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fs, FileEncoding, Endianness.BigEndian))
{
input.Skip(3);
var count = input.ReadByte();
input.Skip(4);
var pointer1 = input.ReadInt32();
var countPointer1 = input.ReadInt16();
var numTalkers = input.ReadInt16();
var pointerTalkers = input.ReadInt32();
var pointerRemainder = input.ReadInt32();
for (var i = 0; i < count; i++)
{
input.Skip(4);
var groupOffset = input.ReadInt32();
input.Skip(1);
var stringCount = input.ReadByte();
input.Skip(6);
var subs = ReadSubtitles(input, groupOffset, stringCount);
if (subs.Count > 0)
{
result.AddRange(subs);
}
}
if (pointerTalkers > 0 && result.Count > 0)
{
input.Seek(pointerTalkers, SeekOrigin.Begin);
for (var i = 0; i < numTalkers; i++)
{
var offset = input.ReadInt32();
var subtitle = ReadSubtitle(input, offset, true);
if (subtitle != null)
{
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
}
}
}
}
LoadChanges(result);
return(result);
}
public static void Extract(string inputPath, string outputFolder)
{
Directory.CreateDirectory(outputFolder);
var logFile = System.IO.Path.Combine(outputFolder, "Extract_Data.tf");
using (var fs = new FileStream(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var input = new ExtendedBinaryReader(fs, Encoding.UTF8, Endianness.BigEndian))
using (var log = new ExtendedBinaryWriter(new FileStream(logFile, FileMode.Create), Encoding.UTF8, Endianness.BigEndian))
{
var numFiles = input.ReadInt16();
log.Write((int)numFiles);
log.Write(input.ReadBytes(6));
for (var i = 0; i < numFiles; i++)
{
input.Seek(8 + i * 16, SeekOrigin.Begin);
var unknown = input.ReadInt32();
log.Write(unknown);
var offsetMsg = input.ReadInt32();
var offsetRemainder = input.ReadInt32();
log.Write(offsetMsg == 0 ? 0 : 1);
log.Write(offsetRemainder == 0 ? 0 : 1);
var sizeMsg = input.ReadInt16();
var sizeRemainder = input.ReadInt16();
if (offsetMsg > 0)
{
input.Seek(offsetMsg, SeekOrigin.Begin);
var msg = input.ReadBytes(sizeMsg);
var msgFile = Path.Combine(outputFolder, $"{i:0000}.msg");
File.WriteAllBytes(msgFile, msg);
}
if (offsetRemainder > 0)
{
log.Write((int)sizeRemainder);
input.Seek(offsetRemainder, SeekOrigin.Begin);
var remainder = input.ReadBytes(sizeRemainder);
log.Write(remainder);
}
}
}
}
// Methods
public override void Read(ExtendedBinaryReader reader)
{
// PACx Header
string sig = reader.ReadSignature(4);
if (sig != PACxSignature)
{
throw new InvalidSignatureException(PACxSignature, sig);
}
// Version String
string verString = reader.ReadSignature(3);
if (!ushort.TryParse(verString, out Version))
{
throw new InvalidSignatureException(PACxSignature + Version, sig + verString);
}
reader.IsBigEndian = IsBigEndian =
(reader.ReadChar() == BigEndianFlag);
ID = reader.ReadUInt32();
FileSize = reader.ReadUInt32();
RootOffset = reader.ReadUInt32();
RootCompressedLength = reader.ReadUInt32();
RootLength = reader.ReadUInt32();
var flags = reader.ReadInt16();
HasDependencies = (flags & 0x2) != 0;
HasCompressedBlocks = (flags & 0x1) != 0;
ushort uk1 = reader.ReadUInt16();
if (!HasCompressedBlocks && uk1 != UnknownConstant)
{
Console.WriteLine($"WARNING: Unknown1 != 0x108! ({uk1})");
}
else if (HasCompressedBlocks && uk1 != UnknownConstant1)
{
Console.WriteLine($"WARNING: Unknown1 != 0x208! ({uk1})");
}
if ((flags & 0x80) != 0)
{
DependencyEntriesLength = reader.ReadUInt32();
CompressedChunksLength = reader.ReadUInt32();
StringTableLength = reader.ReadUInt32();
FinalTableLength = reader.ReadUInt32();
Length = LengthWithFlags;
}
else
{
Length = LengthWithoutFlags;
}
reader.Offset = Length;
}
protected override IList <Subtitle> GetSubtitles()
{
var result = new List <Subtitle>();
using (var fs = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fs, FileEncoding))
{
while (input.Position < input.Length)
{
var nextOffset = input.ReadInt16();
var sectionName = input.ReadString(Encoding.UTF8);
var aux = input.PeekInt16();
while (aux != -1)
{
input.Skip(2);
var subtitle = ReadSubtitle(input);
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
aux = input.PeekInt16();
}
input.Skip(2);
}
}
LoadChanges(result);
return(result);
}
private static object ReadValueType(Type valueType, ExtendedBinaryReader br, bool noAlign = false)
{
if (!noAlign)
{
br.AlignStream();
}
if (valueType == typeof(string))
{
return(br.ReadAlignedString());
}
else if (valueType == typeof(Int32))
{
return(br.ReadInt32());
}
else if (valueType == typeof(UInt32))
{
return(br.ReadUInt32());
}
else if (valueType == typeof(Int64))
{
return(br.ReadInt64());
}
else if (valueType == typeof(UInt64))
{
return(br.ReadUInt64());
}
else if (valueType == typeof(Int16))
{
return(br.ReadInt16());
}
else if (valueType == typeof(UInt16))
{
return(br.ReadUInt16());
}
else if (valueType == typeof(Byte))
{
return(br.ReadByte());
}
else if (valueType == typeof(SByte))
{
return(br.ReadSByte());
}
else if (valueType == typeof(Boolean))
{
return(br.ReadBoolean());
}
else if (valueType == typeof(Double))
{
return(br.ReadDouble());
}
else if (valueType == typeof(Single))
{
return(br.ReadSingle());
}
else
{
throw new ArgumentException($"{valueType} is not a value type");
}
}
public override void Rebuild(string outputFolder)
{
var outputPath = System.IO.Path.Combine(outputFolder, RelativePath);
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(outputPath));
var subtitles = GetSubtitles();
using (var fsInput = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fsInput, FileEncoding, Endianness.BigEndian))
using (var fsOutput = new FileStream(outputPath, FileMode.Create))
using (var output = new ExtendedBinaryWriter(fsOutput, FileEncoding, Endianness.BigEndian))
{
output.Write(input.ReadBytes(6));
var groupCount = input.ReadInt16();
output.Write(groupCount);
output.Write(input.ReadBytes(4));
var groupsOffset = input.ReadInt32();
output.Write(groupsOffset);
long outputOffset = input.PeekInt32();
var firstStringOffset = outputOffset;
while (input.Position < groupsOffset)
{
var offset = input.ReadInt32();
if (offset > 0 && offset < input.Length)
{
outputOffset = WriteSubtitle(output, subtitles, offset, outputOffset);
}
else
{
output.Write(offset);
}
}
output.Write(input.ReadBytes((int)(groupsOffset - (int)input.Position)));
for (var i = 0; i < groupCount; i++)
{
var offsets = new int[_groupSize];
for (var j = 0; j < _groupSize; j++)
{
offsets[j] = input.ReadInt32();
}
for (var j = 0; j < 6; j++)
{
output.Write(offsets[j]);
}
outputOffset = WriteSubtitle(output, subtitles, offsets[6], outputOffset);
output.Write(offsets[7]);
}
output.Write(input.ReadBytes((int)(firstStringOffset - input.Position)));
}
}
protected override IList <Subtitle> GetSubtitles()
{
var result = new List <Subtitle>();
using (var fs = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fs, FileEncoding, Endianness.BigEndian))
{
input.Skip(6);
var groupCount = input.ReadInt16();
input.Skip(8);
Subtitle subtitle;
for (var i = 0; i < 43; i++)
{
subtitle = ReadSubtitle(input);
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
}
// barkeeper
input.Seek(0x108, SeekOrigin.Begin);
subtitle = ReadSubtitle(input);
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
input.Seek(0x110, SeekOrigin.Begin);
for (var i = 0; i < groupCount; i++)
{
var offsets = new int[22];
for (var j = 0; j < 22; j++)
{
offsets[j] = input.ReadInt32();
}
var returnPos = input.Position;
subtitle = ReadSubtitle(input, offsets[8], false);
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
for (var j = 14; j < 22; j++)
{
subtitle = ReadSubtitle(input, offsets[j], false);
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
}
input.Seek(returnPos, SeekOrigin.Begin);
}
}
LoadChanges(result);
return(result);
}
private void Load_Xex(string filename)
{
Xex_Name = Path.GetFileName(filename);
Xex_File = File.ReadAllBytes(filename);
RenderingRes_X_TextBox.Enabled = true;
RenderingRes_Y_TextBox.Enabled = true;
GammaColor_R_TextBox.Enabled = true;
GammaColor_G_TextBox.Enabled = true;
GammaColor_B_TextBox.Enabled = true;
SaveXex.Enabled = true;
RestoreOriginalResBtn.Enabled = true;
RestoreOriginalGammaBtn.Enabled = true;
DisableGammaCorrectionBtn.Enabled = true;
using (MemoryStream file = new MemoryStream(Xex_File))
using (ExtendedBinaryReader read = new ExtendedBinaryReader(file, true))
{
// Get Rendering Res -- In Order Of Xex File
file.Seek(0xBA5026, SeekOrigin.Begin);
RenderingRes_Y = read.ReadInt16();
file.Seek(0xBA502A, SeekOrigin.Begin);
RenderingRes_X = read.ReadInt16();
//Get Gamma Color -- In Order Of Xex File
file.Seek(0x1277450, SeekOrigin.Begin);
GammaColor_R = read.ReadSingle();
file.Seek(0x1277454, SeekOrigin.Begin);
GammaColor_G = read.ReadSingle();
file.Seek(0x1277458, SeekOrigin.Begin);
GammaColor_B = read.ReadSingle();
}
RenderingRes_X_TextBox.Text = RenderingRes_X.ToString();
RenderingRes_Y_TextBox.Text = RenderingRes_Y.ToString();
GammaColor_R_TextBox.Text = GammaColor_R.ToString();
GammaColor_G_TextBox.Text = GammaColor_G.ToString();
GammaColor_B_TextBox.Text = GammaColor_B.ToString();
}
public override void Rebuild(string outputFolder)
{
var outputPath = System.IO.Path.Combine(outputFolder, RelativePath);
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(outputPath));
var subtitles = GetSubtitles();
using (var fsInput = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fsInput, FileEncoding, Endianness.LittleEndian))
using (var fsOutput = new FileStream(outputPath, FileMode.Create))
using (var output = new ExtendedBinaryWriter(fsOutput, FileEncoding, Endianness.LittleEndian))
{
var outputOffset = 0;
while (input.Position < input.Length)
{
var inputNextOffset = input.ReadInt16();
var sectionName = input.ReadString(Encoding.UTF8);
using (var tempMemoryStream = new MemoryStream())
using (var temp = new ExtendedBinaryWriter(tempMemoryStream, FileEncoding, Endianness.LittleEndian))
{
temp.WriteString(sectionName);
var aux = input.PeekInt16();
while (aux != -1)
{
var index = input.ReadByte();
temp.Write(index);
var size = input.ReadByte();
var offset = (int)input.Position;
WriteSubtitle(temp, subtitles, offset);
input.ReadString();
aux = input.PeekInt16();
}
input.Skip(2);
temp.Write((short)-1);
var bytes = tempMemoryStream.ToArray();
output.Write((short)(outputOffset + 2 + bytes.Length));
output.Write(bytes);
outputOffset = outputOffset + 2 + bytes.Length;
}
}
}
}
protected override IList <Subtitle> GetSubtitles()
{
var result = new List <Subtitle>();
using (var fs = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fs, FileEncoding, Endianness.BigEndian))
{
input.Skip(6);
var groupCount = input.ReadInt16();
input.Skip(4);
var groupsOffset = input.ReadInt32();
Subtitle subtitle;
while (input.Position < groupsOffset)
{
var subtitleOffset = input.ReadInt32();
if (subtitleOffset > 0 && subtitleOffset < input.Length)
{
input.Seek(-4, SeekOrigin.Current);
subtitle = ReadSubtitle(input);
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
}
}
input.Seek(groupsOffset, SeekOrigin.Begin);
for (var i = 0; i < groupCount; i++)
{
var offsets = new int[_groupSize];
for (var j = 0; j < _groupSize; j++)
{
offsets[j] = input.ReadInt32();
}
var returnPos = input.Position;
subtitle = ReadSubtitle(input, offsets[6], false);
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
input.Seek(returnPos, SeekOrigin.Begin);
}
}
LoadChanges(result);
return(result);
}
// Methods
public override void Load(Stream fileStream)
{
// Header
var reader = new ExtendedBinaryReader(fileStream, Encoding.ASCII, false);
string sig = reader.ReadSignature();
if (sig != Signature)
{
throw new InvalidSignatureException(Signature, sig);
}
// Textures
uint totalFrameCount = reader.ReadUInt32();
byte textureCount = reader.ReadByte();
for (int i = 0; i < textureCount; ++i)
{
Textures.Add(new Texture()
{
FilePath = reader.ReadString(),
Unknown1 = reader.ReadByte()
});
}
// Animations
ushort animCount = reader.ReadUInt16();
for (int i2 = 0; i2 < animCount; ++i2)
{
var anim = new Animation()
{
Name = reader.ReadString()
};
ushort frameCount = reader.ReadUInt16();
anim.Unknown1 = reader.ReadInt16();
anim.Unknown2 = reader.ReadInt16();
// Animation Frames
for (int i3 = 0; i3 < frameCount; ++i3)
{
anim.Frames.Add(new Frame()
{
TextureIndex = reader.ReadByte(),
Unknown1 = reader.ReadInt16(),
Unknown2 = reader.ReadInt16(),
X = reader.ReadUInt16(),
Y = reader.ReadUInt16(),
Width = reader.ReadUInt16(),
Height = reader.ReadUInt16(),
OriginX = reader.ReadInt16(),
OriginY = reader.ReadInt16()
});
}
Animations.Add(anim);
}
}
public override Instruction Read(ExtendedBinaryReader reader)
{
var instruction = new InstructionIf();
short amount = reader.ReadInt16();
instruction.Arguments.Add(reader.ReadInt32());
for (int i = 0; i < amount; ++i)
{
uint left = reader.ReadUInt32();
uint right = reader.ReadUInt32();
var compareOp = (Comparison.ComparisonOperators)reader.ReadByte();
instruction.Comparisons.Add(new Comparison(left, compareOp, right));
}
return(instruction);
}
private void LoadHeader()
{
var identifier = _reader.ReadString();
if (identifier != PhylopCommon.Header)
{
throw new InvalidDataException("Unrecognized file header: " + identifier);
}
var schemaVersion = _reader.ReadInt16();
if (schemaVersion != PhylopCommon.SchemaVersion)
{
throw new InvalidDataException("Expected phylop schema version:" + PhylopCommon.SchemaVersion + " observed schema version: " + schemaVersion);
}
var dataVersion = _reader.ReadInt16();
if (dataVersion != PhylopCommon.DataVersion)
{
Console.WriteLine("WARNING: Expected phylop data version:" + PhylopCommon.DataVersion + " observed data version: " + dataVersion);
}
_genomeAssembly = (GenomeAssembly)_reader.ReadByte();
_version = DataSourceVersion.Read(_reader);
// skip the reference name
_reader.ReadString();
_intervalListPosition = _reader.ReadInt64();
CheckGuard();
LoadChromosomeIntervals();
IsInitialized = true;
}
public override void ReadData(ExtendedBinaryReader input)
{
var startPos = input.Position;
for (var i = 0; i < DataCount; i++)
{
var from = input.ReadInt16();
var str = input.ReadString();
var info = new Info {
From = @from, Value = str, TranslatedValue = str, LoadedValue = str
};
_data.Add(info);
}
_remainder = input.ReadBytes((int)(startPos + Size - input.Position));
}
public static object ReadByType(ExtendedBinaryReader reader, ArgumentType type)
{
switch (type)
{
case AT_Bool:
return(reader.ReadBoolean());
case AT_Byte:
return(reader.ReadByte());
case AT_Int16:
return(reader.ReadInt16());
case AT_Int32:
return(reader.ReadInt32());
case AT_Float:
return(reader.ReadSingle());
case AT_String:
return(reader.ReadStringElsewhere());
case AT_StringPtr:
return(reader.ReadNullTerminatedStringPointer());
case AT_CodePointer:
return(reader.ReadInt32());
case AT_DataReference:
return(reader.ReadUInt32());
case AT_DataBlock:
long position = reader.ReadUInt32();
long length = reader.ReadUInt32();
if (reader.Offset > position)
{
reader.Offset = (uint)position;
}
return(new StreamBlock(position, length));
default:
return(null);
}
}
private IList <Subtitle> ReadSubtitles(ExtendedBinaryReader input, long groupOffset, int count)
{
var result = new List <Subtitle>();
var returnPos = input.Position;
input.Seek(groupOffset, SeekOrigin.Begin);
for (var i = 0; i < count; i++)
{
var strLength = input.ReadInt16();
var propCount = input.ReadByte();
var zero = input.ReadByte();
var strOffset = input.ReadInt32();
var propOffset = input.ReadInt32();
var sub = ReadSubtitle(input, strOffset, true);
if (sub != null)
{
var subtitle = new Subtitle(sub);
subtitle.PropertyChanged += SubtitlePropertyChanged;
var stringCharCount = subtitle.CleanText().Length;
subtitle.Properties = ReadProperties(input, propOffset, propCount);
foreach (var property in subtitle.Properties)
{
if (property.Position == stringCharCount)
{
property.IsEndProperty = true;
}
}
result.Add(subtitle);
}
}
input.Seek(returnPos, SeekOrigin.Begin);
return(result);
}
/*
* public TypeTree(TypeTree parent, uint format, int version, bool isArray, int size, int index, int flags, string type, string name)
* {
* this.parent = parent;
* this.format = format;
*
* this.version = version;
* this.isArray = isArray;
* this.size = size;
* this.index = index;
* this.flags = flags;
* this.type = type;
* this.name = name;
* }
*/
public static TypeTreeNode ReadTypeTree(uint format, ExtendedBinaryReader buf)
{
TypeTreeNode root = new TypeTreeNode();
if (format == 10 || format >= 12)
{
int nodesCount = buf.ReadInt32();
int stringBufferBytes = buf.ReadInt32();
int nodesize = format >= 19 ? 32 : 24;
buf.BaseStream.Seek(nodesize * nodesCount, SeekOrigin.Current);
byte[] stringData = buf.ReadBytes(stringBufferBytes);
buf.BaseStream.Seek(-(nodesize * nodesCount + stringBufferBytes), SeekOrigin.Current);
Stack <TypeTreeNode> stack = new Stack <TypeTreeNode>();
stack.Push(root);
using (var stringReader = new ExtendedBinaryReader(new MemoryStream(stringData)))
{
for (int i = 0; i < nodesCount; i++)
{
short version = buf.ReadInt16();
byte depth = buf.ReadByte();
bool isArray = buf.ReadBoolean();
ushort typeIndex = buf.ReadUInt16();
string typeStr;
if (buf.ReadUInt16() == 0)
{
stringReader.BaseStream.Position = typeIndex;
typeStr = stringReader.ReadNullTerminatedString();
}
else
{
typeStr = baseStrings.ContainsKey(typeIndex) ? baseStrings[typeIndex] : typeIndex.ToString();
}
ushort nameIndex = buf.ReadUInt16();
string nameStr;
if (buf.ReadUInt16() == 0)
{
stringReader.BaseStream.Position = nameIndex;
nameStr = stringReader.ReadNullTerminatedString();
}
else
{
nameStr = baseStrings.ContainsKey(nameIndex) ? baseStrings[nameIndex] : nameIndex.ToString();
}
int size = buf.ReadInt32();
int index = buf.ReadInt32();
int flags = buf.ReadInt32();
ulong refTypeHash = 0;
if (format >= 19)
{
refTypeHash = buf.ReadUInt64();
}
TypeTreeNode t;
if (depth == 0)
{
t = root;
}
else
{
while (stack.Count > depth)
{
stack.Pop();
}
t = new TypeTreeNode();
stack.Peek().children.Add(t);
stack.Push(t);
}
t.version = version;
t.isArray = isArray;
t.type = typeStr;
t.name = nameStr;
t.size = size;
t.index = index;
t.flags = flags;
t.refTypeHash = refTypeHash;
}
}
buf.BaseStream.Seek(stringBufferBytes, SeekOrigin.Current);
}
else
{
root.type = buf.ReadNullTerminatedString();
root.name = buf.ReadNullTerminatedString();
root.size = buf.ReadInt32();
root.index = buf.ReadInt32();
root.isArray = buf.ReadBoolean();
root.version = buf.ReadInt32();
root.flags = buf.ReadInt32();
int childCount = buf.ReadInt32();
for (int i = 0; i < childCount; i++)
{
root.children.Add(TypeTreeNode.ReadTypeTree(format, buf));
}
}
return(root);
}
public override object Read(ExtendedBinaryReader reader) => Lookup(reader.ReadInt16());
public override void Rebuild(string outputFolder)
{
var outputPath = System.IO.Path.Combine(outputFolder, RelativePath);
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(outputPath));
var subtitles = GetSubtitles();
using (var fsInput = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fsInput, FileEncoding, Endianness.BigEndian))
using (var fsOutput = new FileStream(outputPath, FileMode.Create))
using (var output = new ExtendedBinaryWriter(fsOutput, FileEncoding, Endianness.BigEndian))
{
output.Write(input.ReadBytes(6));
var groupCount = input.ReadInt16();
output.Write(groupCount);
output.Write(input.ReadBytes(8));
long outputOffset = input.PeekInt32();
var firstStringOffset = outputOffset;
for (var i = 0; i < 43; i++)
{
var offset = input.ReadInt32();
outputOffset = WriteSubtitle(output, subtitles, offset, outputOffset);
}
output.Write(input.ReadBytes(0x108 - (int)input.Position));
// barkeeper
var barKeeperOffset = input.ReadInt32();
outputOffset = WriteSubtitle(output, subtitles, barKeeperOffset, outputOffset);
output.Write(input.ReadBytes(0x110 - (int)input.Position));
for (var i = 0; i < groupCount; i++)
{
var offsets = new int[22];
for (var j = 0; j < 22; j++)
{
offsets[j] = input.ReadInt32();
}
for (var j = 0; j < 8; j++)
{
output.Write(offsets[j]);
}
outputOffset = WriteSubtitle(output, subtitles, offsets[8], outputOffset);
for (var j = 9; j < 14; j++)
{
output.Write(offsets[j]);
}
for (var j = 14; j < 22; j++)
{
outputOffset = WriteSubtitle(output, subtitles, offsets[j], outputOffset);
}
}
output.Write(input.ReadBytes((int)(firstStringOffset - input.Position)));
}
}
public override void Rebuild(string outputFolder)
{
var outputPath = System.IO.Path.Combine(outputFolder, RelativePath);
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(outputPath));
var subtitles = GetSubtitles();
using (var fsInput = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fsInput, FileEncoding, Endianness.BigEndian))
using (var fsOutput = new FileStream(outputPath, FileMode.Create))
using (var output = new ExtendedBinaryWriter(fsOutput, FileEncoding, Endianness.BigEndian))
{
output.Write(input.ReadBytes(3));
var count = input.ReadByte();
output.Write(count);
output.Write(input.ReadBytes(4));
var inputPointer1 = input.ReadInt32();
var inputCountPointer1 = input.ReadInt16();
var dataPointer1 = new byte[inputCountPointer1 * 16];
if (inputCountPointer1 > 0)
{
input.Seek(inputPointer1, SeekOrigin.Begin);
dataPointer1 = input.ReadBytes(inputCountPointer1 * 16);
input.Seek(14, SeekOrigin.Begin);
}
output.Write(0); // Si no es 0, ya lo rellenaré luego
output.Write(inputCountPointer1);
var numTalkers = input.ReadInt16();
output.Write(numTalkers);
var inputPointerTalkers = input.ReadInt32();
output.Write(0); // Si no es 0, ya lo rellenaré luego
var inputPointerRemainder = input.ReadInt32();
output.Write(0); // Si no es 0, ya lo rellenaré luego
using (var unknownMemoryStream = new MemoryStream())
using (var outputUnknown = new ExtendedBinaryWriter(unknownMemoryStream, FileEncoding, Endianness.BigEndian))
using (var propertiesMemoryStream = new MemoryStream())
using (var outputProperties = new ExtendedBinaryWriter(propertiesMemoryStream, FileEncoding, Endianness.BigEndian))
using (var stringsMemoryStream = new MemoryStream())
using (var outputStrings = new ExtendedBinaryWriter(stringsMemoryStream, FileEncoding, Endianness.BigEndian))
{
var stringLengths = new List <short>();
var stringOffsets = new List <int>();
var propertiesCount = new List <byte>();
var propertiesOffsets = new List <int>();
var unknownOffsets = new List <int>();
var unknownSectionOffset = 0;
var strOffset = 0;
var propOffset = 0;
var totalStrCount = 0;
for (var i = 0; i < count; i++)
{
input.Seek(0x18 + i * 0x10, SeekOrigin.Begin);
var unknownOffset = input.ReadInt32();
output.Write(0); // Si no es 0, ya lo rellenaré luego
var groupOffset = input.ReadInt32();
output.Write(groupOffset);
var unknownCount = input.ReadByte();
output.Write(unknownCount);
var stringCount = input.ReadByte();
output.Write(stringCount);
totalStrCount += stringCount;
output.Write(input.ReadBytes(6));
if (unknownOffset != 0)
{
var returnPos = input.Position;
input.Seek(unknownOffset, SeekOrigin.Begin);
outputUnknown.Write(input.ReadBytes(unknownCount * 12));
unknownOffsets.Add(unknownSectionOffset);
unknownSectionOffset = (int)outputUnknown.Position;
input.Seek(returnPos, SeekOrigin.Begin);
}
else
{
unknownOffsets.Add(-1);
}
input.Seek(groupOffset, SeekOrigin.Begin);
for (var j = 0; j < stringCount; j++)
{
var inputStringLength = input.ReadInt16();
var inputPropertiesCount = input.ReadByte();
var zero = input.ReadByte();
var inputStringOffset = input.ReadInt32();
var inputPropertiesOffset = input.ReadInt32();
if (inputStringLength == 0)
{
stringLengths.Add(0);
propertiesCount.Add(inputPropertiesCount);
stringOffsets.Add(strOffset);
propertiesOffsets.Add(propOffset);
outputStrings.WriteString(string.Empty);
strOffset = (int)outputStrings.Position;
var ret = input.Position;
input.Seek(inputPropertiesOffset, SeekOrigin.Begin);
var prop = input.ReadBytes(inputPropertiesCount * 16);
input.Seek(ret, SeekOrigin.Begin);
outputProperties.Write(prop);
propOffset = (int)outputProperties.Position;
}
else
{
var sub = (Subtitle)subtitles.First(x => x.Offset == inputStringOffset);
stringLengths.Add((short)FileEncoding.GetByteCount(sub.Translation));
propertiesCount.Add((byte)sub.TranslationProperties.Count);
stringOffsets.Add(strOffset);
propertiesOffsets.Add(propOffset);
outputStrings.WriteString(sub.Translation);
strOffset = (int)outputStrings.Position;
outputProperties.Write(sub.TranslationProperties.ToByteArray());
propOffset = (int)outputProperties.Position;
}
}
}
var unknownBytes = unknownMemoryStream.ToArray();
var propertiesBytes = propertiesMemoryStream.ToArray();
var stringsBytes = stringsMemoryStream.ToArray();
var propBase = (int)output.Position + totalStrCount * 12;
var unknownBase = propBase + propertiesBytes.Length;
var strBase = unknownBase + unknownBytes.Length;
var outputReturnPos = output.Position;
for (var i = 0; i < count; i++)
{
output.Seek(0x18 + i * 0x10, SeekOrigin.Begin);
if (unknownOffsets[i] >= 0)
{
output.Write(unknownOffsets[i] + unknownBase);
}
}
output.Seek(outputReturnPos, SeekOrigin.Begin);
for (var i = 0; i < totalStrCount; i++)
{
output.Write(stringLengths[i]);
output.Write(propertiesCount[i]);
output.Write((byte)0);
output.Write(stringOffsets[i] + strBase);
output.Write(propertiesOffsets[i] + propBase);
}
output.Write(propertiesBytes);
if (unknownBytes.Length > 0)
{
output.Write(unknownBytes);
}
output.Write(stringsBytes);
output.WritePadding(4);
}
if (inputPointer1 > 0)
{
var outputPointer1 = (int)output.Position;
output.Seek(8, SeekOrigin.Begin);
output.Write(outputPointer1);
output.Seek(outputPointer1, SeekOrigin.Begin);
output.Write(dataPointer1);
}
if (inputPointerTalkers > 0)
{
var outputPointerTalkers = (int)output.Position;
output.Seek(16, SeekOrigin.Begin);
output.Write(outputPointerTalkers);
output.Seek(outputPointerTalkers, SeekOrigin.Begin);
input.Seek(inputPointerTalkers, SeekOrigin.Begin);
using (var stringsMemoryStream = new MemoryStream())
using (var outputStrings =
new ExtendedBinaryWriter(stringsMemoryStream, FileEncoding, Endianness.BigEndian))
{
var baseOffset = (int)output.Position + numTalkers * 4;
var strOffset = baseOffset;
for (var i = 0; i < numTalkers; i++)
{
var offset = input.ReadInt32();
var sub = subtitles.FirstOrDefault(x => x.Offset == offset);
output.Write(strOffset);
if (sub != null)
{
outputStrings.WriteString(sub.Translation);
}
else
{
outputStrings.WriteString(string.Empty);
}
strOffset = baseOffset + (int)outputStrings.Position;
}
output.Write(stringsMemoryStream.ToArray());
}
}
if (inputPointerRemainder > 0)
{
var outputPointerRemainder = (int)output.Position;
output.Seek(20, SeekOrigin.Begin);
output.Write(outputPointerRemainder);
output.Seek(outputPointerRemainder, SeekOrigin.Begin);
input.Seek(inputPointerRemainder, SeekOrigin.Begin);
var data = input.ReadBytes((int)(input.Length - inputPointerRemainder));
output.Write(data);
}
}
}
/// <summary>
/// Reads a SEAnim from a stream
/// </summary>
/// <param name="Stream">The stream to read from</param>
/// <returns>A SEAnim if successful, otherwise throws an error and returns null</returns>
public static SEModel Read(Stream Stream)
{
// Create a new model
var model = new SEModel();
// Setup a new reader
using (ExtendedBinaryReader readFile = new ExtendedBinaryReader(Stream))
{
// Magic
var Magic = readFile.ReadChars(7);
// Version
var Version = readFile.ReadInt16();
// Header size
var HeaderSize = readFile.ReadInt16();
// Check magic
if (!Magic.SequenceEqual(new char[] { 'S', 'E', 'M', 'o', 'd', 'e', 'l' }))
{
// Bad file
throw new Exception("Bad SEModel file, magic was invalid");
}
// Data present flags
var DataPresentFlags = readFile.ReadByte();
// Bone data present flags
var BoneDataPresentFlags = readFile.ReadByte();
// Mesh data present flags
var MeshDataPresentFlags = readFile.ReadByte();
// Read counts
var BoneCount = readFile.ReadInt32();
var MeshCount = readFile.ReadInt32();
var MatCount = readFile.ReadInt32();
// Skip 3 reserved bytes
readFile.BaseStream.Position += 3;
// Read bone tag names
List <string> BoneNames = new List <string>();
// Loop
for (int i = 0; i < BoneCount; i++)
{
BoneNames.Add(readFile.ReadNullTermString());
}
// Loop and read bones
for (int i = 0; i < BoneCount; i++)
{
// Read bone flags (unused)
var BoneFlags = readFile.ReadByte();
// Read bone index
var ParentIndex = readFile.ReadInt32();
// Check for global matricies
Vector3 GlobalPosition = Vector3.Zero;
Quaternion GlobalRotation = Quaternion.Identity;
// Check
if (Convert.ToBoolean(BoneDataPresentFlags & (byte)SEModel_BoneDataPresenceFlags.SEMODEL_PRESENCE_GLOBAL_MATRIX))
{
GlobalPosition = new Vector3(readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle());
GlobalRotation = new Quaternion(readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle());
}
// Check for local matricies
Vector3 LocalPosition = Vector3.Zero;
Quaternion LocalRotation = Quaternion.Identity;
// Check
if (Convert.ToBoolean(BoneDataPresentFlags & (byte)SEModel_BoneDataPresenceFlags.SEMODEL_PRESENCE_LOCAL_MATRIX))
{
LocalPosition = new Vector3(readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle());
LocalRotation = new Quaternion(readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle());
}
// Check for scales
Vector3 Scale = Vector3.One;
// Check
if (Convert.ToBoolean(BoneDataPresentFlags & (byte)SEModel_BoneDataPresenceFlags.SEMODEL_PRESENCE_SCALES))
{
Scale = new Vector3(readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle());
}
// Add the bone
model.AddBone(BoneNames[i], ParentIndex, GlobalPosition, GlobalRotation, LocalPosition, LocalRotation, Scale);
}
// Loop and read meshes
for (int i = 0; i < MeshCount; i++)
{
// Make a new submesh
var mesh = new SEModelMesh();
// Read mesh flags (unused)
var MeshFlags = readFile.ReadByte();
// Read counts
var MatIndiciesCount = readFile.ReadByte();
var MaxSkinInfluenceCount = readFile.ReadByte();
var VertexCount = readFile.ReadInt32();
var FaceCount = readFile.ReadInt32();
// Loop and read positions
for (int v = 0; v < VertexCount; v++)
{
mesh.AddVertex(new SEModelVertex()
{
Position = new Vector3(readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle())
});
}
// Read uvlayers
if (Convert.ToBoolean(MeshDataPresentFlags & (byte)SEModel_MeshDataPresenceFlags.SEMODEL_PRESENCE_UVSET))
{
for (int v = 0; v < VertexCount; v++)
{
for (int l = 0; l < MatIndiciesCount; l++)
{
mesh.Verticies[v].UVSets.Add(new Vector2(readFile.ReadSingle(), readFile.ReadSingle()));
}
}
}
// Read normals
if (Convert.ToBoolean(MeshDataPresentFlags & (byte)SEModel_MeshDataPresenceFlags.SEMODEL_PRESENCE_NORMALS))
{
// Loop and read vertex normals
for (int v = 0; v < VertexCount; v++)
{
mesh.Verticies[v].VertexNormal = new Vector3(readFile.ReadSingle(), readFile.ReadSingle(), readFile.ReadSingle());
}
}
// Read colors
if (Convert.ToBoolean(MeshDataPresentFlags & (byte)SEModel_MeshDataPresenceFlags.SEMODEL_PRESENCE_COLOR))
{
// Loop and read colors
for (int v = 0; v < VertexCount; v++)
{
mesh.Verticies[v].VertexColor = new Color(readFile.ReadByte(), readFile.ReadByte(), readFile.ReadByte(), readFile.ReadByte());
}
}
// Read weights
if (Convert.ToBoolean(MeshDataPresentFlags & (byte)SEModel_MeshDataPresenceFlags.SEMODEL_PRESENCE_WEIGHTS))
{
for (int v = 0; v < VertexCount; v++)
{
// Read IDs and Values
for (int l = 0; l < MaxSkinInfluenceCount; l++)
{
if (BoneCount <= 0xFF)
{
mesh.Verticies[v].Weights.Add(new SEModelWeight()
{
BoneIndex = readFile.ReadByte(), BoneWeight = readFile.ReadSingle()
});
}
else if (BoneCount <= 0xFFFF)
{
mesh.Verticies[v].Weights.Add(new SEModelWeight()
{
BoneIndex = readFile.ReadUInt16(), BoneWeight = readFile.ReadSingle()
});
}
else
{
mesh.Verticies[v].Weights.Add(new SEModelWeight()
{
BoneIndex = readFile.ReadUInt32(), BoneWeight = readFile.ReadSingle()
});
}
}
}
}
// Loop and read faces
for (int f = 0; f < FaceCount; f++)
{
if (VertexCount <= 0xFF)
{
mesh.AddFace(readFile.ReadByte(), readFile.ReadByte(), readFile.ReadByte());
}
else if (VertexCount <= 0xFFFF)
{
mesh.AddFace(readFile.ReadUInt16(), readFile.ReadUInt16(), readFile.ReadUInt16());
}
else
{
mesh.AddFace(readFile.ReadUInt32(), readFile.ReadUInt32(), readFile.ReadUInt32());
}
}
// Read material reference indicies
for (int f = 0; f < MatIndiciesCount; f++)
{
mesh.AddMaterialIndex(readFile.ReadInt32());
}
// Add the mesh
model.AddMesh(mesh);
}
// Loop and read materials
for (int m = 0; m < MatCount; m++)
{
var mat = new SEModelMaterial();
// Read the name
mat.Name = readFile.ReadNullTermString();
// Read IsSimpleMaterial
var IsSimpleMaterial = readFile.ReadBoolean();
// Read the material
if (IsSimpleMaterial)
{
mat.MaterialData = new SEModelSimpleMaterial()
{
DiffuseMap = readFile.ReadNullTermString(),
NormalMap = readFile.ReadNullTermString(),
SpecularMap = readFile.ReadNullTermString()
};
}
// Add the material
model.AddMaterial(mat);
}
}
// Return result
return(model);
}
public override void Read(ExtendedBinaryReader reader, Action <short> synchronizationCallback)
{
synchronizationCallback(reader.ReadInt16());
}
public override void Deserialize(ExtendedBinaryReader reader, Action <short> valueFixup)
{
valueFixup(reader.ReadInt16());
}
public TypeMetaData(uint format, ExtendedBinaryReader buf)
{
if (format >= 13)
{
hasTypeTrees = buf.ReadBoolean();
int types_count = buf.ReadInt32();
for (int i = 0; i < types_count; i++)
{
int classID = buf.ReadInt32();
int scriptID;
if (format >= 17)
{
byte unk0 = buf.ReadByte();
scriptID = -1 - buf.ReadInt16();
}
else
{
scriptID = classID;
}
ClassIDs.Add(new ClassInfo {
scriptID = scriptID, classID = classID
});
byte[] hash;
if ((format < 16 && classID < 0) || (format >= 16 && classID == 114))
{
hash = buf.ReadBytes(0x20);
}
else
{
hash = buf.ReadBytes(0x10);
}
Hashes[classID] = hash;
if (hasTypeTrees)
{
TypeTrees.Add(classID, TypeTreeNode.ReadTypeTree(format, buf));
if (format >= 21)
{
int dependenciesCount = buf.ReadInt32();
var TypeDependencies = (int[])buf.ReadValueArray <int>(dependenciesCount);
}
}
}
}
else
{
int fieldsCount = buf.ReadInt32();
for (int i = 0; i < fieldsCount; i++)
{
int classID = buf.ReadInt32();
TypeTrees.Add(classID, TypeTreeNode.ReadTypeTree(format, buf));
}
}
}
