public static unsafe DynamicBuffer <T> GetBufferRO <T>(this EntityManager manager, Entity entity)
where T : struct, IBufferElementData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
#if ENABLE_UNITY_COLLECTIONS_CHECKS
manager.EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
if (!TypeManager.IsBuffer(typeIndex))
{
throw new ArgumentException(
$"GetBuffer<{typeof(T)}> may not be IComponentData or ISharedComponentData; currently {TypeManager.GetTypeInfo<T>().Category}");
}
#endif
manager.ComponentJobSafetyManager->CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)manager.EntityComponentStore->GetComponentDataWithTypeRO(entity, typeIndex);
int internalCapacity = TypeManager.GetTypeInfo(typeIndex).BufferCapacity;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var isReadOnly = false; // @TODO FIXME! we need DynamicBuffer<T>.GetUnsafeReadOnlyPtr();
return(new DynamicBuffer <T>(header, manager.ComponentJobSafetyManager->GetSafetyHandle(typeIndex, isReadOnly), manager.ComponentJobSafetyManager->GetBufferSafetyHandle(typeIndex), isReadOnly, internalCapacity));
#else
return(new DynamicBuffer <T>(header, internalCapacity));
#endif
}
//cm
internal void AddBufferRaw(Entity entity, int componentTypeIndex, BufferHeader *tempBuffer)
{
EntityComponentStore->AssertEntityHasComponent(entity, componentTypeIndex);
ComponentJobSafetyManager->CompleteReadAndWriteDependency(componentTypeIndex);
var bufferHeader = (BufferHeader *)EntityComponentStore->GetComponentDataWithTypeRW(entity, componentTypeIndex,
EntityComponentStore->GlobalSystemVersion);
var typeInfo = TypeManager.GetTypeInfo(componentTypeIndex);
var elementSize = typeInfo.ElementSize;
var alignment = typeInfo.AlignmentInBytes;
var total = bufferHeader->Length + tempBuffer->Length;
if (total > bufferHeader->Capacity)
{
BufferHeader.EnsureCapacity(bufferHeader, total, elementSize, alignment, BufferHeader.TrashMode.RetainOldData);
}
UnsafeUtility.MemCpy(
BufferHeader.GetElementPointer(bufferHeader) + bufferHeader->Length * elementSize,
BufferHeader.GetElementPointer(tempBuffer),
tempBuffer->Length * elementSize);
bufferHeader->Length = total;
}
public DynamicBuffer <T> GetBuffer <T>(Entity entity) where T : struct, IBufferElementData
{
CheckAccess();
var typeIndex = TypeManager.GetTypeIndex <T>();
m_EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (!TypeManager.IsBuffer(typeIndex))
{
throw new ArgumentException(
$"GetBuffer<{typeof(T)}> may not be IComponentData or ISharedComponentData; currently {TypeManager.GetTypeInfo<T>().Category}");
}
#endif
BufferHeader *header = (BufferHeader *)m_EntityComponentStore->GetComponentDataWithTypeRW(entity, typeIndex, m_EntityComponentStore->GlobalSystemVersion);
int internalCapacity = TypeManager.GetTypeInfo(typeIndex).BufferCapacity;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
return(new DynamicBuffer <T>(header, m_Safety, m_Safety, false, internalCapacity));
#else
return(new DynamicBuffer <T>(header, internalCapacity));
#endif
}
public static void EnsureCapacity(BufferHeader *header, int count, int typeSize, int alignment, TrashMode trashMode)
{
if (header->Capacity >= count)
{
return;
}
int newCapacity = Math.Max(Math.Max(2 * header->Capacity, count), kMinimumCapacity);
long newBlockSize = newCapacity * typeSize;
byte *oldData = GetElementPointer(header);
byte *newData = (byte *)UnsafeUtility.Malloc(newBlockSize, alignment, Allocator.Persistent);
if (trashMode == TrashMode.RetainOldData)
{
long oldBlockSize = header->Capacity * typeSize;
UnsafeUtility.MemCpy(newData, oldData, oldBlockSize);
}
// Note we're freeing the old buffer only if it was not using the internal capacity. Don't change this to 'oldData', because that would be a bug.
if (header->Pointer != null)
{
UnsafeUtility.Free(header->Pointer, Allocator.Persistent);
}
header->Pointer = newData;
header->Capacity = newCapacity;
}
private IpcCircularBuffer(Section section, string sectionName, Semaphore readSemaphore, Semaphore writeSemaphore)
{
BufferHeader header;
_section = section;
_sectionView = section.MapView(Marshal.SizeOf(typeof(BufferHeader)));
header = _sectionView.ReadStruct <BufferHeader>();
_sectionView.Dispose();
if (readSemaphore == null || writeSemaphore == null)
{
_readSemaphore = new Semaphore(sectionName + "_" + header.ReadSemaphoreId.ToString("x"));
_writeSemaphore = new Semaphore(sectionName + "_" + header.WriteSemaphoreId.ToString("x"));
}
else
{
_readSemaphore = readSemaphore;
_writeSemaphore = writeSemaphore;
}
_sectionView = _section.MapView(header.BlockSize * header.NumberOfBlocks);
_header = (BufferHeader *)_sectionView.Memory;
_data = &_header->Data;
}
public DynamicBuffer <T> this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
if (index < m_MinIndex || index > m_MaxIndex)
{
FailOutOfRangeError(index);
}
var safety = m_Safety;
#endif
if (index < m_Cache.CachedBeginIndex || index >= m_Cache.CachedEndIndex)
{
m_Iterator.UpdateCache(index, out m_Cache, !m_IsReadOnly);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (m_Cache.CachedSizeOf < sizeof(BufferHeader))
{
throw new InvalidOperationException("size cache info is broken");
}
#endif
}
BufferHeader *header = (BufferHeader *)((byte *)m_Cache.CachedPtr + index * m_Cache.CachedSizeOf);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
return(new DynamicBuffer <T>(header, m_Safety));
#else
return(new DynamicBuffer <T>(header));
#endif
}
}
/// <summary>
/// Gets the dynamic buffer of an entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <typeparam name="T">The type of the buffer's elements.</typeparam>
/// <returns>The DynamicBuffer object for accessing the buffer contents.</returns>
/// <exception cref="ArgumentException">Thrown if T is an unsupported type.</exception>
public DynamicBuffer <T> GetBuffer <T>(Entity entity) where T : struct, IBufferElementData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
#if ENABLE_UNITY_COLLECTIONS_CHECKS
EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
if (!TypeManager.IsBuffer(typeIndex))
{
throw new ArgumentException(
$"GetBuffer<{typeof(T)}> may not be IComponentData or ISharedComponentData; currently {TypeManager.GetTypeInfo<T>().Category}");
}
#endif
ComponentJobSafetyManager->CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header =
(BufferHeader *)EntityComponentStore->GetComponentDataWithTypeRW(entity, typeIndex,
EntityComponentStore->GlobalSystemVersion);
int internalCapacity = TypeManager.GetTypeInfo(typeIndex).BufferCapacity;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
return(new DynamicBuffer <T>(header, ComponentJobSafetyManager->GetSafetyHandle(typeIndex, false),
ComponentJobSafetyManager->GetBufferSafetyHandle(typeIndex), false, internalCapacity));
#else
return(new DynamicBuffer <T>(header, internalCapacity));
#endif
}
public static void PatchEntitiesForPrefab(EntityPatchInfo *scalarPatches, int scalarPatchCount, BufferEntityPatchInfo *bufferPatches, int bufferPatchCount, byte *data, int indexInChunk, int entityCount, SparseEntityRemapInfo *remapping, int remappingCount)
{
// Patch scalars (single components) with entity references.
for (int p = 0; p < scalarPatchCount; p++)
{
byte *entityData = data + scalarPatches[p].Offset;
for (int e = 0; e != entityCount; e++)
{
Entity *entity = (Entity *)(entityData + scalarPatches[p].Stride * (e + indexInChunk));
* entity = RemapEntityForPrefab(remapping + e * remappingCount, remappingCount, *entity);
}
}
// Patch buffers that contain entity references
for (int p = 0; p < bufferPatchCount; ++p)
{
byte *bufferData = data + bufferPatches[p].BufferOffset;
for (int e = 0; e != entityCount; e++)
{
BufferHeader *header = (BufferHeader *)(bufferData + bufferPatches[p].BufferStride * (e + indexInChunk));
byte *elemsBase = BufferHeader.GetElementPointer(header) + bufferPatches[p].ElementOffset;
int elemCount = header->Length;
for (int k = 0; k != elemCount; ++k)
{
Entity *entityPtr = (Entity *)elemsBase;
* entityPtr = RemapEntityForPrefab(remapping + e * remappingCount, remappingCount, *entityPtr);
elemsBase += bufferPatches[p].ElementStride;
}
}
}
}
public DynamicBuffer <T> this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (m_IsReadOnly)
{
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
}
else
{
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
}
if (index < 0 || index >= Length)
{
throw new InvalidOperationException($"index {index} out of range in LowLevelBufferAccessor of length {Length}");
}
#endif
BufferHeader *hdr = (BufferHeader *)(m_BasePointer + index * m_Stride);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
return(new DynamicBuffer <T>(hdr, m_Safety, m_ArrayInvalidationSafety));
#else
return(new DynamicBuffer <T>(hdr));
#endif
}
}
public static unsafe void Destroy(BufferHeader *header)
{
if (header.Pointer != null)
{
UnsafeUtility.Free((void *)header.Pointer, Allocator.Persistent);
}
Initialize(header, 0);
}
public static void ReplicateComponents(Chunk *srcChunk, int srcIndex, Chunk *dstChunk, int dstBaseIndex, int count)
{
var srcArchetype = srcChunk->Archetype;
var srcBuffer = srcChunk->Buffer;
var dstBuffer = dstChunk->Buffer;
var dstArchetype = dstChunk->Archetype;
var srcOffsets = srcArchetype->Offsets;
var srcSizeOfs = srcArchetype->SizeOfs;
var srcBufferCapacities = srcArchetype->BufferCapacities;
var srcTypesCount = srcArchetype->TypesCount;
var srcTypes = srcArchetype->Types;
var dstTypes = dstArchetype->Types;
var dstOffsets = dstArchetype->Offsets;
var dstTypeIndex = 1;
// type[0] is always Entity, and will be patched up later, so just skip
for (var srcTypeIndex = 1; srcTypeIndex != srcTypesCount; srcTypeIndex++)
{
var srcType = srcTypes[srcTypeIndex];
var dstType = dstTypes[dstTypeIndex];
// Type does not exist in destination. Skip it.
if (srcType.TypeIndex != dstType.TypeIndex)
{
continue;
}
var srcOffset = srcOffsets[srcTypeIndex];
var srcSizeOf = srcSizeOfs[srcTypeIndex];
var dstOffset = dstOffsets[dstTypeIndex];
var src = srcBuffer + (srcOffset + srcSizeOf * srcIndex);
var dst = dstBuffer + (dstOffset + srcSizeOf * dstBaseIndex);
if (!srcType.IsBuffer)
{
UnsafeUtility.MemCpyReplicate(dst, src, srcSizeOf, count);
}
else
{
var srcBufferCapacity = srcBufferCapacities[srcTypeIndex];
var alignment = 8; // TODO: Need a way to compute proper alignment for arbitrary non-generic types in TypeManager
var elementSize = TypeManager.GetTypeInfo(srcType.TypeIndex).ElementSize;
for (int i = 0; i < count; ++i)
{
BufferHeader *srcHdr = (BufferHeader *)src;
BufferHeader *dstHdr = (BufferHeader *)dst;
BufferHeader.Initialize(dstHdr, srcBufferCapacity);
BufferHeader.Assign(dstHdr, BufferHeader.GetElementPointer(srcHdr), srcHdr->Length, elementSize, alignment);
dst += srcSizeOf;
}
}
dstTypeIndex++;
}
}
public static unsafe void PatchEntities(EntityPatchInfo *scalarPatches, int scalarPatchCount, BufferEntityPatchInfo *bufferPatches, int bufferPatchCount, byte *data, int count, ref NativeArray <EntityRemapInfo> remapping)
{
int index = 0;
while (true)
{
if (index >= scalarPatchCount)
{
int num3 = 0;
while (num3 < bufferPatchCount)
{
byte *numPtr2 = data + bufferPatches[num3].BufferOffset;
int num4 = 0;
while (true)
{
if (num4 == count)
{
num3++;
break;
}
BufferHeader *header = (BufferHeader *)numPtr2;
byte * numPtr3 = BufferHeader.GetElementPointer(header) + bufferPatches[num3].ElementOffset;
int length = header->Length;
int num6 = 0;
while (true)
{
if (num6 == length)
{
numPtr2 += bufferPatches[num3].BufferStride;
num4++;
break;
}
Entity *entityPtr2 = (Entity *)numPtr3;
entityPtr2[0] = RemapEntity(ref remapping, entityPtr2[0]);
numPtr3 += bufferPatches[num3].ElementStride;
num6++;
}
}
}
return;
}
byte *numPtr = data + scalarPatches[index].Offset;
int num2 = 0;
while (true)
{
if (num2 == count)
{
index++;
break;
}
Entity *entityPtr = (Entity *)numPtr;
entityPtr[0] = RemapEntity(ref remapping, entityPtr[0]);
numPtr += scalarPatches[index].Stride;
num2++;
}
}
}
public static void Destroy(BufferHeader *header)
{
if (header->Pointer != null)
{
Memory.Unmanaged.Free(header->Pointer, Allocator.Persistent);
}
Initialize(header, 0);
}
public void SetBufferRaw(Entity entity, int componentTypeIndex, BufferHeader *tempBuffer, int sizeInChunk)
{
if (m_IsMainThread)
{
DependencyManager->CompleteReadAndWriteDependency(componentTypeIndex);
}
EntityComponentStore->SetBufferRawWithValidation(entity, componentTypeIndex, tempBuffer, sizeInChunk);
}
public static byte *GetElementPointer(BufferHeader *header)
{
if (header->Pointer != null)
{
return(header->Pointer);
}
return((byte *)(header + 1));
}
internal DynamicBuffer(BufferHeader *header, AtomicSafetyHandle safety, AtomicSafetyHandle arrayInvalidationSafety, bool isReadOnly)
{
m_Buffer = header;
m_Safety0 = safety;
m_Safety1 = arrayInvalidationSafety;
m_SafetyReadOnlyCount = isReadOnly ? 2 : 0;
m_SafetyReadWriteCount = isReadOnly ? 0 : 2;
m_IsReadOnly = isReadOnly;
}
internal unsafe void SetBufferRaw(Entity entity, int componentTypeIndex, BufferHeader *tempBuffer, int sizeInChunk)
{
this.Entities.AssertEntityHasComponent(entity, componentTypeIndex);
this.ComponentJobSafetyManager.CompleteReadAndWriteDependency(componentTypeIndex);
byte *numPtr = ref this.Entities.GetComponentDataWithTypeRW(entity, componentTypeIndex, this.Entities.GlobalSystemVersion);
BufferHeader.Destroy((BufferHeader *)numPtr);
UnsafeUtility.MemCpy((void *)numPtr, (void *)tempBuffer, (long)sizeInChunk);
}
public static void EnsureCapacity(BufferHeader *header, int count, int typeSize, int alignment, TrashMode trashMode, bool useMemoryInitPattern, byte memoryInitPattern)
{
if (count <= header->Capacity)
{
return;
}
var adjustedCount = Math.Max(kMinimumCapacity, Math.Max(2 * header->Capacity, count)); // stop pathological performance of ++Capacity allocating every time, tiny Capacities
SetCapacity(header, adjustedCount, typeSize, alignment, trashMode, useMemoryInitPattern, memoryInitPattern, 0);
}
public static void Burst_Unity__Entities__EntityDataAccess_SetBufferRaw(IntPtr p)
{
var v0 = default(Entity);
var v1 = default(int);
BufferHeader *v2 = (BufferHeader *)((byte *)p + 2048);
var v3 = default(int);
var instance = (EntityDataAccess *)p;
instance->SetBufferRaw(v0, v1, v2, v3);
}
internal void *GetBufferRawRW(Entity entity, int typeIndex)
{
Entities->AssertEntityHasComponent(entity, typeIndex);
ComponentJobSafetyManager.CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)Entities->GetComponentDataWithTypeRW(entity, typeIndex, Entities->GlobalSystemVersion);
return(BufferHeader.GetElementPointer(header));
}
internal int GetBufferLength(Entity entity, int typeIndex)
{
Entities->AssertEntityHasComponent(entity, typeIndex);
ComponentJobSafetyManager.CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)Entities->GetComponentDataWithTypeRW(entity, typeIndex, Entities->GlobalSystemVersion);
return(header->Length);
}
internal int GetBufferLength(Entity entity, int typeIndex)
{
EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
ComponentJobSafetyManager->CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)EntityComponentStore->GetComponentDataWithTypeRO(entity, typeIndex);
return(header->Length);
}
internal void *GetBufferRawRO(Entity entity, int typeIndex)
{
EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
ComponentJobSafetyManager->CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)EntityComponentStore->GetComponentDataWithTypeRO(entity, typeIndex);
return(BufferHeader.GetElementPointer(header));
}
public static void Assign(BufferHeader *header, byte *source, int count, int typeSize, int alignment)
{
EnsureCapacity(header, count, typeSize, alignment, TrashMode.TrashOldData);
// Select between internal capacity buffer and heap buffer.
byte *elementPtr = GetElementPointer(header);
UnsafeUtility.MemCpy(elementPtr, source, typeSize * count);
header->Length = count;
}
public DynamicBuffer <T> CreateBufferCommand <T>(ECBCommand commandType, EntityCommandBufferChain *chain, Entity e) where T : struct, IBufferElementData
{
BufferHeader *header = AddEntityBufferCommand <T>(chain, commandType, e);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var safety = m_BufferSafety;
AtomicSafetyHandle.UseSecondaryVersion(ref safety);
return(new DynamicBuffer <T>(header, safety));
#else
return(new DynamicBuffer <T>(header));
#endif
}
internal DynamicBuffer(BufferHeader *header, AtomicSafetyHandle safety, AtomicSafetyHandle arrayInvalidationSafety, bool isReadOnly, bool useMemoryInitPattern, byte memoryInitPattern, int internalCapacity)
{
m_Buffer = header;
m_Safety0 = safety;
m_Safety1 = arrayInvalidationSafety;
m_SafetyReadOnlyCount = isReadOnly ? 2 : 0;
m_SafetyReadWriteCount = isReadOnly ? 0 : 2;
m_IsReadOnly = isReadOnly;
m_InternalCapacity = internalCapacity;
m_useMemoryInitPattern = useMemoryInitPattern;
m_memoryInitPattern = memoryInitPattern;
}
internal void SetBufferRaw(Entity entity, int componentTypeIndex, BufferHeader *tempBuffer, int sizeInChunk)
{
Entities->AssertEntityHasComponent(entity, componentTypeIndex);
ComponentJobSafetyManager.CompleteReadAndWriteDependency(componentTypeIndex);
var ptr = Entities->GetComponentDataWithTypeRW(entity, componentTypeIndex, Entities->GlobalSystemVersion);
BufferHeader.Destroy((BufferHeader *)ptr);
UnsafeUtility.MemCpy(ptr, tempBuffer, sizeInChunk);
}
internal void *GetBufferRawRW(Entity entity, int typeIndex)
{
var access = GetCheckedEntityDataAccess();
var ecs = access->EntityComponentStore;
ecs->AssertEntityHasComponent(entity, typeIndex);
access->DependencyManager->CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)ecs->GetComponentDataWithTypeRW(entity, typeIndex, ecs->GlobalSystemVersion);
return(BufferHeader.GetElementPointer(header));
}
internal int GetBufferLength(Entity entity, int typeIndex)
{
var access = GetCheckedEntityDataAccess();
var ecs = access->EntityComponentStore;
ecs->AssertEntityHasComponent(entity, typeIndex);
access->DependencyManager->CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)ecs->GetComponentDataWithTypeRO(entity, typeIndex);
return(header->Length);
}
public BufferHeader *Alloc(int size)
{
if (size == _pageSize)
{
return(Alloc());
}
BufferHeader *header = (BufferHeader *)Marshal.AllocHGlobal(size + BufferHeader.BufferHeaderSize);
(*header).Next = null;
(*header).Size = size;
(*header).Used = 0;
return(header);
}
protected override void Dispose(bool disposing)
{
var pool = Interlocked.Exchange(ref _pool, null);
var head = _first;
_first = null;
_current = null;
if (head != null && pool != null)
pool.Dealloc(head);
base.Dispose(disposing);
}
int EnsureCapacity()
{
var pool = _pool ?? (_pool = ThreadBufferPool.Pool);
if (_current == null)
{
var buffer = pool.Alloc();
_current = _first = buffer;
return (*_current).Size;
}
var current = (*_current);
if (current.Used == current.Size)
{
var buffer = pool.Alloc();
(*_current).Next = buffer;
_current = buffer;
return (*buffer).Size;
}
return current.Size - current.Used;
}
