public unsafe void SerializeAndDeserialize_MultidimensionalArray() { var src = new ClassWithMultidimensionalArray { MultidimensionalArrayInt32 = new[, ] { { 1, 2 }, { 3, 4 } } }; var parameters = new BinarySerializationParameters { UserDefinedAdapters = new List <IBinaryAdapter> { new Array2Adapter <int>() } }; using (var stream = new UnsafeAppendBuffer(16, 4, Allocator.Temp)) { BinarySerialization.ToBinary(&stream, src, parameters); var reader = stream.AsReader(); var dst = BinarySerialization.FromBinary <ClassWithMultidimensionalArray>(&reader, parameters); Assert.That(dst.MultidimensionalArrayInt32, Is.EqualTo(new[, ] { { 1, 2 }, { 3, 4 } })); } }
static object CloneManagedComponent(object obj) { if (obj == null) { return(null); } else { #if !NET_DOTS var type = obj.GetType(); var buffer = new UnsafeAppendBuffer(16, 16, Allocator.Temp); var writer = new PropertiesBinaryWriter(&buffer); BoxedProperties.WriteBoxedType(obj, writer); var readBuffer = buffer.AsReader(); var r2 = new PropertiesBinaryReader(&readBuffer, writer.GetObjectTable()); object newObj = BoxedProperties.ReadBoxedClass(type, r2); buffer.Dispose(); return(newObj); #else // Until DOTS Runtime supports Properties just reuse the same instance return(obj); #endif } }
unsafe public void ReadWriteBoxed() { var srcData = ConfigureStruct(); // Write to stream var buffer = new UnsafeAppendBuffer(0, 16, Allocator.Persistent); var writer = new ManagedObjectBinaryWriter(&buffer); var boxedSrcData = (object)srcData; writer.WriteObject(boxedSrcData); var objectTable = writer.GetUnityObjects(); // Read from stream var readStream = buffer.AsReader(); var reader = new ManagedObjectBinaryReader(&readStream, objectTable); var boxedRead = reader.ReadObject(typeof(TestStruct)); // Check same TestStruct.AreEqual(srcData, (TestStruct)boxedRead); buffer.Dispose(); }
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 void Init(Hasher hasher, RedrawScope frameRedrawScope, RedrawScope customRedrawScope, bool isGizmos) { if (state != State.Reserved) { throw new System.InvalidOperationException(); } meta = new Meta { hasher = hasher, redrawScope1 = frameRedrawScope, redrawScope2 = customRedrawScope, isGizmos = isGizmos, version = 0, // Will be filled in later }; if (meshes == null) { meshes = new List <Mesh>(); } if (!commandBuffers.IsCreated) { commandBuffers = new NativeArray <UnsafeAppendBuffer>(JobsUtility.MaxJobThreadCount, Allocator.Persistent, NativeArrayOptions.UninitializedMemory); for (int i = 0; i < commandBuffers.Length; i++) { commandBuffers[i] = new UnsafeAppendBuffer(0, 4, Allocator.Persistent); } } state = State.Initialized; }
unsafe public void ReadWriteBoxedWithStringArrayWithOneElement() { var srcData = new ComponentWithStringArray() { StringArray = new string[] { "One" } }; // Write to stream var buffer = new UnsafeAppendBuffer(0, 16, Allocator.Persistent); var writer = new ManagedObjectBinaryWriter(&buffer); var boxedSrcData = (object)srcData; writer.WriteObject(boxedSrcData); var objectTable = writer.GetUnityObjects(); // Read from stream var readStream = buffer.AsReader(); var reader = new ManagedObjectBinaryReader(&readStream, objectTable); var boxedRead = reader.ReadObject(typeof(ComponentWithStringArray)); // Check same ComponentWithStringArray.AreEqual(srcData, (ComponentWithStringArray)boxedRead); 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(); }
public static unsafe int ManagedGetHashCode(object lhs, TypeInfo typeInfo) { var fn = (TypeInfo.ManagedGetHashCodeDelegate)typeInfo.GetHashFn; if (fn != null) { return(fn(lhs)); } var hash = 0; using (var buffer = new UnsafeAppendBuffer(16, 16, Allocator.Temp)) { var writer = new ManagedObjectBinaryWriter(&buffer); writer.WriteObject(lhs); hash = Hash32(buffer.Ptr, (uint)buffer.Length); foreach (var obj in writer.GetUnityObjects()) { hash *= FNV_32_PRIME; hash ^= obj.GetHashCode(); } } return(hash); }
unsafe public void ReadWriteObjectTableIndex() { var srcData = ConfigureStruct(); // Write to stream var buffer = new UnsafeAppendBuffer(0, 16, Allocator.Persistent); var writer = new PropertiesBinaryWriter(&buffer); PropertyContainer.Visit(ref srcData, writer); var objectTable = writer.GetObjectTable(); // Read from stream var readStream = writer.Buffer.AsReader(); var reader = new PropertiesBinaryReader(&readStream, objectTable); var readData = new TestStruct(); PropertyContainer.Visit(ref readData, reader); // Check same TestStruct.AreEqual(srcData, readData); buffer.Dispose(); }
unsafe public void ReadWriteBoxedWithStringArrayWithOneElement() { var srcData = new ComponentWithStringArray() { StringArray = new string[] { "One" } }; // Write to stream var buffer = new UnsafeAppendBuffer(0, 16, Allocator.Persistent); var writer = new PropertiesBinaryWriter(&buffer); var boxedSrcData = (object)srcData; BoxedProperties.WriteBoxedType(boxedSrcData, writer); var objectTable = writer.GetObjectTable(); // Read from stream var readStream = writer.Buffer.AsReader(); var reader = new PropertiesBinaryReader(&readStream, objectTable); var boxedRead = BoxedProperties.ReadBoxedClass(typeof(ComponentWithStringArray), reader); // Check same ComponentWithStringArray.AreEqual(srcData, (ComponentWithStringArray)boxedRead); buffer.Dispose(); }
unsafe public void ReadWriteBoxed() { var srcData = ConfigureStruct(); // Write to stream var buffer = new UnsafeAppendBuffer(0, 16, Allocator.Persistent); var writer = new PropertiesBinaryWriter(&buffer); var boxedSrcData = (object)srcData; BoxedProperties.WriteBoxedType(boxedSrcData, writer); var objectTable = writer.GetObjectTable(); // Read from stream var readStream = writer.Buffer.AsReader(); var reader = new PropertiesBinaryReader(&readStream, objectTable); var boxedRead = BoxedProperties.ReadBoxedStruct(typeof(TestStruct), reader); // Check same TestStruct.AreEqual(srcData, (TestStruct)boxedRead); buffer.Dispose(); }
public void UnsafeAppendBuffer_ThrowZeroAlignment() { Assert.Throws <ArgumentException>(() => { var buffer = new UnsafeAppendBuffer(0, 0, Allocator.Temp); }); }
public unsafe void UnsafeAppendBuffer_DisposeJob() { var sizeOf = UnsafeUtility.SizeOf <int>(); var alignOf = UnsafeUtility.AlignOf <int>(); var container = new UnsafeAppendBuffer(5, 16, Allocator.Persistent); var disposeJob = container.Dispose(default);
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]); }
public MeshBuffers(Allocator allocator) { splitterOutput = new UnsafeAppendBuffer(0, 4, allocator); vertices = new UnsafeAppendBuffer(0, 4, allocator); triangles = new UnsafeAppendBuffer(0, 4, allocator); solidVertices = new UnsafeAppendBuffer(0, 4, allocator); solidTriangles = new UnsafeAppendBuffer(0, 4, allocator); bounds = new Bounds(); }
public byte[] ToMsg() { var buffer = new UnsafeAppendBuffer(0, 16, Allocator.TempJob); Serialize(ref buffer); var bytes = buffer.ToBytes(); buffer.Dispose(); return(bytes); }
public StructuralChangeQueue(UnsafeEntityManager uem, Allocator allocator) { _uem = uem; CreateChunks = new UnsafeList(allocator); AddComponentToChunks = new UnsafeList(allocator); RemoveComponentFromChunks = new UnsafeList(allocator); AddComponentBatches = new UnsafeList(allocator); RemoveComponentBatches = new UnsafeList(allocator); ChunkScratch = new UnsafeAppendBuffer(4096, 4, Allocator.Persistent); BatchScratch = new UnsafeAppendBuffer(4096, 4, Allocator.Persistent); }
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 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 void ToBinary_StructWithInt32Property_DoesNotAllocate() { var container = new StructWithInt32Property(); GCAllocTest.Method(() => { using (var stream = new UnsafeAppendBuffer(16, 8, Allocator.Temp)) { BinarySerialization.ToBinary(&stream, container); } }) .ExpectedCount(0) .Warmup() .Run(); }
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); } }
internal static unsafe byte[] SerializeUnmanagedArray <T>(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); fixed(T *dataPtr = value) buf.AddArray <T>(dataPtr, value.Length); Assert.AreEqual(buf.Length, bytes.Length); } return(bytes); }
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(); }
protected override T SerializeAndDeserialize <T>(T value, CommonSerializationParameters parameters = default) { var stream = new UnsafeAppendBuffer(16, 8, Allocator.Temp); var binarySerializationParameters = new BinarySerializationParameters { DisableSerializedReferences = parameters.DisableSerializedReferences }; try { BinarySerialization.ToBinary(&stream, value, binarySerializationParameters); var reader = stream.AsReader(); return(BinarySerialization.FromBinary <T>(&reader, binarySerializationParameters)); } finally { stream.Dispose(); } }
public MultiAppendBuffer(Allocator allocator, int initialCapacityPerThread = JobsUtility.CacheLineSize) { var bufferSize = UnsafeUtility.SizeOf <UnsafeAppendBuffer>(); var bufferCount = JobsUtility.MaxJobThreadCount + 1; var allocationSize = bufferSize * bufferCount; var initialBufferCapacityBytes = initialCapacityPerThread; var ptr = (byte *)UnsafeUtility.Malloc(allocationSize, UnsafeUtility.AlignOf <int>(), allocator); UnsafeUtility.MemClear(ptr, allocationSize); UnsafeUtility.CopyStructureToPtr(ref allocator, ptr); var dataStartPtr = ptr + sizeof(Allocator); for (int i = 0; i < bufferCount; i++) { var bufferPtr = (UnsafeAppendBuffer *)(dataStartPtr + bufferSize * i); var buffer = new UnsafeAppendBuffer(initialBufferCapacityBytes, UnsafeUtility.AlignOf <int>(), allocator); UnsafeUtility.CopyStructureToPtr(ref buffer, bufferPtr); } Ptr = (UnsafeAppendBuffer *)dataStartPtr; }
public void FromBinary_StructWithInt32Property_DoesNotAllocate() { var container = new StructWithInt32Property(); using (var writer = new UnsafeAppendBuffer(16, 8, Allocator.Temp)) { var writerPtr = &writer; BinarySerialization.ToBinary(writerPtr, container); GCAllocTest.Method(() => { var reader = writerPtr->AsReader(); var readerPtr = &reader; BinarySerialization.FromBinary <StructWithInt32Property>(readerPtr); }) .ExpectedCount(0) .Warmup() .Run(); } }
//@TODO: Encode type in hashcode... #if !NET_DOTS public static unsafe int ManagedGetHashCode(object lhs, TypeInfo typeInfo) { var fn = (TypeInfo.ManagedGetHashCodeDelegate)typeInfo.GetHashFn; if (fn != null) { return(fn(lhs)); } int hash = 0; using (var buffer = new UnsafeAppendBuffer(16, 16, Allocator.Temp)) { var writer = new PropertiesBinaryWriter(&buffer); BoxedProperties.WriteBoxedType(lhs, writer); var remainder = buffer.Length & (sizeof(int) - 1); var alignedSize = buffer.Length - remainder; var bufferPtrAtEndOfAlignedData = buffer.Ptr + alignedSize; for (int i = 0; i < alignedSize; i += sizeof(int)) { hash *= FNV_32_PRIME; hash ^= *(int *)(buffer.Ptr + i); } for (var i = 0; i < remainder; i++) { hash *= FNV_32_PRIME; hash ^= *(byte *)(bufferPtrAtEndOfAlignedData + i); } foreach (var obj in writer.GetObjectTable()) { hash *= FNV_32_PRIME; hash ^= obj.GetHashCode(); } } return(hash); }