protected override void ReadChunks(long totalSize)
{
if (BinaryReader.BaseStream.Length == 0)
{
return;
}
var curPos = BinaryReader.BaseStream.Position;
if (BinaryReader.ReadChar() == 'J' &&
BinaryReader.ReadChar() == 'D' &&
BinaryReader.ReadChar() == 'L' &&
BinaryReader.ReadChar() == 'Z')
{
#if DEBUG
Console.WriteLine("JDLZ compressed!");
#endif
BinaryReader.BaseStream.Seek(curPos, SeekOrigin.Begin);
var data = new byte[BinaryReader.BaseStream.Length];
BinaryReader.BaseStream.Read(data, 0, data.Length);
var decompressed = JDLZ.Decompress(data);
var newName = _fileName + ".dejdlz";
var stream = new FileStream(newName, FileMode.CreateNew);
stream.Write(decompressed, 0, decompressed.Length);
stream.Close();
BinaryReader = new BinaryReader(new FileStream(newName, FileMode.Open));
File.Delete(newName);
}
else
{
BinaryReader.BaseStream.Seek(curPos, SeekOrigin.Begin);
}
var runTo = BinaryReader.BaseStream.Position + totalSize;
for (var i = 0;
i < 0xFFFF && BinaryReader.BaseStream.Position < runTo;
i++
)
{
var chunkId = BinaryReader.ReadUInt32();
var chunkSize = BinaryReader.ReadUInt32();
var chunkRunTo = BinaryReader.BaseStream.Position + chunkSize;
var normalizedId = (int)chunkId & 0xffffffff;
BinaryUtil.PrintID(BinaryReader, chunkId, normalizedId, chunkSize, GetType());
switch (normalizedId)
{
case (long)ChunkID.BCHUNK_TRACKSTREAMER_SECTIONS:
_dataModels.Add(new SectionListReadContainer(BinaryReader, FileName, chunkSize).Get());
break;
case (long)ChunkID.BCHUNK_SPEED_ELIGHT_CHUNKS:
{
_dataModels.Add(new LightListReadContainer(BinaryReader, FileName, chunkSize).Get());
break;
}
case (long)ChunkID.BCHUNK_SPEED_ESOLID_LIST_CHUNKS:
{
_dataModels.Add(new SolidListReadContainer(BinaryReader, FileName, chunkSize).Get());
break;
}
case (long)ChunkID.BCHUNK_SPEED_TEXTURE_PACK_LIST_CHUNKS:
{
_dataModels.Add(new TPKReadContainer(BinaryReader, FileName, chunkSize, false).Get());
break;
}
default:
_dataModels.Add(new NullModel(normalizedId, chunkSize, BinaryReader.BaseStream.Position));
if (DebugUtil.IsContainerChunk(chunkId))
{
ReadChunks(chunkSize);
}
break;
}
BinaryUtil.ValidatePosition(BinaryReader, chunkRunTo, GetType());
BinaryReader.BaseStream.Seek(chunkRunTo - BinaryReader.BaseStream.Position, SeekOrigin.Current);
}
}
public void EnsureCapacity(int appendLength)
{
BinaryUtil.EnsureCapacity(ref buffer, offset, appendLength);
}
public static int SerializeFromFormatter <TTypeResolver, T>(ref byte[] bytes, int startOffset, int offset, int index, T value)
where TTypeResolver : ITypeResolver, new()
{
BinaryUtil.WriteInt32(ref bytes, startOffset + (8 + 4 * index), offset - startOffset);
return(Formatter <TTypeResolver, T> .Default.Serialize(ref bytes, offset, value));
}
protected override void ReadChunks(long totalSize)
{
if (BinaryReader.BaseStream.Length == 0)
{
return;
}
var curPos = BinaryReader.BaseStream.Position;
if (BinaryReader.ReadChar() == 'J' &&
BinaryReader.ReadChar() == 'D' &&
BinaryReader.ReadChar() == 'L' &&
BinaryReader.ReadChar() == 'Z')
{
#if DEBUG
Console.WriteLine("JDLZ compressed!");
#endif
BinaryReader.BaseStream.Seek(curPos, SeekOrigin.Begin);
var data = new byte[BinaryReader.BaseStream.Length];
BinaryReader.BaseStream.Read(data, 0, data.Length);
var decompressed = JDLZ.Decompress(data);
var newName = _fileName + ".dejdlz";
var stream = new FileStream(newName, FileMode.CreateNew);
stream.Write(decompressed, 0, decompressed.Length);
stream.Close();
BinaryReader = new BinaryReader(new FileStream(newName, FileMode.Open));
File.Delete(newName);
}
else
{
BinaryReader.BaseStream.Seek(curPos, SeekOrigin.Begin);
}
var runTo = BinaryReader.BaseStream.Position + totalSize;
for (var i = 0;
i < 0xFFFF && BinaryReader.BaseStream.Position < runTo;
i++
)
{
var chunkId = BinaryReader.ReadUInt32();
var chunkSize = BinaryReader.ReadUInt32();
var chunkRunTo = BinaryReader.BaseStream.Position + chunkSize;
var normalizedId = (int)chunkId & 0xffffffff;
#if DEBUG
BinaryUtil.PrintID(BinaryReader, chunkId, normalizedId, chunkSize, GetType());
#endif
switch (normalizedId)
{
case (long)ChunkID.BCHUNK_CARINFO_ARRAY:
var carListContainer = new MWCarListReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(carListContainer.Get());
break;
case (long)ChunkID.BCHUNK_SPEED_TEXTURE_PACK_LIST_CHUNKS:
{
var tpkContainer = new TPKReadContainer(BinaryReader, _fileName, chunkSize, false);
_dataModels.Add(tpkContainer.Get());
break;
}
case (long)ChunkID.BCHUNK_SPEED_TEXTURE_PACK_LIST_CHUNKS_ANIM:
{
var tpkContainer = new AnimatedTPKReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(tpkContainer.Get());
break;
}
case (long)ChunkID.BCHUNK_SPEED_TEXTURE_PACK_LIST_CHUNKS_COMPRESSED:
{
var tpkContainer = new CompressedTPKReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(tpkContainer.Get());
break;
}
case (long)ChunkID.BCHUNK_LANGUAGE:
var languageContainer = new LanguageReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(languageContainer.Get());
break;
case (long)ChunkID.BCHUNK_TRACKINFO:
var trackListContainer = new TrackListReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(trackListContainer.Get());
break;
case (long)ChunkID.BCHUNK_TRACKSTREAMER_SECTIONS:
var sectionsContainer = new SectionListReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(sectionsContainer.Get());
break;
case (long)ChunkID.BCHUNK_SPEED_ESOLID_LIST_CHUNKS:
var solidListContainer = new SolidListReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(solidListContainer.Get());
break;
case (long)ChunkID.BCHUNK_FENG_PACKAGE:
{
var fngContainer = new FNGReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(fngContainer.Get());
break;
}
case (long)ChunkID.BCHUNK_FENG_PACKAGE_COMPRESSED:
{
var fngContainer = new CompressedFNGReadContainer(BinaryReader, _fileName, chunkSize);
_dataModels.Add(fngContainer.Get());
break;
}
default:
_dataModels.Add(new NullModel(normalizedId, chunkSize, BinaryReader.BaseStream.Position));
break;
}
BinaryUtil.ValidatePosition(BinaryReader, chunkRunTo, GetType());
BinaryReader.BaseStream.Seek(chunkRunTo - BinaryReader.BaseStream.Position, SeekOrigin.Current);
}
}
public void WriteQuotation()
{
BinaryUtil.EnsureCapacity(ref buffer, offset, 1);
buffer[offset++] = (byte)'\"';
}
static int GetExtraBytesOffset(byte[] extraBytes, int binaryLastIndex, int index)
{
var offset = (index - binaryLastIndex - 1) * 4;
return(BinaryUtil.ReadInt32(ref extraBytes, offset));
}
public void EnsureAdditionalCapacity(int appendLength) => BinaryUtil.EnsureCapacityArrayPool(ref buffer, length, appendLength);
public void WriteEndObject()
{
BinaryUtil.EnsureCapacity(ref buffer, offset, 1);
buffer[offset++] = (byte)'}';
}
public void Pack(byte[] buf, ref int offset)
{
buf[offset++] = AddressSize;
BinaryUtil.Write(Address, buf, ref offset);
BinaryUtil.Write(Port, buf, ref offset);
}
public void Binary2()
{
const int offset = 64;
var bytes = new byte[100];
bytes = new byte[100];
BinaryUtil.WriteBoolean(ref bytes, offset, true).Is(1);
BinaryUtil.ReadBoolean(ref bytes, offset).IsTrue();
bytes = new byte[100];
BinaryUtil.WriteByte(ref bytes, offset, (byte)234).Is(1);
BinaryUtil.ReadByte(ref bytes, offset).Is((byte)234);
bytes = new byte[100];
BinaryUtil.WriteChar(ref bytes, offset, 'z').Is(2);
BinaryUtil.ReadChar(ref bytes, offset).Is('z');
bytes = new byte[100];
var now = DateTime.Now.ToUniversalTime();
BinaryUtil.WriteDateTime(ref bytes, offset, now).Is(12);
BinaryUtil.ReadDateTime(ref bytes, offset).Is(now);
bytes = new byte[100];
BinaryUtil.WriteDecimal(ref bytes, offset, decimal.MaxValue).Is(16);
BinaryUtil.ReadDecimal(ref bytes, offset).Is(decimal.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteDouble(ref bytes, offset, double.MaxValue).Is(8);
BinaryUtil.ReadDouble(ref bytes, offset).Is(double.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteInt16(ref bytes, offset, short.MaxValue).Is(2);
BinaryUtil.ReadInt16(ref bytes, offset).Is(short.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteInt32(ref bytes, offset, int.MaxValue).Is(4);
BinaryUtil.ReadInt32(ref bytes, offset).Is(int.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteInt32Unsafe(ref bytes, offset, int.MaxValue);
BinaryUtil.ReadInt32(ref bytes, offset).Is(int.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteInt64(ref bytes, offset, long.MaxValue).Is(8);
BinaryUtil.ReadInt64(ref bytes, offset).Is(long.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteSByte(ref bytes, offset, sbyte.MaxValue).Is(1);
BinaryUtil.ReadSByte(ref bytes, offset).Is(sbyte.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteSingle(ref bytes, offset, Single.MaxValue).Is(4);
BinaryUtil.ReadSingle(ref bytes, offset).Is(Single.MaxValue);
bytes = new byte[100];
var c = BinaryUtil.WriteString(ref bytes, offset, "あいうえおかきくけこ");
BinaryUtil.ReadString(ref bytes, offset, c).Is("あいうえおかきくけこ");
var ts = new TimeSpan(14, 213, 41241);
bytes = new byte[100];
BinaryUtil.WriteTimeSpan(ref bytes, offset, ts).Is(12);
BinaryUtil.ReadTimeSpan(ref bytes, offset).Is(ts);
bytes = new byte[100];
BinaryUtil.WriteUInt16(ref bytes, offset, UInt16.MaxValue).Is(2);
BinaryUtil.ReadUInt16(ref bytes, offset).Is(UInt16.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteUInt32(ref bytes, offset, UInt32.MaxValue).Is(4);
BinaryUtil.ReadUInt32(ref bytes, offset).Is(UInt32.MaxValue);
bytes = new byte[100];
BinaryUtil.WriteUInt64(ref bytes, offset, UInt64.MaxValue).Is(8);
BinaryUtil.ReadUInt64(ref bytes, offset).Is(UInt64.MaxValue);
var guid = System.Guid.NewGuid();
bytes = new byte[100];
BinaryUtil.WriteGuid(ref bytes, offset, guid).Is(16);
BinaryUtil.ReadGuid(ref bytes, offset).Is(guid);
}
public override int Serialize(ref byte[] bytes, int offset, IList <T> value)
{
if (value == null)
{
BinaryUtil.WriteInt32(ref bytes, offset, -1);
return(4);
}
var segment = value as IZeroFormatterSegment;
if (segment != null)
{
return(segment.Serialize(ref bytes, offset));
}
var length = formatter.GetLength();
if (length != null)
{
// FixedSize Array
var writeSize = value.Count * length.Value + 4;
if (bytes == null)
{
bytes = new byte[writeSize];
}
offset += BinaryUtil.WriteInt32(ref bytes, offset, value.Count);
// Optimize iteration
var array = value as T[];
if (array != null)
{
for (int i = 0; i < array.Length; i++)
{
offset += formatter.Serialize(ref bytes, offset, array[i]);
}
}
else
{
var list = value as List <T>;
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
offset += formatter.Serialize(ref bytes, offset, list[i]);
}
}
else
{
foreach (var item in value)
{
offset += formatter.Serialize(ref bytes, offset, item);
}
}
}
return(writeSize);
}
else
{
var startoffset = offset;
var indexStartOffset = startoffset + 8;
offset = (startoffset + 8) + (value.Count * 4);
// Optimize iteration
var array = value as T[];
if (array != null)
{
for (int i = 0; i < array.Length; i++)
{
var size = formatter.Serialize(ref bytes, offset, array[i]);
BinaryUtil.WriteInt32Unsafe(ref bytes, indexStartOffset + i * 4, offset);
offset += size;
}
}
else
{
var list = value as List <T>;
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
var size = formatter.Serialize(ref bytes, offset, list[i]);
BinaryUtil.WriteInt32Unsafe(ref bytes, indexStartOffset + i * 4, offset);
offset += size;
}
}
else
{
var count = 0;
foreach (var item in value)
{
var size = formatter.Serialize(ref bytes, offset, item);
BinaryUtil.WriteInt32Unsafe(ref bytes, indexStartOffset + count * 4, offset);
offset += size;
count++;
}
}
}
BinaryUtil.WriteInt32(ref bytes, startoffset + 4, value.Count);
var totalBytes = offset - startoffset;
BinaryUtil.WriteInt32Unsafe(ref bytes, startoffset, totalBytes);
return(totalBytes);
}
}
protected virtual void OutputTexture(Texture texture, DDS.Header header, BinaryWriter writer)
{
writer.Write(0x20534444);
BinaryUtil.WriteStruct(writer, header);
writer.Write(texture.Data);
}
public void Initialize()
{
_binaryUtil = new BinaryUtil();
}
public void WriteRaw(byte rawValue)
{
BinaryUtil.EnsureCapacity(ref buffer, offset, 1);
buffer[offset++] = rawValue;
}
void ReadStringSegmentCore(out byte[] resultBytes, out int resultOffset, out int resultLength)
{
// SkipWhiteSpace is already called from IsNull
byte[] builder = null;
var builderOffset = 0;
char[] codePointStringBuffer = null;
var codePointStringOffet = 0;
if (bytes[offset] != '\"')
{
throw CreateParsingException("String Begin Token");
}
offset++;
var from = offset;
// eliminate array-bound check
for (int i = offset; i < bytes.Length; i++)
{
byte escapeCharacter = 0;
switch (bytes[i])
{
case (byte)'\\': // escape character
switch ((char)bytes[i + 1])
{
case '"':
case '\\':
case '/':
escapeCharacter = bytes[i + 1];
goto COPY;
case 'b':
escapeCharacter = (byte)'\b';
goto COPY;
case 'f':
escapeCharacter = (byte)'\f';
goto COPY;
case 'n':
escapeCharacter = (byte)'\n';
goto COPY;
case 'r':
escapeCharacter = (byte)'\r';
goto COPY;
case 't':
escapeCharacter = (byte)'\t';
goto COPY;
case 'u':
if (codePointStringBuffer == null)
{
codePointStringBuffer = StringBuilderCache.GetCodePointStringBuffer();
}
if (codePointStringOffet == 0)
{
if (builder == null)
{
builder = StringBuilderCache.GetBuffer();
}
var copyCount = i - from;
BinaryUtil.EnsureCapacity(ref builder, builderOffset, copyCount + 1); // require + 1
Buffer.BlockCopy(bytes, from, builder, builderOffset, copyCount);
builderOffset += copyCount;
}
if (codePointStringBuffer.Length == codePointStringOffet)
{
Array.Resize(ref codePointStringBuffer, codePointStringBuffer.Length * 2);
}
var a = (char)bytes[i + 2];
var b = (char)bytes[i + 3];
var c = (char)bytes[i + 4];
var d = (char)bytes[i + 5];
var codepoint = GetCodePoint(a, b, c, d);
codePointStringBuffer[codePointStringOffet++] = (char)codepoint;
i += 5;
offset += 6;
from = offset;
continue;
default:
throw CreateParsingExceptionMessage("Bad JSON escape.");
}
case (byte)'"': // endtoken
offset++;
goto END;
default: // string
if (codePointStringOffet != 0)
{
if (builder == null)
{
builder = StringBuilderCache.GetBuffer();
}
BinaryUtil.EnsureCapacity(ref builder, builderOffset, StringEncoding.UTF8.GetMaxByteCount(codePointStringOffet));
builderOffset += StringEncoding.UTF8.GetBytes(codePointStringBuffer, 0, codePointStringOffet, builder, builderOffset);
codePointStringOffet = 0;
}
offset++;
continue;
}
COPY:
{
if (builder == null)
{
builder = StringBuilderCache.GetBuffer();
}
if (codePointStringOffet != 0)
{
BinaryUtil.EnsureCapacity(ref builder, builderOffset, StringEncoding.UTF8.GetMaxByteCount(codePointStringOffet));
builderOffset += StringEncoding.UTF8.GetBytes(codePointStringBuffer, 0, codePointStringOffet, builder, builderOffset);
codePointStringOffet = 0;
}
var copyCount = i - from;
BinaryUtil.EnsureCapacity(ref builder, builderOffset, copyCount + 1); // require + 1!
Buffer.BlockCopy(bytes, from, builder, builderOffset, copyCount);
builderOffset += copyCount;
builder[builderOffset++] = escapeCharacter;
i += 1;
offset += 2;
from = offset;
}
}
resultLength = 0;
resultBytes = null;
resultOffset = 0;
throw CreateParsingException("String End Token");
END:
if (builderOffset == 0 && codePointStringOffet == 0) // no escape
{
resultBytes = bytes;
resultOffset = from;
resultLength = offset - 1 - from; // skip last quote
}
else
{
if (builder == null)
{
builder = StringBuilderCache.GetBuffer();
}
if (codePointStringOffet != 0)
{
BinaryUtil.EnsureCapacity(ref builder, builderOffset, StringEncoding.UTF8.GetMaxByteCount(codePointStringOffet));
builderOffset += StringEncoding.UTF8.GetBytes(codePointStringBuffer, 0, codePointStringOffet, builder, builderOffset);
codePointStringOffet = 0;
}
var copyCount = offset - from - 1;
BinaryUtil.EnsureCapacity(ref builder, builderOffset, copyCount);
Buffer.BlockCopy(bytes, from, builder, builderOffset, copyCount);
builderOffset += copyCount;
resultBytes = builder;
resultOffset = 0;
resultLength = builderOffset;
}
}
public void WriteEndArray()
{
BinaryUtil.EnsureCapacity(ref buffer, offset, 1);
buffer[offset++] = (byte)']';
}
public override int Serialize(ref byte[] bytes, int offset, HashCollision value)
{
BinaryUtil.WriteInt32(ref bytes, offset, value.identifier);
BinaryUtil.WriteInt32(ref bytes, offset, value.hashCode);
return(8);
}
public void WriteNameSeparator()
{
BinaryUtil.EnsureCapacity(ref buffer, offset, 1);
buffer[offset++] = (byte)':';
}
public static int SerializeCacheSegment <T>(ref byte[] targetBytes, int startOffset, int offset, int index, CacheSegment <T> segment)
{
BinaryUtil.WriteInt32(ref targetBytes, startOffset + (8 + 4 * index), offset);
return(segment.Serialize(ref targetBytes, offset));
}
public void WriteString(string value)
{
if (value == null)
{
WriteNull();
return;
}
// single-path escape
// nonescaped-ensure
var startoffset = offset;
var max = StringEncoding.UTF8.GetMaxByteCount(value.Length) + 2;
BinaryUtil.EnsureCapacity(ref buffer, startoffset, max);
var from = 0;
var to = value.Length;
buffer[offset++] = (byte)'\"';
// for JIT Optimization, for-loop i < str.Length
for (int i = 0; i < value.Length; i++)
{
byte escapeChar = default(byte);
switch (value[i])
{
case '"':
escapeChar = (byte)'"';
break;
case '\\':
escapeChar = (byte)'\\';
break;
case '\b':
escapeChar = (byte)'b';
break;
case '\f':
escapeChar = (byte)'f';
break;
case '\n':
escapeChar = (byte)'n';
break;
case '\r':
escapeChar = (byte)'r';
break;
case '\t':
escapeChar = (byte)'t';
break;
// use switch jumptable
case (char)0:
case (char)1:
case (char)2:
case (char)3:
case (char)4:
case (char)5:
case (char)6:
case (char)7:
case (char)11:
case (char)14:
case (char)15:
case (char)16:
case (char)17:
case (char)18:
case (char)19:
case (char)20:
case (char)21:
case (char)22:
case (char)23:
case (char)24:
case (char)25:
case (char)26:
case (char)27:
case (char)28:
case (char)29:
case (char)30:
case (char)31:
case (char)32:
case (char)33:
case (char)35:
case (char)36:
case (char)37:
case (char)38:
case (char)39:
case (char)40:
case (char)41:
case (char)42:
case (char)43:
case (char)44:
case (char)45:
case (char)46:
case (char)47:
case (char)48:
case (char)49:
case (char)50:
case (char)51:
case (char)52:
case (char)53:
case (char)54:
case (char)55:
case (char)56:
case (char)57:
case (char)58:
case (char)59:
case (char)60:
case (char)61:
case (char)62:
case (char)63:
case (char)64:
case (char)65:
case (char)66:
case (char)67:
case (char)68:
case (char)69:
case (char)70:
case (char)71:
case (char)72:
case (char)73:
case (char)74:
case (char)75:
case (char)76:
case (char)77:
case (char)78:
case (char)79:
case (char)80:
case (char)81:
case (char)82:
case (char)83:
case (char)84:
case (char)85:
case (char)86:
case (char)87:
case (char)88:
case (char)89:
case (char)90:
case (char)91:
default:
continue;
}
max += 2;
BinaryUtil.EnsureCapacity(ref buffer, startoffset, max); // check +escape capacity
offset += StringEncoding.UTF8.GetBytes(value, from, i - from, buffer, offset);
from = i + 1;
buffer[offset++] = (byte)'\\';
buffer[offset++] = escapeChar;
}
if (from != value.Length)
{
offset += StringEncoding.UTF8.GetBytes(value, from, value.Length - from, buffer, offset);
}
buffer[offset++] = (byte)'\"';
}
public void AddCharacter(byte str)
{
BinaryUtil.EnsureCapacity(ref buffer, offset, 1);
buffer[offset++] = str;
}
// Dirty Helpers...
public static int GetByteSize(ArraySegment <byte> originalBytes)
{
var array = originalBytes.Array;
return(BinaryUtil.ReadInt32(ref array, originalBytes.Offset));
}
public void AddStringSlow(string str)
{
BinaryUtil.EnsureCapacity(ref buffer, offset, StringEncoding.UTF8.GetMaxByteCount(str.Length));
offset += StringEncoding.UTF8.GetBytes(str, 0, str.Length, buffer, offset);
}
private IAggregate GetValueAggregate(ref JsonReader reader, IJsonFormatterResolver formatterResolver, IReadOnlyDictionary <string, object> meta)
{
var token = reader.GetCurrentJsonToken();
if (token == JsonToken.Number || token == JsonToken.Null)
{
var value = reader.ReadNullableDouble();
string valueAsString = null;
token = reader.GetCurrentJsonToken();
if (token != JsonToken.EndObject)
{
reader.ReadNext(); // ,
var propertyName = reader.ReadPropertyNameSegmentRaw();
if (propertyName.EqualsBytes(ValueAsStringField))
{
valueAsString = reader.ReadString();
token = reader.GetCurrentJsonToken();
if (token == JsonToken.EndObject)
{
return new ValueAggregate
{
Value = value,
ValueAsString = valueAsString,
Meta = meta
}
}
;
reader.ReadNext(); // ,
propertyName = reader.ReadPropertyNameSegmentRaw();
}
if (propertyName.EqualsBytes(KeysField))
{
var keyedValueMetric = new KeyedValueAggregate
{
Value = value,
Meta = meta
};
var formatter = formatterResolver.GetFormatter <List <string> >();
keyedValueMetric.Keys = formatter.Deserialize(ref reader, formatterResolver);
return(keyedValueMetric);
}
// skip any remaining properties for now
while (token != JsonToken.EndObject)
{
reader.ReadNextBlock();
token = reader.GetCurrentJsonToken();
}
}
return(new ValueAggregate
{
Value = value,
ValueAsString = valueAsString,
Meta = meta
});
}
var scriptedMetric = reader.ReadNextBlockSegment();
var bytes = BinaryUtil.ToArray(ref scriptedMetric);
var doc = new LazyDocument(bytes, formatterResolver);
return(new ScriptedMetricAggregate(doc)
{
Meta = meta
});
}
public static void Main(string[] args)
{
/*if (args.Length < 2)
* {
* Console.WriteLine("Please provide a file path and game");
* return;
* }*/
var path = args[0];
var game = args[1];
// leo no touchy please
//var path = @"D:\Games\Electronic Arts\Need for Speed Most Wanted\TRACKS\STREAML2RA.BUN";
//var game = "mw";
if (game != "mw" && game != "ug2" && game != "uc" && game != "world" && game != "carbon" && game != "ps")
{
Console.Error.WriteLine("Invalid game");
return;
}
ReadContainer <List <BaseModel> > container = null;
var readStream = new FileStream(path, FileMode.Open);
switch (game)
{
case "mw":
container = new MWFileReadContainer(
new BinaryReader(
readStream
),
path,
null
);
break;
case "ug2":
container = new UG2FileReadContainer(
new BinaryReader(
readStream
),
path,
null
);
break;
case "uc":
container = new UCFileReadContainer(
new BinaryReader(
readStream
),
path,
null
);
break;
case "world":
container = new WorldFileReadContainer(
new BinaryReader(
readStream
),
path,
null
);
break;
default:
break;
}
if (container == null)
{
return;
}
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var results = container.Get();
stopwatch.Stop();
Console.WriteLine("Results:");
Console.WriteLine(" Chunks read in {0} ms", stopwatch.ElapsedMilliseconds);
ProcessResults(results, path, container.GetType());
if (game == "world")
{
var writeContainer = new WorldFileWriteContainer();
{
using (var writeStream = File.OpenWrite($"{path}_mod"))
{
foreach (var model in results)
{
if (model is TexturePack tpk)
{
foreach (var t in tpk.Textures)
{
var ddsFile = $"{t.Name}.dds";
if (!File.Exists(ddsFile))
{
continue;
}
Console.WriteLine($"Found DDS: {ddsFile}");
using (var ddsStream = new BinaryReader(File.OpenRead(ddsFile)))
{
var ddsHeader = BinaryUtil.ReadStruct <DDSHeader>(ddsStream);
t.DataSize = (uint)(ddsStream.BaseStream.Length - 0x80);
t.Data = ddsStream.ReadBytes((int)t.DataSize);
Console.WriteLine($"DDS Data Size: {t.DataSize} - Mipmap: {ddsHeader.MipMapCount}");
t.MipMap = ddsHeader.MipMapCount;
t.Width = ddsHeader.Width;
t.Height = ddsHeader.Height;
t.CompressionType = ddsHeader.PixelFormat.Flags >= 0x40
? 0x15
: ddsHeader.PixelFormat.FourCC;
//t.CompressionType = ddsHeader.PixelFormat.FourCC;
}
}
}
}
writeContainer.Write(new BinaryReader(readStream), new BinaryWriter(writeStream), results);
}
}
}
}
catch (Exception e)
{
Console.Error.WriteLine("Uh oh! Error:");
Console.Error.WriteLine($"{e}");
}
}
