You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1399 lines
58 KiB
1399 lines
58 KiB
using System; |
|
using MessagePack; |
|
|
|
namespace MessagePack.Unity |
|
{ |
|
public sealed class Vector2Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Vector2> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Vector2 value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.y); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Vector2 Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var x = default(float); |
|
var y = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
x = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
y = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var result = new global::UnityEngine.Vector2(x, y); |
|
return result; |
|
} |
|
} |
|
|
|
|
|
public sealed class Vector3Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Vector3> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Vector3 value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 3); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.y); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.z); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Vector3 Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var x = default(float); |
|
var y = default(float); |
|
var z = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
x = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
y = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
z = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var result = new global::UnityEngine.Vector3(x, y, z); |
|
return result; |
|
} |
|
} |
|
|
|
|
|
public sealed class Vector4Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Vector4> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Vector4 value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.y); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.z); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.w); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Vector4 Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var x = default(float); |
|
var y = default(float); |
|
var z = default(float); |
|
var w = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
x = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
y = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
z = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
w = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var result = new global::UnityEngine.Vector4(x, y, z, w); |
|
return result; |
|
} |
|
} |
|
|
|
|
|
public sealed class QuaternionFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Quaternion> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Quaternion value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.y); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.z); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.w); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Quaternion Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var x = default(float); |
|
var y = default(float); |
|
var z = default(float); |
|
var w = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
x = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
y = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
z = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
w = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var result = new global::UnityEngine.Quaternion(x, y, z, w); |
|
return result; |
|
} |
|
} |
|
|
|
|
|
public sealed class ColorFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Color> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Color value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.r); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.g); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.b); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.a); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Color Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var r = default(float); |
|
var g = default(float); |
|
var b = default(float); |
|
var a = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
r = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
g = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
b = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
a = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var result = new global::UnityEngine.Color(r, g, b, a); |
|
return result; |
|
} |
|
} |
|
|
|
|
|
public sealed class BoundsFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Bounds> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Bounds value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3>().Serialize(ref bytes, offset, value.center, formatterResolver); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3>().Serialize(ref bytes, offset, value.size, formatterResolver); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Bounds Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var center = default(global::UnityEngine.Vector3); |
|
var size = default(global::UnityEngine.Vector3); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
center = formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
case 1: |
|
size = formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var result = new global::UnityEngine.Bounds(center, size); |
|
return result; |
|
} |
|
} |
|
|
|
|
|
public sealed class RectFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Rect> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Rect value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.y); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.width); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.height); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Rect Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var x = default(float); |
|
var y = default(float); |
|
var width = default(float); |
|
var height = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
x = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
y = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
width = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
height = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var result = new global::UnityEngine.Rect(x, y, width, height); |
|
return result; |
|
} |
|
} |
|
|
|
// additional |
|
|
|
public sealed class WrapModeFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.WrapMode> |
|
{ |
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.WrapMode value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
return MessagePackBinary.WriteInt32(ref bytes, offset, (Int32)value); |
|
} |
|
|
|
public global::UnityEngine.WrapMode Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
return (global::UnityEngine.WrapMode)MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
} |
|
} |
|
|
|
public sealed class GradientModeFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.GradientMode> |
|
{ |
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.GradientMode value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
return MessagePackBinary.WriteInt32(ref bytes, offset, (Int32)value); |
|
} |
|
|
|
public global::UnityEngine.GradientMode Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
return (global::UnityEngine.GradientMode)MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
} |
|
} |
|
|
|
public sealed class KeyframeFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Keyframe> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Keyframe value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.time); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.value); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.inTangent); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.outTangent); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Keyframe Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __time__ = default(float); |
|
var __value__ = default(float); |
|
var __inTangent__ = default(float); |
|
var __outTangent__ = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__time__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__value__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
__inTangent__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
__outTangent__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.Keyframe(__time__, __value__, __inTangent__, __outTangent__); |
|
____result.time = __time__; |
|
____result.value = __value__; |
|
____result.inTangent = __inTangent__; |
|
____result.outTangent = __outTangent__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class AnimationCurveFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.AnimationCurve> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.AnimationCurve value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
if (value == null) |
|
{ |
|
return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset); |
|
} |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 3); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.Keyframe[]>().Serialize(ref bytes, offset, value.keys, formatterResolver); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.WrapMode>().Serialize(ref bytes, offset, value.postWrapMode, formatterResolver); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.WrapMode>().Serialize(ref bytes, offset, value.preWrapMode, formatterResolver); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.AnimationCurve Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
readSize = 1; |
|
return null; |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __keys__ = default(global::UnityEngine.Keyframe[]); |
|
var __postWrapMode__ = default(global::UnityEngine.WrapMode); |
|
var __preWrapMode__ = default(global::UnityEngine.WrapMode); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__keys__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.Keyframe[]>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
case 1: |
|
__postWrapMode__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.WrapMode>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
case 2: |
|
__preWrapMode__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.WrapMode>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.AnimationCurve(); |
|
____result.keys = __keys__; |
|
____result.postWrapMode = __postWrapMode__; |
|
____result.preWrapMode = __preWrapMode__; |
|
return ____result; |
|
} |
|
} |
|
|
|
public sealed class Matrix4x4Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Matrix4x4> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Matrix4x4 value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteArrayHeader(ref bytes, offset, 16); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m00); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m10); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m20); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m30); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m01); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m11); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m21); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m31); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m02); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m12); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m22); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m32); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m03); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m13); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m23); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.m33); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Matrix4x4 Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __m00__ = default(float); |
|
var __m10__ = default(float); |
|
var __m20__ = default(float); |
|
var __m30__ = default(float); |
|
var __m01__ = default(float); |
|
var __m11__ = default(float); |
|
var __m21__ = default(float); |
|
var __m31__ = default(float); |
|
var __m02__ = default(float); |
|
var __m12__ = default(float); |
|
var __m22__ = default(float); |
|
var __m32__ = default(float); |
|
var __m03__ = default(float); |
|
var __m13__ = default(float); |
|
var __m23__ = default(float); |
|
var __m33__ = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__m00__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__m10__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
__m20__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
__m30__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 4: |
|
__m01__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 5: |
|
__m11__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 6: |
|
__m21__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 7: |
|
__m31__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 8: |
|
__m02__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 9: |
|
__m12__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 10: |
|
__m22__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 11: |
|
__m32__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 12: |
|
__m03__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 13: |
|
__m13__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 14: |
|
__m23__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 15: |
|
__m33__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.Matrix4x4(); |
|
____result.m00 = __m00__; |
|
____result.m10 = __m10__; |
|
____result.m20 = __m20__; |
|
____result.m30 = __m30__; |
|
____result.m01 = __m01__; |
|
____result.m11 = __m11__; |
|
____result.m21 = __m21__; |
|
____result.m31 = __m31__; |
|
____result.m02 = __m02__; |
|
____result.m12 = __m12__; |
|
____result.m22 = __m22__; |
|
____result.m32 = __m32__; |
|
____result.m03 = __m03__; |
|
____result.m13 = __m13__; |
|
____result.m23 = __m23__; |
|
____result.m33 = __m33__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class GradientColorKeyFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.GradientColorKey> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.GradientColorKey value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.Color>().Serialize(ref bytes, offset, value.color, formatterResolver); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.time); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.GradientColorKey Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __color__ = default(global::UnityEngine.Color); |
|
var __time__ = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__color__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.Color>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
case 1: |
|
__time__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.GradientColorKey(__color__, __time__); |
|
____result.color = __color__; |
|
____result.time = __time__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class GradientAlphaKeyFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.GradientAlphaKey> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.GradientAlphaKey value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.alpha); |
|
offset += MessagePackBinary.WriteSingle(ref bytes, offset, value.time); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.GradientAlphaKey Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __alpha__ = default(float); |
|
var __time__ = default(float); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__alpha__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__time__ = MessagePackBinary.ReadSingle(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.GradientAlphaKey(__alpha__, __time__); |
|
____result.alpha = __alpha__; |
|
____result.time = __time__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class GradientFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Gradient> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Gradient value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
if (value == null) |
|
{ |
|
return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset); |
|
} |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 3); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.GradientColorKey[]>().Serialize(ref bytes, offset, value.colorKeys, formatterResolver); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.GradientAlphaKey[]>().Serialize(ref bytes, offset, value.alphaKeys, formatterResolver); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.GradientMode>().Serialize(ref bytes, offset, value.mode, formatterResolver); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Gradient Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
readSize = 1; |
|
return null; |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __colorKeys__ = default(global::UnityEngine.GradientColorKey[]); |
|
var __alphaKeys__ = default(global::UnityEngine.GradientAlphaKey[]); |
|
var __mode__ = default(global::UnityEngine.GradientMode); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__colorKeys__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.GradientColorKey[]>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
case 1: |
|
__alphaKeys__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.GradientAlphaKey[]>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
case 2: |
|
__mode__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.GradientMode>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.Gradient(); |
|
____result.colorKeys = __colorKeys__; |
|
____result.alphaKeys = __alphaKeys__; |
|
____result.mode = __mode__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class Color32Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Color32> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Color32 value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteByte(ref bytes, offset, value.r); |
|
offset += MessagePackBinary.WriteByte(ref bytes, offset, value.g); |
|
offset += MessagePackBinary.WriteByte(ref bytes, offset, value.b); |
|
offset += MessagePackBinary.WriteByte(ref bytes, offset, value.a); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Color32 Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __r__ = default(byte); |
|
var __g__ = default(byte); |
|
var __b__ = default(byte); |
|
var __a__ = default(byte); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__r__ = MessagePackBinary.ReadByte(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__g__ = MessagePackBinary.ReadByte(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
__b__ = MessagePackBinary.ReadByte(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
__a__ = MessagePackBinary.ReadByte(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.Color32(__r__, __g__, __b__, __a__); |
|
____result.r = __r__; |
|
____result.g = __g__; |
|
____result.b = __b__; |
|
____result.a = __a__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class RectOffsetFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.RectOffset> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.RectOffset value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
if (value == null) |
|
{ |
|
return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset); |
|
} |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.left); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.right); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.top); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.bottom); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.RectOffset Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
readSize = 1; |
|
return null; |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __left__ = default(int); |
|
var __right__ = default(int); |
|
var __top__ = default(int); |
|
var __bottom__ = default(int); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__left__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__right__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
__top__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
__bottom__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.RectOffset(); |
|
____result.left = __left__; |
|
____result.right = __right__; |
|
____result.top = __top__; |
|
____result.bottom = __bottom__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class LayerMaskFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.LayerMask> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.LayerMask value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.value); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.LayerMask Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __value__ = default(int); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__value__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.LayerMask(); |
|
____result.value = __value__; |
|
return ____result; |
|
} |
|
} |
|
|
|
#if UNITY_2017_2_OR_NEWER |
|
|
|
public sealed class Vector2IntFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Vector2Int> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Vector2Int value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.y); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Vector2Int Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __x__ = default(int); |
|
var __y__ = default(int); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__x__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__y__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.Vector2Int(__x__, __y__); |
|
____result.x = __x__; |
|
____result.y = __y__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class Vector3IntFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.Vector3Int> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.Vector3Int value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 3); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.y); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.z); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.Vector3Int Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __x__ = default(int); |
|
var __y__ = default(int); |
|
var __z__ = default(int); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__x__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__y__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
__z__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.Vector3Int(__x__, __y__, __z__); |
|
____result.x = __x__; |
|
____result.y = __y__; |
|
____result.z = __z__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class RangeIntFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.RangeInt> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.RangeInt value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.start); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.length); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.RangeInt Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __start__ = default(int); |
|
var __length__ = default(int); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__start__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__length__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.RangeInt(__start__, __length__); |
|
____result.start = __start__; |
|
____result.length = __length__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class RectIntFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.RectInt> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.RectInt value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.x); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.y); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.width); |
|
offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.height); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.RectInt Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __x__ = default(int); |
|
var __y__ = default(int); |
|
var __width__ = default(int); |
|
var __height__ = default(int); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__x__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 1: |
|
__y__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 2: |
|
__width__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
case 3: |
|
__height__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.RectInt(__x__, __y__, __width__, __height__); |
|
____result.x = __x__; |
|
____result.y = __y__; |
|
____result.width = __width__; |
|
____result.height = __height__; |
|
return ____result; |
|
} |
|
} |
|
|
|
|
|
public sealed class BoundsIntFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::UnityEngine.BoundsInt> |
|
{ |
|
|
|
public int Serialize(ref byte[] bytes, int offset, global::UnityEngine.BoundsInt value, global::MessagePack.IFormatterResolver formatterResolver) |
|
{ |
|
|
|
var startOffset = offset; |
|
offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3Int>().Serialize(ref bytes, offset, value.position, formatterResolver); |
|
offset += formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3Int>().Serialize(ref bytes, offset, value.size, formatterResolver); |
|
return offset - startOffset; |
|
} |
|
|
|
public global::UnityEngine.BoundsInt Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize) |
|
{ |
|
if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset)) |
|
{ |
|
throw new InvalidOperationException("typecode is null, struct not supported"); |
|
} |
|
|
|
var startOffset = offset; |
|
var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); |
|
offset += readSize; |
|
|
|
var __position__ = default(global::UnityEngine.Vector3Int); |
|
var __size__ = default(global::UnityEngine.Vector3Int); |
|
|
|
for (int i = 0; i < length; i++) |
|
{ |
|
var key = i; |
|
|
|
switch (key) |
|
{ |
|
case 0: |
|
__position__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3Int>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
case 1: |
|
__size__ = formatterResolver.GetFormatterWithVerify<global::UnityEngine.Vector3Int>().Deserialize(bytes, offset, formatterResolver, out readSize); |
|
break; |
|
default: |
|
readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset); |
|
break; |
|
} |
|
offset += readSize; |
|
} |
|
|
|
readSize = offset - startOffset; |
|
|
|
var ____result = new global::UnityEngine.BoundsInt(__position__, __size__); |
|
____result.position = __position__; |
|
____result.size = __size__; |
|
return ____result; |
|
} |
|
} |
|
|
|
#endif |
|
} |