Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Add Unity.Mathematics support #1690

Open
wants to merge 4 commits into
base: master
Choose a base branch
from
+521 −3
Open

Add Unity.Mathematics support #1690

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
923d788
Add support to Unity..Mathematics.int2
KonH Oct 13, 2023
6ead9fa
Setup conditional reference to Unity.Mathematics package
KonH Oct 19, 2023
5c0535e
Move formatter to the end of file, it is more suitable for specific case
KonH Oct 19, 2023
9272e9d
Add most common Unity.Mathematics datatypes support
KonH Oct 19, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
14 changes: 11 additions & 3 deletions src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePack.asmdef
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
{
"name": "MessagePack",
"references": [
"MessagePack.Annotations"
"MessagePack.Annotations",
"Unity.Mathematics"
],
"optionalUnityReferences": [],
"includePlatforms": [],
Expand All @@ -18,5 +19,12 @@
],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": []
}
"versionDefines": [
{
"name": "com.unity.mathematics",
"expression": "",
"define": "UNITY_MATHEMATICS_SUPPORT"
}
],
"noEngineReferences": false
}
350 changes: 350 additions & 0 deletions src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Unity/Formatters.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1132,4 +1132,354 @@ public void Serialize(ref MessagePackWriter writer, global::UnityEngine.BoundsIn
}
}
#endif

#if UNITY_MATHEMATICS_SUPPORT
public sealed class Bool2Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.bool2>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.bool2 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(2);
writer.Write(value.x);
writer.Write(value.y);
}

public global::Unity.Mathematics.bool2 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
var x = default(bool);
var y = default(bool);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadBoolean();
break;
case 1:
y = reader.ReadBoolean();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.bool2(x, y);
return result;
}
}

public sealed class Bool3Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.bool3>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.bool3 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(3);
writer.Write(value.x);
writer.Write(value.y);
writer.Write(value.z);
}

public global::Unity.Mathematics.bool3 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
var x = default(bool);
var y = default(bool);
var z = default(bool);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadBoolean();
break;
case 1:
y = reader.ReadBoolean();
break;
case 2:
z = reader.ReadBoolean();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.bool3(x, y, z);
return result;
}
}

public sealed class Double2Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.double2>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.double2 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(2);
writer.Write(value.x);
writer.Write(value.y);
}

public global::Unity.Mathematics.double2 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
var x = default(double);
var y = default(double);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadDouble();
break;
case 1:
y = reader.ReadDouble();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.double2(x, y);
return result;
}
}

public sealed class Double3Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.double3>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.double3 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(3);
writer.Write(value.x);
writer.Write(value.y);
writer.Write(value.z);
}

public global::Unity.Mathematics.double3 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
var x = default(double);
var y = default(double);
var z = default(double);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadDouble();
break;
case 1:
y = reader.ReadDouble();
break;
case 2:
z = reader.ReadDouble();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.double3(x, y, z);
return result;
}
}

public sealed class Float2Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.float2>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.float2 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(2);
writer.Write(value.x);
writer.Write(value.y);
}

public global::Unity.Mathematics.float2 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
var x = default(float);
var y = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadSingle();
break;
case 1:
y = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.float2(x, y);
return result;
}
}

public sealed class Float3Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.float3>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.float3 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(3);
writer.Write(value.x);
writer.Write(value.y);
writer.Write(value.z);
}

public global::Unity.Mathematics.float3 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
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 = reader.ReadSingle();
break;
case 1:
y = reader.ReadSingle();
break;
case 2:
z = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.float3(x, y, z);
return result;
}
}

public sealed class Int2Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.int2>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.int2 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(2);
writer.Write(value.x);
writer.Write(value.y);
}

public global::Unity.Mathematics.int2 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
var x = default(int);
var y = default(int);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadInt32();
break;
case 1:
y = reader.ReadInt32();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.int2(x, y);
return result;
}
}

public sealed class Int3Formatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Unity.Mathematics.int3>
{
public void Serialize(ref MessagePackWriter writer, global::Unity.Mathematics.int3 value, global::MessagePack.MessagePackSerializerOptions options)
{
writer.WriteArrayHeader(3);
writer.Write(value.x);
writer.Write(value.y);
writer.Write(value.z);
}

public global::Unity.Mathematics.int3 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}

var length = reader.ReadArrayHeader();
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 = reader.ReadInt32();
break;
case 1:
y = reader.ReadInt32();
break;
case 2:
z = reader.ReadInt32();
break;
default:
reader.Skip();
break;
}
}

var result = new global::Unity.Mathematics.int3(x, y, z);
return result;
}
}
#endif
}