public Polygon Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
reader.ReadArrayHeader();
var hole = reader.ReadBoolean();
var nx = reader.ReadArrayHeader();
var x = new double[nx];
for (var j = 0; j < nx; j++)
{
x[j] = reader.ReadDouble();
}
var ny = reader.ReadArrayHeader();
var y = new double[ny];
for (var j = 0; j < ny; j++)
{
y[j] = reader.ReadDouble();
}
return(new Polygon
{
Hole = hole,
Longitude = x,
Latitude = y
});
}
public System.Numerics.Complex Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
var count = reader.ReadArrayHeader();
if (count != 2)
{
ThrowHelper.ThrowInvalidOperationException_Complex_Format();
}
var real = reader.ReadDouble();
var imaginary = reader.ReadDouble();
return(new System.Numerics.Complex(real, imaginary));
}
public global::DRXLibrary.Models.Drx.Document.DrxDocumentVrel Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
var length = reader.ReadArrayHeader();
var __Vividity__ = default(double);
var __Remembrance__ = default(double);
var __Emotion__ = default(double);
var __Length__ = default(double);
for (int i = 0; i < length; i++)
{
switch (i)
{
case 0:
__Vividity__ = reader.ReadDouble();
break;
case 1:
__Remembrance__ = reader.ReadDouble();
break;
case 2:
__Emotion__ = reader.ReadDouble();
break;
case 3:
__Length__ = reader.ReadDouble();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::DRXLibrary.Models.Drx.Document.DrxDocumentVrel();
____result.Vividity = __Vividity__;
____result.Remembrance = __Remembrance__;
____result.Emotion = __Emotion__;
____result.Length = __Length__;
reader.Depth--;
return(____result);
}
public System.Numerics.Complex Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var count = reader.ReadArrayHeader();
if (count != 2)
{
throw new MessagePackSerializationException("Invalid Complex format.");
}
var real = reader.ReadDouble();
var imaginary = reader.ReadDouble();
return(new System.Numerics.Complex(real, imaginary));
}
public Point Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
return(null);
}
reader.ReadArrayHeader();
return(new Point
{
Longitude = reader.ReadDouble(),
Latitude = reader.ReadDouble()
});
}
private Tick?Extract()
{
if (BytesRemaining <= 0)
{
return(null);
}
var reader = new MessagePackReader(_parent.AsReadOnlySequence().Slice(_position));
if (_previousTick is null)
{
var price = reader.ReadDouble();
var bid = reader.ReadDouble();
var ask = reader.ReadDouble();
var volume = (double)(reader.ReadUInt32() * _minQtyIncrement);
var timeStamp = new TimeStamp((long)reader.ReadUInt64());
_position += reader.Consumed;
return(_previousTick = new Tick
{
Instrument = Instrument,
Price = price,
Bid = bid,
Ask = ask,
Volume = volume,
TimeStamp = timeStamp,
});
}
else
{
var price = _previousTick.Price.AddIncrements(_tickSize, reader.ReadInt32());
var bid = _previousTick.Bid.AddIncrements(_tickSize, reader.ReadInt32());
var ask = _previousTick.Ask.AddIncrements(_tickSize, reader.ReadInt32());
var volume = (double)(reader.ReadUInt32() * _minQtyIncrement);
var timeStamp = _previousTick.TimeStamp.AddTicks((long)reader.ReadUInt64());
_position += reader.Consumed;
return(_previousTick = new Tick
{
Instrument = Instrument,
Price = price,
Bid = bid,
Ask = ask,
Volume = volume,
TimeStamp = timeStamp,
});
}
}
public Double?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(reader.ReadDouble());
}
public Double[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var array = new Double[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadDouble();
}
return(array);
}
public void DoubleTest(Double target, int length)
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.Write(target);
writer.Flush();
sequence.Length.Is(length);
packer.Pack(target).Position.Is(sequence.Length);
stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
sequenceReader.ReadDouble().Is(target);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).AsDouble().Is(target);
}
public Double Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
return(reader.ReadDouble());
}
public object Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
MessagePackType type = reader.NextMessagePackType;
IFormatterResolver resolver = options.Resolver;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (code >= MessagePackCode.MinNegativeFixInt && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (code >= MessagePackCode.MinFixInt && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (reader.NextCode == MessagePackCode.Float32)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
// We must copy the sequence returned by ReadBytes since the reader's sequence is only valid during deserialization.
return(reader.ReadBytes()?.ToArray());
case MessagePackType.Extension:
ExtensionHeader ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
if (length == 0)
{
return(Array.Empty <object>());
}
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, options);
}
}
finally
{
reader.Depth--;
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length, options.Security.GetEqualityComparer <object>());
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, options);
var value = objectFormatter.Deserialize(ref reader, options);
hash.Add(key, value);
}
}
finally
{
reader.Depth--;
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new MessagePackSerializationException("Invalid primitive bytes.");
}
}
public override double Deserialize(MessagePackReader reader)
{
return(reader.ReadDouble());
}
public Vector3 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new Vector3((float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble()));
}
public RgbaFloat Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new RgbaFloat((float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble()));
}
public Quaternion Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new Quaternion((float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble()));
}
public object Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
var type = reader.GetMessagePackType();
switch (type)
{
case MessagePackType.Integer:
var code = reader.Peek();
if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else
{
switch (code)
{
case MessagePackCode.Int8: return(reader.ReadSByte());
case MessagePackCode.Int16: return(reader.ReadInt16());
case MessagePackCode.Int32: return(reader.ReadInt32());
case MessagePackCode.Int64: return(reader.ReadInt64());
case MessagePackCode.UInt8: return(reader.ReadByte());
case MessagePackCode.UInt16: return(reader.ReadUInt16());
case MessagePackCode.UInt32: return(reader.ReadUInt32());
case MessagePackCode.UInt64: return(reader.ReadUInt64());
default: ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
}
}
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (MessagePackCode.Float32 == reader.Peek())
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
return(reader.ReadBytes());
case MessagePackType.Extension:
var extTypeCode = reader.GetExtensionFormatTypeCode();
if (extTypeCode != ReservedMessagePackExtensionTypeCode.DateTime)
{
ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes();
}
return(reader.ReadDateTime());
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
var objectFormatter = formatterResolver.GetFormatter <object>();
var array = new object[length];
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, formatterResolver);
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
var objectFormatter = formatterResolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length);
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, formatterResolver);
var value = objectFormatter.Deserialize(ref reader, formatterResolver);
hash.Add(key, value);
}
return(hash);
}
case MessagePackType.Nil:
reader.Advance(1);
return(null);
default:
ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
}
}
public object Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
var type = reader.NextMessagePackType;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (MessagePackCode.Float32 == reader.NextCode)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
return(reader.ReadBytes());
case MessagePackType.Extension:
var ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
var objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, resolver);
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
var objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length);
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, resolver);
var value = objectFormatter.Deserialize(ref reader, resolver);
hash.Add(key, value);
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new InvalidOperationException("Invalid primitive bytes.");
}
}
public static ResourcePak Load(string path)
{
var fileBytes = File.ReadAllBytes(path);
var pakReader = new MessagePackReader(fileBytes);
// Read Into Nested Object
pakReader.ReadArrayHeader();
var pakeName = pakReader.ReadString();
var pak = new ResourcePak(pakeName);
int numberImages = pakReader.ReadMapHeader();
if (numberImages > 0)
{
pak.Images = new Dictionary <string, ImageData>();
for (int i = 0; i < numberImages; ++i)
{
var key = pakReader.ReadString();
pakReader.ReadArrayHeader();
var imageId = pakReader.ReadString();
var imageData = pakReader.ReadBytes();
int imageWidth = pakReader.ReadInt32();
int imageHeight = pakReader.ReadInt32();
pak.Images.Add(key, new ImageData()
{
Id = imageId,
Data = imageData?.ToArray(),
Width = imageWidth,
Height = imageHeight
});
}
}
int numberAtlases = pakReader.ReadMapHeader();
if (numberAtlases > 0)
{
pak.Atlases = new Dictionary <string, TextureAtlasData>();
for (int i = 0; i < numberAtlases; i++)
{
var key = pakReader.ReadString();
pakReader.ReadArrayHeader();
var atlasId = pakReader.ReadString();
var atlasImageData = pakReader.ReadBytes();
int imageWidth = pakReader.ReadInt32();
int imageHeight = pakReader.ReadInt32();
var atlasData = new TextureAtlasData()
{
Id = atlasId,
Data = atlasImageData?.ToArray(),
Atlas = new Dictionary <string, SRect>(),
Width = imageWidth,
Height = imageHeight,
};
int rectsCount = pakReader.ReadMapHeader();
if (rectsCount > 0)
{
for (int j = 0; j < rectsCount; ++j)
{
var rectKey = pakReader.ReadString();
pakReader.ReadArrayHeader();
var rectX = pakReader.ReadInt32();
var rectY = pakReader.ReadInt32();
var rectW = pakReader.ReadInt32();
var rectH = pakReader.ReadInt32();
atlasData.Atlas.Add(rectKey, new SRect(rectX, rectY, rectW, rectH));
}
}
atlasData.RuntimeUpdatable = pakReader.ReadBoolean();
pak.Atlases.Add(key, atlasData);
}
}
int shadersCount = pakReader.ReadMapHeader();
if (shadersCount > 0)
{
pak.Shaders = new Dictionary <string, ShaderProgramData>();
for (int i = 0; i < shadersCount; ++i)
{
var shaderKey = pakReader.ReadString();
pakReader.ReadArrayHeader();
var shaderId = pakReader.ReadString();
var vertexShaderData = pakReader.ReadBytes();
var fragShaderData = pakReader.ReadBytes();
string[] samplers = null;
string[] @params = null;
int samplersCount = pakReader.ReadArrayHeader();
if (samplersCount > 0)
{
samplers = new string[samplersCount];
for (int j = 0; j < samplersCount; ++j)
{
samplers[j] = pakReader.ReadString();
}
}
int paramsCount = pakReader.ReadArrayHeader();
if (paramsCount > 0)
{
@params = new string[paramsCount];
for (int k = 0; k < paramsCount; ++k)
{
@params[k] = pakReader.ReadString();
}
}
pak.Shaders.Add(shaderKey, new ShaderProgramData()
{
Id = shaderId,
VertexShader = vertexShaderData?.ToArray(),
FragmentShader = fragShaderData?.ToArray(),
Samplers = samplers,
Params = @params
});
}
}
int fontsSize = pakReader.ReadMapHeader();
if (fontsSize > 0)
{
pak.Fonts = new Dictionary <string, FontData>();
for (int i = 0; i < fontsSize; ++i)
{
var fontKey = pakReader.ReadString();
pakReader.ReadArrayHeader();
var fontId = pakReader.ReadString();
var fontData = new FontData()
{
Id = fontId
};
pakReader.ReadArrayHeader();
var fontImageDataId = pakReader.ReadString();
var fontImageData = pakReader.ReadBytes();
int fontImageWidth = pakReader.ReadInt32();
int fontImageHeight = pakReader.ReadInt32();
fontData.FontSheet = new ImageData()
{
Id = fontImageDataId,
Width = fontImageWidth,
Height = fontImageHeight,
Data = fontImageData?.ToArray()
};
int charCount = pakReader.ReadArrayHeader();
if (charCount > 0)
{
fontData.Chars = new char[charCount];
for (int j = 0; j < charCount; ++j)
{
fontData.Chars[j] = pakReader.ReadChar();
}
}
int glyphRectCount = pakReader.ReadArrayHeader();
if (glyphRectCount > 0)
{
fontData.GlyphRects = new SRect[glyphRectCount];
for (int k = 0; k < glyphRectCount; ++k)
{
pakReader.ReadArrayHeader();
int x = pakReader.ReadInt32();
int y = pakReader.ReadInt32();
int w = pakReader.ReadInt32();
int h = pakReader.ReadInt32();
fontData.GlyphRects[k] = new SRect(x, y, w, h);
}
}
int glyphCroppingsCount = pakReader.ReadArrayHeader();
if (glyphCroppingsCount > 0)
{
fontData.GlyphCroppings = new SRect[glyphCroppingsCount];
for (int l = 0; l < glyphCroppingsCount; ++l)
{
pakReader.ReadArrayHeader();
int x = pakReader.ReadInt32();
int y = pakReader.ReadInt32();
int w = pakReader.ReadInt32();
int h = pakReader.ReadInt32();
fontData.GlyphCroppings[l] = new SRect(x, y, w, h);
}
}
int glyphKerningsCount = pakReader.ReadArrayHeader();
if (glyphKerningsCount > 0)
{
fontData.GlyphKernings = new SVec3[glyphKerningsCount];
for (int k = 0; k < glyphKerningsCount; ++k)
{
pakReader.ReadArrayHeader();
float x = (float)pakReader.ReadDouble();
float y = (float)pakReader.ReadDouble();
float z = (float)pakReader.ReadDouble();
fontData.GlyphKernings[k] = new SVec3(x, y, z);
}
}
fontData.LineSpacing = pakReader.ReadInt32();
fontData.Spacing = pakReader.ReadInt32();
fontData.DefaultChar = pakReader.ReadChar();
pak.Fonts.Add(fontKey, fontData);
}
}
int textCount = pakReader.ReadMapHeader();
if (textCount > 0)
{
pak.TextFiles = new Dictionary <string, TextFileData>();
var textKey = pakReader.ReadString();
pakReader.ReadArrayHeader();
var textId = pakReader.ReadString();
int textRowCount = pakReader.ReadArrayHeader();
var textData = new TextFileData()
{
Id = textId,
TextData = new byte[textRowCount][]
};
for (int i = 0; i < textRowCount; ++i)
{
textData.TextData[i] = pakReader.ReadBytes().Value.ToArray();
}
pak.TextFiles.Add(textKey, textData);
}
pak.TotalResourcesCount = pakReader.ReadInt32();
return(pak);
}