Optimize network transform replication

Source/Engine/Networking/Components/NetworkTransform.cpp

@@ -157,6 +157,7 @@ void NetworkTransform::Serialize(NetworkStream* stream)
 
     // Encode data
     Data data;
+    Platform::MemoryClear(&data, sizeof(data));
     data.LocalSpace = LocalSpace;
     data.HasSequenceIndex = Mode == ReplicationModes::Prediction;
     data.Components = Components;
@@ -195,8 +196,7 @@ void NetworkTransform::Serialize(NetworkStream* stream)
         }
         if (EnumHasAllFlags(data.Components, ReplicationComponents::Rotation))
         {
-            const Float3 rotation = transform.Orientation.GetEuler();
+            stream->Write(transform.Orientation);
-            stream->Write(rotation);
         }
         else if (EnumHasAnyFlags(data.Components, ReplicationComponents::Rotation))
         {
@@ -260,9 +260,7 @@ void NetworkTransform::Deserialize(NetworkStream* stream)
         }
         if (EnumHasAllFlags(data.Components, ReplicationComponents::Rotation))
         {
-            Float3 rotation;
+            stream->Read(transform.Orientation);
-            stream->Read(rotation);
-            transform.Orientation = Quaternion::Euler(rotation);
         }
         else if (EnumHasAnyFlags(data.Components, ReplicationComponents::Rotation))
         {

Source/Engine/Networking/NetworkStream.cpp

@@ -3,6 +3,7 @@
 #include "NetworkStream.h"
 #include "INetworkSerializable.h"
 #include "Engine/Core/Math/Quaternion.h"
+#include "Engine/Core/Math/Transform.h"
 
 // Quaternion quantized for optimized network data size.
 struct NetworkQuaternion
@@ -151,6 +152,20 @@ void NetworkStream::Read(Quaternion& data)
     NetworkQuaternion::Read(this, data);
 }
 
+void NetworkStream::Read(Transform& data)
+{
+    struct NonQuantized
+    {
+        Vector3 Pos;
+        Float3 Scale;
+    };
+    NonQuantized nonQuantized;
+    ReadBytes(&nonQuantized, sizeof(nonQuantized));
+    NetworkQuaternion::Read(this, data.Orientation);
+    data.Translation = nonQuantized.Pos;
+    data.Scale = nonQuantized.Scale;
+}
+
 void NetworkStream::Write(INetworkSerializable& obj)
 {
     obj.Serialize(this);
@@ -166,6 +181,19 @@ void NetworkStream::Write(const Quaternion& data)
     NetworkQuaternion::Write(this, data);
 }
 
+void NetworkStream::Write(const Transform& data)
+{
+    struct NonQuantized
+    {
+        Vector3 Pos;
+        Float3 Scale;
+    };
+    // TODO: quantize transform (at least scale)
+    NonQuantized nonQuantized = { data.Translation, data.Scale };
+    WriteBytes(&nonQuantized, sizeof(nonQuantized));
+    NetworkQuaternion::Write(this, data.Orientation);
+}
+
 void NetworkStream::Flush()
 {
     // Nothing to do

Source/Engine/Networking/NetworkStream.h

@@ -73,11 +73,13 @@ public:
     void Read(INetworkSerializable& obj);
     void Read(INetworkSerializable* obj);
     void Read(Quaternion& data);
+    void Read(Transform& data);
 
     using WriteStream::Write;
     void Write(INetworkSerializable& obj);
     void Write(INetworkSerializable* obj);
     void Write(const Quaternion& data);
+    void Write(const Transform& data);
 
 public:
     // [Stream]