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();
}