/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
ID = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(8));
/* Skip reserved bytes*/
Header.Stream.Reader.BaseStream.Seek(4, SeekOrigin.Current);
Origin = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
PointOnXAxis = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
PointInXYPlane = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementZ = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementY = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementX = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementPitch = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementRoll = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementYaw = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementScaleZ = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementScaleY = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
MinMaxCurrentIncrementScaleX = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
Flags = Header.Stream.Reader.ReadInt32();
// Apply the dof origin to our GO position so we can pivot using the GO transform as you would expect to.
// DuckbearLab: FIX! Put this in comment?!?
//Position = new Vector3((float)Origin[0], (float)Origin[1], (float)Origin[2]);
// TODO: Can DOF have a matrix? This would mess the origin up if they can, maybe apply in the import function?
// Parse children
base.Parse();
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
// Parse colors, 1024 in total
Colors = new PaletteColor[1024];
for (int i = 0; i < 1024; ++i)
{
//Colors[i] = new PaletteColor();
Colors[i].Color.a = Header.Stream.Reader.ReadByte();
Colors[i].Color.b = Header.Stream.Reader.ReadByte();
Colors[i].Color.g = Header.Stream.Reader.ReadByte();
Colors[i].Color.r = Header.Stream.Reader.ReadByte();
}
// Do we have color names?
if (Length > 4228)
{
int numColNames = Header.Stream.Reader.ReadInt32();
for (int i = 0; i < numColNames; ++i)
{
short len = Header.Stream.Reader.ReadInt16();
Header.Stream.Reader.BaseStream.Seek(2, SeekOrigin.Current); // Skip reserved
short index = Header.Stream.Reader.ReadInt16();
Header.Stream.Reader.BaseStream.Seek(2, SeekOrigin.Current); // Skip reserved
if (len > 8 && index >= 0 && index < Colors.Length)
{
Colors[index].Name = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(len - 8));
}
}
}
}
public override void Read(Vault vault, BinaryReader br)
{
while (br.BaseStream.Position < EndOffset)
{
string str = NullTerminatedString.Read(br);
HashManager.AddVLT(str);
}
}
public void ReadPointerData(Vault vault, BinaryReader br)
{
br.BaseStream.Position = _typeNames;
foreach (var t in vault.Database.Types)
{
t.Name = NullTerminatedString.Read(br);
HashManager.AddVLT(t.Name);
}
}
public void WritePointerData(Vault vault, BinaryWriter bw)
{
_typeNamesDst = bw.BaseStream.Position;
foreach (var type in vault.Database.Types)
{
NullTerminatedString.Write(bw, type.Name);
}
bw.AlignWriter(8);
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
ID = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(8));
Flags = Header.Stream.Reader.ReadInt32();
RelativePriority = Header.Stream.Reader.ReadInt16();
Transparency = Header.Stream.Reader.ReadUInt16();
SpecialEffectID1 = Header.Stream.Reader.ReadInt16();
SpecialEffectID2 = Header.Stream.Reader.ReadInt16();
// Ignore last 2 reserved bytes.
// Parse children
base.Parse();
}
/// <summary>
/// Parses a header record.
/// </summary>
/// <returns></returns>
private bool HandleHeader()
{
ID = NullTerminatedString.GetAsString(Stream.Reader.ReadBytes(8));
FormatRevisionLevel = Stream.Reader.ReadInt32();
EditRevisionLevel = Stream.Reader.ReadInt32();
DateTimeLastRevision = NullTerminatedString.GetAsString(Stream.Reader.ReadBytes(32));
NextGroupNodeID = Stream.Reader.ReadInt16();
NextLODNodeID = Stream.Reader.ReadInt16();
NextObjectNodeID = Stream.Reader.ReadInt16();
NextFaceNodeID = Stream.Reader.ReadInt16();
UnitMultiplier = Stream.Reader.ReadInt16();
VertexCoordinateUnits = ( VertexCoordinateUnits )Stream.Reader.ReadByte();
TexWhite = Stream.Reader.ReadBoolean();
Flags = Stream.Reader.ReadInt32();
/* Skip reserved bytes*/ Stream.Reader.BaseStream.Seek(24, SeekOrigin.Current);
ProjectionType = ( Projection )Stream.Reader.ReadInt32();
/* Skip reserved bytes*/ Stream.Reader.BaseStream.Seek(28, SeekOrigin.Current);
NextDegreeOfFreedomNodeID = Stream.Reader.ReadInt16();
VertexStorageType = ( VertexStorageType )Stream.Reader.ReadInt16();
DatabaseOrigin = ( DatabaseOrigin )Stream.Reader.ReadInt32();
SouthwestDatabaseCoordinate = new double[] { Stream.Reader.ReadDouble(), Stream.Reader.ReadDouble() };
DeltaToPlaceDatabase = new double[] { Stream.Reader.ReadDouble(), Stream.Reader.ReadDouble(), 0 }; // z is read later in the stream
NextSoundNodeID = Stream.Reader.ReadInt16();
NextPathNodeID = Stream.Reader.ReadInt16();
/* Skip reserved bytes*/ Stream.Reader.BaseStream.Seek(8, SeekOrigin.Current);
NextClipNodeID = Stream.Reader.ReadInt16();
NextTextNodeID = Stream.Reader.ReadInt16();
NextBSPNodeID = Stream.Reader.ReadInt16();
NextSwitchNodeID = Stream.Reader.ReadInt16();
/* Skip reserved bytes*/ Stream.Reader.BaseStream.Seek(4, SeekOrigin.Current);
SouthWestCornerLatLon = new double[] { Stream.Reader.ReadDouble(), Stream.Reader.ReadDouble() };
NorthEastCornerLatLon = new double[] { Stream.Reader.ReadDouble(), Stream.Reader.ReadDouble() };
OriginLatLon = new double[] { Stream.Reader.ReadDouble(), Stream.Reader.ReadDouble() };
LambertLatLon = new double[] { Stream.Reader.ReadDouble(), Stream.Reader.ReadDouble() };
NextLightSourceNodeID = Stream.Reader.ReadInt16();
NextLightPointNodeID = Stream.Reader.ReadInt16();
NextRoadNodeID = Stream.Reader.ReadInt16();
NextCATNodeID = Stream.Reader.ReadInt16();
/* Skip reserved bytes*/ Stream.Reader.BaseStream.Seek(8, SeekOrigin.Current);
EarthEllipsoidModel = ( EarthEllipsoidModel )Stream.Reader.ReadInt32();
NextAdaptiveNodeID = Stream.Reader.ReadInt16();
NextCurveNodeID = Stream.Reader.ReadInt16();
UTMZone = Stream.Reader.ReadInt16();
/* Skip reserved bytes*/ Stream.Reader.BaseStream.Seek(6, SeekOrigin.Current);
DeltaToPlaceDatabase[2] = Stream.Reader.ReadDouble(); // Read z
NextMeshNodeID = Stream.Reader.ReadUInt16();
NextLightPointSystemNodeID = Stream.Reader.ReadUInt16();
/* Skip reserved bytes*/ Stream.Reader.BaseStream.Seek(4, SeekOrigin.Current);
EarthAxis = new double[] { Stream.Reader.ReadDouble(), Stream.Reader.ReadDouble() };
return(true);
}
public IList <Vault> Load(BinaryReader br, Database database, PackLoadingOptions loadingOptions)
{
ByteOrder byteOrder = loadingOptions?.ByteOrder ?? ByteOrder.Little;
// check for VPAK header
AttribVaultPackImage vaultPackImage = new AttribVaultPackImage();
vaultPackImage.Read(null, br);
br.BaseStream.Position = vaultPackImage.Header.StringBlockOffset;
List <Vault> vaults = new List <Vault>();
foreach (AttribVaultPackEntry attribVaultPackEntry in vaultPackImage.Entries)
{
br.BaseStream.Position = vaultPackImage.Header.StringBlockOffset + attribVaultPackEntry.VaultNameOffset;
Vault vault = new Vault(NullTerminatedString.Read(br));
br.BaseStream.Seek(attribVaultPackEntry.BinOffset, SeekOrigin.Begin);
byte[] binData = new byte[attribVaultPackEntry.BinSize];
if (br.Read(binData, 0, binData.Length) != binData.Length)
{
throw new Exception($"Failed to read {binData.Length} bytes of BIN data");
}
br.BaseStream.Seek(attribVaultPackEntry.VltOffset, SeekOrigin.Begin);
byte[] vltData = new byte[attribVaultPackEntry.VltSize];
if (br.Read(vltData, 0, vltData.Length) != vltData.Length)
{
throw new Exception($"Failed to read {vltData.Length} bytes of VLT data");
}
vault.BinStream = new MemoryStream(binData);
vault.VltStream = new MemoryStream(vltData);
using (VaultLoadingWrapper loadingWrapper = new VaultLoadingWrapper(vault, byteOrder))
{
database.LoadVault(vault, loadingWrapper);
}
vaults.Add(vault);
}
return(vaults);
}
public override void Read(FrontendPackage package, FrontendChunkBlock chunkBlock, FrontendChunkReader chunkReader, BinaryReader reader)
{
Names = new Dictionary <long, string>();
while (reader.BaseStream.Position < chunkBlock.EndOffset)
{
long pos = reader.BaseStream.Position;
var str = NullTerminatedString.Read(reader);
if (!string.IsNullOrEmpty(str))
{
Names[pos - chunkBlock.DataOffset] = str;
}
}
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
ID = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(8));
IRColorCode = Header.Stream.Reader.ReadInt32();
RelativePriority = Header.Stream.Reader.ReadInt16();
DrawType = (DrawType)Header.Stream.Reader.ReadSByte();
TexWhite = Header.Stream.Reader.ReadBoolean();
ColorNameIndex = Header.Stream.Reader.ReadUInt16();
AlternateColorIndex = Header.Stream.Reader.ReadUInt16();
/* Skip reserved bytes*/
Header.Stream.Reader.BaseStream.Seek(1, SeekOrigin.Current);
TemplateBillboard = (TemplateBillboard)Header.Stream.Reader.ReadSByte();
DetailTexturePattern = Header.Stream.Reader.ReadInt16();
TexturePattern = Header.Stream.Reader.ReadInt16();
MaterialIndex = Header.Stream.Reader.ReadInt16();
SurfaceMaterialCode = Header.Stream.Reader.ReadInt16();
FeatureID = Header.Stream.Reader.ReadInt16();
IRMaterialCode = Header.Stream.Reader.ReadInt32();
Transparency = Header.Stream.Reader.ReadUInt16();
LODGenerationControl = Header.Stream.Reader.ReadByte();
LineStyleIndex = Header.Stream.Reader.ReadByte();
Flags = Header.Stream.Reader.ReadInt32();
LightMode = (LightMode)Header.Stream.Reader.ReadByte();
/* Skip reserved bytes*/
Header.Stream.Reader.BaseStream.Seek(7, SeekOrigin.Current);
Color32 c = new Color32();
c.a = Header.Stream.Reader.ReadByte();
c.b = Header.Stream.Reader.ReadByte();
c.g = Header.Stream.Reader.ReadByte();
c.r = Header.Stream.Reader.ReadByte();
PackedColorPrimary = c;
c.a = Header.Stream.Reader.ReadByte();
c.b = Header.Stream.Reader.ReadByte();
c.g = Header.Stream.Reader.ReadByte();
c.r = Header.Stream.Reader.ReadByte();
PackedColorAlternate = c;
TextureMappingIndex = Header.Stream.Reader.ReadInt16();
/* Skip reserved bytes*/
Header.Stream.Reader.BaseStream.Seek(2, SeekOrigin.Current);
PrimaryColorIndex = Header.Stream.Reader.ReadUInt32();
AlternateColorIndex = Header.Stream.Reader.ReadUInt32();
/* Skip reserved bytes*/
Header.Stream.Reader.BaseStream.Seek(2, SeekOrigin.Current);
ShaderIndex = Header.Stream.Reader.ReadInt16();
// Parse children
base.Parse();
}
/// <summary>
/// Parses binary stream.
/// </summary>
/// <param name="db">Database this material is part of.</param>
public void Parse(Database db)
{
Index = db.Stream.Reader.ReadInt32();
ID = NullTerminatedString.GetAsString(db.Stream.Reader.ReadBytes(12)); // Name of material
Flags = db.Stream.Reader.ReadInt32();
Ambient = new Color(db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle());
Diffuse = new Color(db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle());
Specular = new Color(db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle());
Emissive = new Color(db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle(), db.Stream.Reader.ReadSingle());
Shininess = db.Stream.Reader.ReadSingle(); // Also apply it to the alpha channel.
Specular = new Color(Specular.r, Specular.g, Specular.b, Shininess / 128f); // Use the shininess in the specular alpha channel.
Alpha = db.Stream.Reader.ReadSingle();
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
//return;
Path = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(200));
Header.Stream.Reader.BaseStream.Seek(4, SeekOrigin.Current); // Skip reserved.
Flags = Header.Stream.Reader.ReadInt32();
ViewAsBoundingBox = Header.Stream.Reader.ReadInt16() == 1 ? true : false;
// Find the file
AbsolutePath = FileFinder.Instance.Find(Path);
if (AbsolutePath != string.Empty)
{
ID = "Ref: " + Path;
if (!Header.ExternalReferencesBank.Contains(Path))
{
Header.ExternalReferencesBank.Add(Path, this);
Reference = new Database(AbsolutePath, this, Header.Settings);
// Override
//if( FlagsColorPaletteOverridden ) Reference.ColorPalette = Header.ColorPalette;
//if( FlagsMaterialPaletteOverridden ) Reference.MaterialPalettes = Header.MaterialPalettes;
//if( FlagsTexturePaletteOverridden ) Reference.TexturePalettes = Header.TexturePalettes;
// TODO: implement overrides for other records that are not currently implemented.
if (FlagsMaterialPaletteOverridden || FlagsTexturePaletteOverridden)
{
Reference.MaterialBank = Header.MaterialBank; // Share material bank.
}
Reference.ExternalReferencesBank = Header.ExternalReferencesBank;
if (!ID.StartsWith("Ref: tree"))
{
Reference.Parse();
}
}
}
else
{
ID = "Broken Ref: " + Path;
Log.WriteError("Could not find external reference: " + Path);
}
base.Parse();
}
public override void Write(Vault vault, BinaryWriter bw)
{
Assembly currentAssembly = Assembly.GetAssembly(typeof(Database));
AssemblyMetadataAttribute metadataAttribute =
currentAssembly.GetCustomAttributes <AssemblyMetadataAttribute>().First(m => m.Key == "GitHash");
Strings.Insert(0, "Generated by VaultBoy by heyitsleo");
Strings.Insert(1, $"{metadataAttribute.Value} | {DateTime.Now:s}");
foreach (string s in Strings)
{
vault.SaveContext.StringOffsets[s] = bw.BaseStream.Position;
NullTerminatedString.Write(bw, s);
}
bw.AlignWriter(0x10);
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
ID = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(8));
/* Skip reserved bytes*/
Header.Stream.Reader.BaseStream.Seek(4, SeekOrigin.Current);
SwitchInDistance = Header.Stream.Reader.ReadDouble();
SwitchOutDistance = Header.Stream.Reader.ReadDouble();
SpecialEffectID1 = Header.Stream.Reader.ReadInt16();
SpecialEffectID2 = Header.Stream.Reader.ReadInt16();
Flags = Header.Stream.Reader.ReadInt32();
Center = new double[] { Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble(), Header.Stream.Reader.ReadDouble() };
TransitionRange = Header.Stream.Reader.ReadDouble();
SignificantSize = Header.Stream.Reader.ReadDouble();
// Parse children
base.Parse();
}
public static unsafe void Cmd_OpenFile(SystemMessage *msg)
{
//var addr = msg->Arg1;
//var str = (NullTerminatedString*)addr;
//var path = str->ToString();
//var path = ((NullTerminatedString*)msg->Arg1)->ToString();
var path = NullTerminatedString.ToString((byte *)msg->Arg1);
if (TraceFileIO)
{
Console.Write("Open File: ");
Console.WriteLine(path);
}
var file = FindFile(path);
if (file == null)
{
Console.Write("File not found: ");
//Console.WriteLine(length.ToString("X"));
Console.WriteLine(path.Length.ToString("X"));
Console.WriteLine(path);
Console.WriteLine(">>");
MessageManager.Send(new SystemMessage(SysCallTarget.ServiceReturn, FileHandle.Zero));
return;
}
var openFile = new OpenFile()
{
Handle = ++lastHandle,
Path = path,
ProcessId = -1,
Buffer = file.Buffer,
};
OpenFiles.Add(openFile);
if (TraceFileIO)
{
Console.WriteLine("Created Handle: " + ((uint)openFile.Handle).ToString("X"));
}
MessageManager.Send(new SystemMessage(SysCallTarget.ServiceReturn, openFile.Handle));
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
ID = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(8));
RelativePriority = Header.Stream.Reader.ReadInt16();
Header.Stream.Reader.BaseStream.Seek(2, SeekOrigin.Current); // Skip reserved
Flags = Header.Stream.Reader.ReadInt32();
SpecialEffectID1 = Header.Stream.Reader.ReadInt16();
SpecialEffectID2 = Header.Stream.Reader.ReadInt16();
Significance = Header.Stream.Reader.ReadInt16();
LayerCode = Header.Stream.Reader.ReadSByte();
Header.Stream.Reader.BaseStream.Seek(5, SeekOrigin.Current); // Skip reserved
LoopCount = Header.Stream.Reader.ReadInt32();
LoopDuration = Header.Stream.Reader.ReadSingle();
LastFrameDuration = Header.Stream.Reader.ReadSingle();
// Parse children
base.Parse();
}
public static unsafe void Cmd_CreateFiFo(SystemMessage *msg)
{
var path = NullTerminatedString.ToString((byte *)msg->Arg1);
var fifo = new FifoFile()
{
};
var vfsFile = new VfsFile
{
Path = path,
Buffer = fifo,
};
Files.Add(vfsFile);
MessageManager.Send(new SystemMessage(SysCallTarget.ServiceReturn));
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(DependencyNames.Count);
if (vault.SaveContext.HashMode == VaultHashMode.Hash64)
{
bw.Write(0);
}
foreach (var dependencyName in DependencyNames)
{
var hash = vault.SaveContext.StringHash(dependencyName);
if (vault.SaveContext.HashMode == VaultHashMode.Hash64)
{
bw.Write(hash);
}
else
{
bw.Write((uint)hash);
}
}
var nameOffsets = new Dictionary <string, int>();
var nameOffset = 0;
foreach (var dependencyName in DependencyNames)
{
nameOffsets[dependencyName] = nameOffset;
nameOffset += dependencyName.Length + 1;
}
foreach (var dependencyName in DependencyNames)
{
bw.Write(nameOffsets[dependencyName]);
}
foreach (var dependencyName in DependencyNames)
{
NullTerminatedString.Write(bw, dependencyName);
}
bw.AlignWriter(0x10);
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
ID = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(8));
/* Skip reserved bytes*/
Header.Stream.Reader.BaseStream.Seek(4, SeekOrigin.Current);
Index = Header.Stream.Reader.ReadInt32();
int numMasks = Header.Stream.Reader.ReadInt32();
/* Skip #words per mask, we'll assume its 1 32bit word per mask for now*/
Header.Stream.Reader.BaseStream.Seek(4, SeekOrigin.Current);
Masks = new int[numMasks];
for (int i = 0; i < numMasks; i++)
{
Masks[i] = Header.Stream.Reader.ReadInt32();
}
// Parse children
base.Parse();
}
//////////////////////////////////////////////////////////////////////
/// <summary>
/// Reads the file header.
/// </summary>
//////////////////////////////////////////////////////////////////////
void ReadHeader()
{
Stream s = new FileStream(File, FileMode.Open);
_Reader = BitConverter.IsLittleEndian ? new BinaryReaderBigEndian(s) : new BinaryReader(s);
try
{
// Magic number
if (_Reader.ReadInt16() != 474)
{
throw new Exception("Invalid file, the file header does not contain the correct magic number(474)");
}
RLE = _Reader.ReadSByte() == 1 ? true : false;
BPC = _Reader.ReadSByte();
Dimension = _Reader.ReadUInt16();
Size = new ushort[] { _Reader.ReadUInt16(), _Reader.ReadUInt16(), _Reader.ReadUInt16() };
PixMinMax = new int[] { _Reader.ReadInt32(), _Reader.ReadInt32() };
// Skip dummy data
_Reader.BaseStream.Seek(4, SeekOrigin.Current);
// Null terminated name.
Name = NullTerminatedString.GetAsString(_Reader.ReadBytes(80));
ColorMapID = _Reader.ReadInt32();
// Skip dummy data
_Reader.BaseStream.Seek(404, SeekOrigin.Current);
if (RLE)
{
ReadOffsets();
}
}
finally
{
_Reader.Close();
}
}
public override void Read(BinaryReader br)
{
this.Hash = br.ReadUInt32();
this.StringOffset = br.ReadUInt32();
if (this.StringOffset == 0)
{
this.Value = "(null)";
}
else
{
if (this.StringOffset > br.BaseStream.Length)
{
this.Value = "(offset is outta here)";
}
else
{
long position = br.BaseStream.Position;
br.BaseStream.Seek(this.StringOffset, SeekOrigin.Begin);
this.Value = NullTerminatedString.Read(br);
br.BaseStream.Seek(position, SeekOrigin.Begin);
}
}
}
public override void Read(BinaryReader br)
{
#if NEVEREVALUATESTOTRUE
StringOffset = Offset;
Value = NullTerminatedString.Read(br);
#else
this.StringOffset = br.ReadUInt32();
if (this.StringOffset > br.BaseStream.Length)
{
this.StringOffset = this.Offset;
}
if (this.StringOffset == 0)
{
this.Value = "(null)";
}
else
{
long position = br.BaseStream.Position;
br.BaseStream.Seek(this.StringOffset, SeekOrigin.Begin);
this.Value = NullTerminatedString.Read(br);
br.BaseStream.Seek(position, SeekOrigin.Begin);
}
#endif
}
public static FileHandle OpenFile(MemoryRegion buf, string path)
{
NullTerminatedString.Set((byte *)buf.Start, path);
return((int)MessageManager.Send(SysCallTarget.OpenFile, buf.Start));
}
/// <summary>
/// Parses binary stream.
/// </summary>
/// <param name="db">Database that this vertex is part of.</param>
public void Parse(Database db)
{
FileName = NullTerminatedString.GetAsString(db.Stream.Reader.ReadBytes(200));
Index = db.Stream.Reader.ReadInt32();
Location = new int[] { db.Stream.Reader.ReadInt32(), db.Stream.Reader.ReadInt32() };
}
public IList <Vault> Load(BinaryReader br, Database database, PackLoadingOptions loadingOptions = null)
{
if (br.ReadUInt32() != 0x73795341)
{
throw new InvalidDataException("Cannot process this stream: Invalid header magic");
}
uint numFiles = br.ReadUInt32();
if (numFiles != 2)
{
throw new InvalidDataException("Cannot process this stream: Invalid file count");
}
uint nameTableLength = br.ReadUInt32();
br.ReadUInt32();
uint vltSize = br.ReadUInt32();
br.ReadUInt32();
uint vltOffset = br.ReadUInt32();
br.ReadUInt32();
uint binSize = br.ReadUInt32();
br.ReadUInt32();
uint binOffset = br.ReadUInt32();
br.ReadUInt32();
var fileNames = new List <string>();
for (int i = 0; i < numFiles; i++)
{
fileNames.Add(NullTerminatedString.Read(br));
}
long endOffset = br.BaseStream.Position;
byte[] vltData = new byte[vltSize];
br.BaseStream.Position = endOffset + vltOffset;
if (br.Read(vltData, 0, vltData.Length) != vltData.Length)
{
throw new Exception("could not read VLT data");
}
byte[] binData = new byte[binSize];
br.BaseStream.Position = endOffset + binOffset;
if (br.Read(binData, 0, binData.Length) != binData.Length)
{
throw new Exception("could not read BIN data");
}
Vault vault = new Vault(fileNames[0].Substring(0, fileNames[0].IndexOf('.')))
{
BinStream = new MemoryStream(binData),
VltStream = new MemoryStream(vltData)
};
using (VaultLoadingWrapper loadingWrapper = new VaultLoadingWrapper(vault, loadingOptions?.ByteOrder ?? ByteOrder.Little))
{
database.LoadVault(vault, loadingWrapper);
}
return(new ReadOnlyCollection <Vault>(new List <Vault>(new[] { vault })));
}
/// <summary>
/// Parses binary stream.
/// </summary>
public override void Parse()
{
ID = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(8));
base.Parse();
}
/// <summary>
/// Parses a record comment.
/// </summary>
/// <returns></returns>
protected bool HandleComment()
{
Comment = NullTerminatedString.GetAsString(Header.Stream.Reader.ReadBytes(Header.Stream.Length - 4)); // The comment is the length of the record minus its header of 4 bytes.
return(true);
}
public void Save(BinaryWriter bw, IList <Vault> vaults, PackSavingOptions savingOptions = null)
{
Dictionary <string, VaultStreamInfo> streamDictionary = new Dictionary <string, VaultStreamInfo>();
foreach (var vault in vaults)
{
VaultWriter vaultWriter = new VaultWriter(vault, new VaultSaveOptions());
streamDictionary[vault.Name] = vaultWriter.BuildVault();
}
// empty header for now
bw.Write(new byte[16]);
Dictionary <string, int> nameOffsets = new Dictionary <string, int>();
int nameOffset = 0;
foreach (var databaseVault in vaults)
{
nameOffsets[databaseVault.Name] = nameOffset;
nameOffset += databaseVault.Name.Length + 1;
}
bw.Write(nameOffset);
bw.Write(new byte[20 * vaults.Count]);
bw.AlignWriter(0x40);
var nameTablePos = bw.BaseStream.Position;
foreach (var databaseVault in vaults)
{
NullTerminatedString.Write(bw, databaseVault.Name);
}
bw.AlignWriter(0x80);
List <long> binOffsets = new List <long>();
List <long> vltOffsets = new List <long>();
foreach (var vault in vaults)
{
bw.AlignWriter(0x80);
var streamInfo = streamDictionary[vault.Name];
binOffsets.Add(bw.BaseStream.Position);
streamInfo.BinStream.CopyTo(bw.BaseStream);
bw.AlignWriter(0x80);
vltOffsets.Add(bw.BaseStream.Position);
streamInfo.VltStream.CopyTo(bw.BaseStream);
}
bw.BaseStream.Position = 0;
// write header
AttribVaultPackImage vpi = new AttribVaultPackImage();
AttribVaultPackHeader header = new AttribVaultPackHeader
{
NumEntries = (uint)vaults.Count,
StringBlockOffset = (uint)nameTablePos,
StringBlockSize = (uint)nameOffset
};
vpi.Header = header;
vpi.Entries = new List <AttribVaultPackEntry>();
for (int i = 0; i < vaults.Count; i++)
{
Vault vault = vaults[i];
var streamInfo = streamDictionary[vault.Name];
AttribVaultPackEntry entry = new AttribVaultPackEntry
{
BinOffset = (uint)binOffsets[i],
VltOffset = (uint)vltOffsets[i],
BinSize = (uint)streamInfo.BinStream.Length,
VltSize = (uint)streamInfo.VltStream.Length,
VaultNameOffset = (uint)nameOffsets[vault.Name]
};
vpi.Entries.Add(entry);
}
vpi.Write(null, bw);
}
public void ReadPointerData(Vault vault, BinaryReader br)
{
Debug.Assert(Pointer != 0);
br.BaseStream.Position = Pointer;
Value = NullTerminatedString.Read(br);
}
public int FileWrite(NullTerminatedString str, FileHandle stream)
{
throw new NotImplementedException();
}
