public unsafe void UnsafeAppendBuffer_PushHeadersWithPackets()
{
var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
var scratchPayload = stackalloc byte[1024];
var expectedSize = 0;
for (int i = 0; i < 1024; i++)
{
var packeType = i;
var packetSize = i;
buffer.Add(new TestHeader
{
Type = packeType,
PayloadSize = packetSize
});
expectedSize += UnsafeUtility.SizeOf <TestHeader>();
buffer.Add(scratchPayload, i);
expectedSize += i;
}
Assert.True(expectedSize == buffer.Length);
buffer.Dispose();
}
public unsafe void UnsafeAppendBuffer_AddAndPop()
{
var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
buffer.Add <int>(123);
buffer.Add <int>(234);
buffer.Add <int>(345);
{
var array = new NativeArray <int>(3, Allocator.Temp);
buffer.Pop(array.GetUnsafePtr(), 3 * UnsafeUtility.SizeOf <int>());
CollectionAssert.AreEqual(new[] { 123, 234, 345 }, array);
}
{
var array = new NativeArray <int>(4, Allocator.Temp);
array.CopyFrom(new[] { 987, 876, 765, 654 });
buffer.Add(array.GetUnsafePtr(), 4 * UnsafeUtility.SizeOf <int>());
}
Assert.AreEqual(654, buffer.Pop <int>());
Assert.AreEqual(765, buffer.Pop <int>());
Assert.AreEqual(876, buffer.Pop <int>());
Assert.AreEqual(987, buffer.Pop <int>());
buffer.Dispose();
}
unsafe public static void SerializeResourcePacket(EntityChangeSet entityChangeSet, ref UnsafeAppendBuffer buffer)
{
var changeSetBuffer = new UnsafeAppendBuffer(1024, 16, Allocator.TempJob);
Serialize(entityChangeSet, &changeSetBuffer, out var globalObjectIds);
buffer.Add(globalObjectIds);
buffer.Add(changeSetBuffer.Ptr, changeSetBuffer.Length);
changeSetBuffer.Dispose();
globalObjectIds.Dispose();
}
public byte[] Serialize()
{
var buffer = new UnsafeAppendBuffer(1024, 16, Allocator.Persistent);
EntityChangeSetSerialization.ResourcePacket.SerializeResourcePacket(Changes, ref buffer);
buffer.Add(SceneGUID);
buffer.Add(SceneName);
buffer.Add(UnloadAllPreviousEntities);
return buffer.ToBytes();
}
unsafe public void UnsafeAppendBuffer_DisposeExternal()
{
var data = stackalloc int[1];
var buffer = new UnsafeAppendBuffer(data, sizeof(int));
buffer.Add(5);
buffer.Dispose();
Assert.AreEqual(5, data[0]);
}
unsafe static byte[] SerializeUnmanagedArray <T>(NativeArray <T> value) where T : unmanaged
{
var bytes = new byte[UnsafeUtility.SizeOf <T>() * value.Length + sizeof(int)];
fixed(byte *ptr = bytes)
{
var buf = new UnsafeAppendBuffer(ptr, bytes.Length);
buf.Add(value);
}
return(bytes);
}
public unsafe void UnsafeAppendBuffer_ReadHeadersWithPackets()
{
var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
var scratchPayload = stackalloc byte[1024];
for (int i = 0; i < 1024; i++)
{
var packeType = i;
var packetSize = i;
buffer.Add(new TestHeader
{
Type = packeType,
PayloadSize = packetSize
});
UnsafeUtility.MemSet(scratchPayload, (byte)(i & 0xff), packetSize);
buffer.Add(scratchPayload, i);
}
var reader = buffer.AsReader();
for (int i = 0; i < 1024; i++)
{
var packetHeader = reader.ReadNext <TestHeader>();
Assert.AreEqual(i, packetHeader.Type);
Assert.AreEqual(i, packetHeader.PayloadSize);
if (packetHeader.PayloadSize > 0)
{
var packetPayload = reader.ReadNext(packetHeader.PayloadSize);
Assert.AreEqual((byte)(i & 0xff), *(byte *)packetPayload);
}
}
Assert.True(reader.EndOfBuffer);
buffer.Dispose();
}
unsafe void SendAssetBundle(int playerID, GUID guid)
{
Hash128 targetHash;
string path = BuildAssetBundleIfNotCached(guid, out targetHash);
if (path == null)
{
return;
}
var stream = File.OpenRead(path);
var assetBundleFileLength = stream.Length;
var bufferSize = stream.Length + sizeof(Hash128) + sizeof(Hash128);
if (bufferSize > int.MaxValue)
{
Debug.LogError($"AssetBundle {guid} can't be sent to the player because it exceeds the 2GB size limit");
return;
}
var bundleAndHeader = new byte[bufferSize];
fixed(byte *data = bundleAndHeader)
{
var writer = new UnsafeAppendBuffer(data, bundleAndHeader.Length);
writer.Add(guid);
writer.Add(targetHash);
stream.Read(bundleAndHeader, writer.Size, (int)assetBundleFileLength);
}
stream.Close();
stream.Dispose();
LiveLinkMsg.LogSend($"AssetBundle: '{AssetDatabase.GUIDToAssetPath(guid.ToString())}' ({guid}), size: {assetBundleFileLength}, hash: {targetHash}");
EditorConnection.instance.Send(LiveLinkMsg.ResponseAssetBundleForGUID, bundleAndHeader, playerID);
}
public ResourcePacket(byte[] buffer)
{
fixed(byte *ptr = buffer)
{
var bufferReader = new UnsafeAppendBuffer.Reader(ptr, buffer.Length);
bufferReader.ReadNext(out GlobalObjectIds, Allocator.Persistent);
var entityChangeSetSourcePtr = bufferReader.Ptr + bufferReader.Offset;
var entityChangeSetSourceSize = bufferReader.Size - bufferReader.Offset;
ChangeSet = new UnsafeAppendBuffer(entityChangeSetSourceSize, 16, Allocator.Persistent);
ChangeSet.Add(entityChangeSetSourcePtr, entityChangeSetSourceSize);
}
}
void AppendObject(UnityEngine.Object obj, ref UnsafeAppendBuffer stream)
{
int index = -1;
if (obj != null)
{
if (!_ObjectTableMap.TryGetValue(obj, out index))
{
index = _ObjectTable.Count;
_ObjectTableMap.Add(obj, index);
_ObjectTable.Add(obj);
}
}
stream.Add(index);
}
unsafe void SendBuildArtifact(string artifactPath, string artifactFileName, int playerId)
{
LiveLinkMsg.LogInfo($"SendBuildArtifact => artifactPath={artifactPath}, playerId={playerId}");
if (!File.Exists(artifactPath))
{
Debug.LogError($"Attempting to send file that doesn't exist on editor. {artifactPath}");
return;
}
using (FileStream fs = new FileStream(artifactPath, FileMode.Open, FileAccess.Read))
{
// TODO: Any OS/language supports wide chars here? Should be tested
var bufferSize = fs.Length + artifactFileName.Length * sizeof(char) + sizeof(int);
if (fs.Length > int.MaxValue)
{
Debug.LogError($"File cannot be sent to the player because it exceeds the 2GB size limit. {artifactPath}");
return;
}
var buffer = new byte[bufferSize];
fixed(byte *data = buffer)
{
var writer = new UnsafeAppendBuffer(data, (int)bufferSize);
writer.Add(artifactFileName);
int numBytesToRead = (int)fs.Length;
int numBytesRead = writer.Size;
while (numBytesToRead > 0)
{
int n = fs.Read(buffer, numBytesRead, numBytesToRead);
if (n == 0)
{
break;
}
numBytesRead += n;
numBytesToRead -= n;
}
}
EditorConnection.instance.Send(LiveLinkMsg.SendBuildArtifact, buffer, playerId);
}
}
public unsafe void UnsafeAppendBuffer_ReadNextArray()
{
var values = new NativeArray <int>(new[] { 123, 234, 345 }, Allocator.Temp);
var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
buffer.Add(values);
var array = (int *)buffer.AsReader().ReadNextArray <int>(out var count);
Assert.AreEqual(values.Length, count);
for (int i = 0; i < count; ++i)
{
Assert.AreEqual(values[i], array[i]);
}
values.Dispose();
buffer.Dispose();
}
void Serialize(ref UnsafeAppendBuffer buffer)
{
buffer.Add(LoadedScenes);
buffer.Add(RemovedScenes);
}
