When developing multiplayer game with PUN2, there will be cases where sending custom types such as user defined structure or class through RPC and Event, etc. However, sending theses custom types directly to network is not allowed in PUN2. Instead, PUN2 provides custom type registering method as a solution.
For using PUN2’s custom type registering method, a custom type must be serialized into byte array. In many cases, byte serialization is performed using Binary Formatter. However, Binary Formatter creates a significant amount of additional bytes, which will hurt traffic for network intensive games and give poor experience for mobile users who cannot use free WIFI connection. In addition, Binary Formatter cannot serialize Unity's Vector2, Vector3, Quaternion and etc.
This archive provides custom type registering method with script and compares the difference with other serialization methods.
Given structure will be serialized with Binary Formatter and the size will be measured by Marshal. Note that Unity objects such as Vector3, Quaternion and etc are not included since those cannot be serialized by Binary Formatter.
public struct TestStruct
{
public int int_1;
public int int_2;
public string string_1;
public float float_1;
public float float_2;
}
TestStruct testStruct = new TestStruct
{
int_1 = 30,
int_2 = 71,
string_1 = "ABC가나다",
float_1 = 0.162f,
float_2 = 62f,
};Serializing the structure and measuring size of it are as follows:
public void BinaryFormatterSerialize(TestStruct testStruct)
{
byte[] bytes;
MemoryStream memoryStream = new MemoryStream();
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, testStruct);
memoryStream.Close();
bytes = memoryStream.ToArray();
Debug.Log(string.Format("Bianary Formatter Serialized Size : {0} bytes", bytes.Length));
}public void CheckSize(TestStruct testStruct)
{
Debug.Log(string.Format("Original Size : {0} bytes", Marshal.SizeOf(testStruct)));
Debug.Log(JsonUtility.ToJson(testStruct, true));
}The result is as follows:
| size(bytes) | |
|---|---|
| Original | 24 bytes |
| Binary Formatter | 199 bytes |
The theoretical size of given structure is 24 bytes. When the given structure is serialized with Binary Formatter, the size is 199 bytes which is 8 times larger than the theoretical size. This may lead to traffic overhead when serializing and sending it to the network.
Given structure above will be serialized with JsonUtility and coverted to bytes. Serializing the structure is as follows:
public void JsonSerialize(TestStruct testStruct)
{
byte[] bytes = Encoding.UTF8.GetBytes(JsonUtility.ToJson(testStruct));
Debug.Log(string.Format("JsonUtility Serialized Size : {0} bytes", bytes.Length));
}The result is as follows:
| size(bytes) | |
|---|---|
| Original | 24 bytes |
| JsonUtility & byte conversion | 94 bytes |
When the given structure is serialized with JsonUtility and converted to bytes, the size is 94 bytes which is about 4 times larger than the theoretical size. This size can be reduced by shortening the names of the variables. For instance, when the names of variables are changed as shown below, the result is as follows.
public struct TestStruct
{
public int a;
public int b;
public string c;
public float d;
public float e;
}
TestStruct testStruct = new TestStruct
{
a = 30,
b = 71,
c = "ABC가나다",
d = 0.162f,
e = 62f,
};| size(bytes) | |
|---|---|
| Original | 24 bytes |
| JsonUtility & byte conversion | 67 bytes |
The size of bytes are reduced from 94 bytes to 67 bytes. However, it is still larger than the theoritical size of 24 bytes.
This archive introduces custom serializer which can serialize custom type such as user defined structure or class. This serializer can provide a size that is close to the theoretical size. Serializable types and sizes are as follows:
| Type | Size(bytes) |
|---|---|
| byte | 1 byte |
| byte[] | 4 + (1 * Length) bytes |
| bool | 1 byte |
| bool[] | 4 + (1 * Length) bytes |
| int | 4 bytes |
| int[] | 4 + (4 * Length) bytes |
| float | 4 bytes |
| float[] | 4 + (4 * Length) bytes |
| Vector2 | 8 bytes |
| Vector2[] | 4 + (8 * Length) bytes |
| Vector3 | 12 bytes |
| Vector3[] | 4 + (12 * Length) bytes |
| Quaternion | 16 bytes |
| Quaternion[] | 4 + (16 * Length) bytes |
| string | 4 + α (UTF8 Encoding) bytes |
| string[] | 4 + ((4 + α) * Length) bytes |
First of all, declare using MSLIMA.Serializer above.
using MSLIMA.Serializer;
Then, Suppose that the structure is given as follows:
public struct TestStruct
{
public int int_1;
public int int_2;
public float float_1;
public bool bool_1;
public string string_1;
public Vector3 vector3_1;
public Vector3 vector3_2;
public Quaternion quaternion_1;
}
TestStruct testStruct = new TestStruct
{
int_1 = 30,
int_2 = 71,
float_1 = 0.162f,
bool_1 = true,
string_1 = "ABC가나다",
vector3_1 = new Vector3(-23f, 62f, 26f),
vector3_2 = new Vector3(1f, 7f, -15f),
quaternion_1 = Quaternion.Euler(35f, 0f, 15f)
};First, create static methods with the names "Serialize" and "Deserialize" inside of the custom type. "Serialize" method has one parameter with type of object and return type with type of byte[]. "Deserialize" method has one parameter with type of byte[] and return type of object.
Note that the names of the methods, parameters and return types must be same as described. In addition, these methods must be static.
public static byte[] Serialize(object customObject)
{
}public static object Deserialize(byte[] bytes)
{
}Second, cast customObject to custom type, declare byte array in "Serialize" method.
public static byte[] Serialize(object customObject)
{
TestStruct o = (TestStruct)customObject;
byte[] bytes = new byte[0];
}Now, use Serializer's method to serialize desired fields and return bytes at last. Note that byte array is passed with ref keyword.
public static byte[] Serialize(object customObject)
{
...
Serializer.Serialize(o.int_1, ref bytes);
Serializer.Serialize(o.int_2, ref bytes);
Serializer.Serialize(o.float_1, ref bytes);
Serializer.Serialize(o.bool_1, ref bytes);
Serializer.Serialize(o.string_1, ref bytes);
Serializer.Serialize(o.vector3_1, ref bytes);
Serializer.Serialize(o.vector3_2, ref bytes);
Serializer.Serialize(o.quaternion_1, ref bytes);
return bytes;
}Third, create new custom type in "Deserialize" method and declare offset variable with type of int and intialize it with 0.
public static object Deserialize(byte[] bytes)
{
TestStruct o = new TestStruct();
int offset = 0;
}Now, use Serializer's deserialize method to deserialize the fields which are serialized above. Offset is passed with ref keyword and return the custom type created above.
Note that the order of deserializing must be same as the order of serializing.
public static object Deserialize(byte[] bytes)
{
...
o.int_1 = Serializer.DeserializeInt(bytes, ref offset);
o.int_2 = Serializer.DeserializeInt(bytes, ref offset);
o.float_1 = Serializer.DeserializeInt(bytes, ref offset);
o.bool_1 = Serializer.DeserializeBool(bytes, ref offset);
o.string_1 = Serializer.DeserializeString(bytes, ref offset);
o.vector3_1 = Serializer.DeserializeVector3(bytes, ref offset);
o.vector3_2 = Serializer.DeserializeVector3(bytes, ref offset);
o.quaternion_1 = Serializer.DeserializeQuaternion(bytes, ref offset);
return o;
}Last, the custom type should be registered to PUN2. Call the method described below once to register the custom type. If registering multiple custom types is needed, the byte code must be different. Simply achieved by changing the alphabet of the parameter in the method.
Serializer.RegisterCustomType<TestStruct>((byte)'A');The result of serializtion of given structure is as follows:
| size(bytes) | |
|---|---|
| Original | 64 bytes |
| Custom Serializer | 69 bytes |
The theoretical size is 64 bytes where the actual serialized size is 69 bytes. The difference of 5 bytes is caused by string, which can be sized variably by the length. The result is acceptable.
The custom serializer provides a smaller size rather than Binary Formatter or JsonUtility serializing. However, there are limitations that it can be inconvenient to have wirte all serialize methods for every custom types which are supposed to be serialized and does not support nested types. Nevertherless, if serializing simple custom types with primitive types and sending it to the network frequently, this custom serializer would help.
Add scoped this registry.
"scopedRegistries": [
{
"name": "MS-LIMA",
"url": "https://package.openupm.com",
"scopes": [
"com.ms-lima"
]
}
]