public static unsafe void PoisonUnusedChunkData(Chunk *chunk, byte value) { Archetype *archetype = chunk.Archetype; int chunkBufferSize = Chunk.GetChunkBufferSize(archetype->TypesCount, archetype->NumSharedComponents); byte * numPtr = &chunk.Buffer.FixedElementField; int count = chunk.Count; int index = 0; while (true) { if (index >= (archetype->TypesCount - 1)) { int num3 = archetype->TypeMemoryOrder[archetype->TypesCount - 1]; int num4 = archetype->Offsets[num3] + (count * archetype->SizeOfs[num3]); UnsafeUtilityEx.MemSet((void *)(numPtr + num4), value, chunkBufferSize - num4); return; } int num6 = archetype->TypeMemoryOrder[index]; int num7 = archetype->TypeMemoryOrder[index + 1]; int num8 = archetype->Offsets[num6] + (count * archetype->SizeOfs[num6]); int num9 = archetype->Offsets[num7]; UnsafeUtilityEx.MemSet((void *)(numPtr + num8), value, num9 - num8); index++; } }
public void OnCreate() { m_TypeArrayIndices = (ushort *)UnsafeUtility.Malloc(sizeof(ushort) * kMaxTypes, 16, Allocator.Persistent); UnsafeUtilityEx.MemSet(m_TypeArrayIndices, 0xFF, sizeof(ushort) * kMaxTypes); #if ENABLE_UNITY_COLLECTIONS_CHECKS m_TempSafety = AtomicSafetyHandle.Create(); #endif m_ReadJobFences = (JobHandle *)UnsafeUtility.Malloc(sizeof(JobHandle) * kMaxReadJobHandles * kMaxTypes, 16, Allocator.Persistent); UnsafeUtility.MemClear(m_ReadJobFences, sizeof(JobHandle) * kMaxReadJobHandles * kMaxTypes); m_ComponentSafetyHandles = (ComponentSafetyHandle *)UnsafeUtility.Malloc(sizeof(ComponentSafetyHandle) * kMaxTypes, 16, Allocator.Persistent); UnsafeUtility.MemClear(m_ComponentSafetyHandles, sizeof(ComponentSafetyHandle) * kMaxTypes); m_JobDependencyCombineBufferCount = 4 * 1024; m_JobDependencyCombineBuffer = (JobHandle *)UnsafeUtility.Malloc( sizeof(ComponentSafetyHandle) * m_JobDependencyCombineBufferCount, 16, Allocator.Persistent); m_TypeCount = 0; IsInTransaction = false; m_ExclusiveTransactionDependency = default(JobHandle); }
public static void PoisonUnusedChunkData(Chunk *chunk, byte value) { var arch = chunk->Archetype; int bufferSize = Chunk.GetChunkBufferSize(arch->NumSharedComponents); byte *buffer = chunk->Buffer; int count = chunk->Count; for (int i = 0; i < arch->TypesCount - 1; ++i) { int startOffset = arch->Offsets[i] + count * arch->SizeOfs[i]; int endOffset = arch->Offsets[i + 1]; UnsafeUtilityEx.MemSet(buffer + startOffset, value, endOffset - startOffset); } int lastStartOffset = arch->Offsets[arch->TypesCount - 1] + count * arch->SizeOfs[arch->TypesCount - 1]; UnsafeUtilityEx.MemSet(buffer + lastStartOffset, value, bufferSize - lastStartOffset); }
public static void PoisonUnusedChunkData(Chunk *chunk, byte value) { var arch = chunk->Archetype; var bufferSize = Chunk.GetChunkBufferSize(arch->TypesCount, arch->NumSharedComponents); var buffer = chunk->Buffer; var count = chunk->Count; for (int i = 0; i < arch->TypesCount - 1; ++i) { var index = arch->TypeMemoryOrder[i]; var nextIndex = arch->TypeMemoryOrder[i + 1]; var startOffset = arch->Offsets[index] + count * arch->SizeOfs[index]; var endOffset = arch->Offsets[nextIndex]; UnsafeUtilityEx.MemSet(buffer + startOffset, value, endOffset - startOffset); } var lastIndex = arch->TypeMemoryOrder[arch->TypesCount - 1]; var lastStartOffset = arch->Offsets[lastIndex] + count * arch->SizeOfs[lastIndex]; UnsafeUtilityEx.MemSet(buffer + lastStartOffset, value, bufferSize - lastStartOffset); }
public unsafe void 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 }); UnsafeUtilityEx.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(); }