/// <summary>
/// Returns parallel reader instance.
/// </summary>
/// <returns>Parallel writer instance.</returns>
public ParallelWriter AsParallelWriter()
{
ParallelWriter writer;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
writer.m_Safety = m_Safety;
AtomicSafetyHandle.UseSecondaryVersion(ref writer.m_Safety);
#endif
writer.m_Buffer = m_Buffer;
writer.m_QueuePool = m_QueuePool;
writer.m_ThreadIndex = 0;
return(writer);
}
public Transform this[int index]
{
get
{
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
return(GetTransform(m_TransformArray, index));
}
set
{
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
SetTransform(m_TransformArray, index, value);
}
}
private void AddRangeNoResize(int sizeOf, int alignOf, void *ptr, int length)
{
var idx = Interlocked.Add(ref ListData->Length, length) - length;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
if (ListData->Capacity < idx + length)
{
throw new Exception($"AddRangeNoResize assumes that list capacity is sufficient (Capacity {ListData->Capacity}, Lenght {ListData->Length})!");
}
#endif
void *dst = (byte *)Ptr + idx * sizeOf;
UnsafeUtility.MemCpy(dst, ptr, length * sizeOf);
}
public void CalculateLength_SyncsChangeFilterTypes()
{
var group = m_Manager.CreateComponentGroup(typeof(EcsTestData));
group.SetFilterChanged(typeof(EcsTestData));
var ws1 = World.GetOrCreateManager <WriteEcsTestDataSystem>();
ws1.Update();
var safetyHandle = m_Manager.ComponentJobSafetyManager.GetSafetyHandle(TypeManager.GetTypeIndex <EcsTestData>(), false);
Assert.Throws <InvalidOperationException>(() => AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle));
group.CalculateLength();
AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle);
group.Dispose();
}
public void CompleteReadAndWriteDependency(int type)
{
//TODO: avoid call and turn into assert
if (TypeManager.IsZeroSized(type))
{
return;
}
CompleteReadAndWriteDependencyNoChecks(type);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var typeWithoutFlags = type & TypeManager.ClearFlagsMask;
AtomicSafetyHandle.CheckWriteAndThrow(m_ComponentSafetyHandles[typeWithoutFlags].SafetyHandle);
AtomicSafetyHandle.CheckWriteAndThrow(m_ComponentSafetyHandles[typeWithoutFlags].BufferHandle);
#endif
}
static void CopySafe(T[] src, int srcIndex, NativeArray <T> dst, int dstIndex, int length)
{
AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety);
CheckCopyPtr(src);
CheckCopyArguments(src.Length, srcIndex, dst.Length, dstIndex, length);
var handle = GCHandle.Alloc(src, GCHandleType.Pinned);
var addr = handle.AddrOfPinnedObject();
UnsafeUtility.MemCpy(
(byte *)dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf <T>(),
(byte *)addr + srcIndex * UnsafeUtility.SizeOf <T>(),
length * UnsafeUtility.SizeOf <T>());
handle.Free();
}
void CheckElementWriteAccess(int index)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (index < m_MinIndex || index > m_MaxIndex)
{
FailOutOfRangeError(index);
}
// Check versions match and write protection is not flagged
int version = m_Safety.UncheckedGetNodeVersion();
if (m_Safety.version != (version & AtomicSafetyNodeVersionMask.VersionAndWriteProtect))
{
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
}
#endif
}
public NativeMinHeapNode <TValue, TPriority> Pop()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (size == 0)
{
throw new IndexOutOfRangeException($"Size is zero");
}
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
var result = this[0];
this[0] = this[size - 1];
size--;
BubbleDown();
return(result);
}
private void CheckReinterpretStoreRange <U>(int destIndex) where U : struct
{
long num = (long)UnsafeUtility.SizeOf <T>();
AtomicSafetyHandle.CheckWriteAndThrow(this.m_Safety);
long num2 = (long)UnsafeUtility.SizeOf <U>();
long num3 = (long)this.Length * num;
long num4 = (long)destIndex * num;
long num5 = num4 + num2;
bool flag = num4 <0L || num5> num3;
if (flag)
{
throw new ArgumentOutOfRangeException("destIndex", "stored byte range must fall inside container bounds");
}
}
public unsafe void CalculateEntityCount_SyncsChangeFilterTypes()
{
var group = m_Manager.CreateEntityQuery(typeof(EcsTestData));
group.SetChangedVersionFilter(typeof(EcsTestData));
var ws1 = World.GetOrCreateSystem <WriteEcsTestDataSystem>();
ws1.Update();
var safetyHandle = m_Manager.SafetyHandles->GetSafetyHandle(TypeManager.GetTypeIndex <EcsTestData>(), false);
Assert.Throws <InvalidOperationException>(() => AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle));
group.CalculateEntityCount();
AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle);
group.Dispose();
}
/// <summary>
/// Removes all elements from this container. Any NativeHeapIndex structures obtained will be
/// invalidated and cannot be used again.
/// </summary>
public void Clear()
{
unsafe {
#if NHEAP_SAFE
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
for (int i = 0; i < _data->Count; i++)
{
var node = ReadArrayElement <HeapNode>(_data->Heap, i);
_data->Table[node.TableIndex].Version++;
}
#endif
_data->Count = 0;
}
}
internal void DestroyInstance()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
PreDisposeCheck();
GetCheckedEntityDataAccess()->Dispose();
UnsafeUtility.Free(m_EntityDataAccess, Allocator.Persistent);
m_EntityDataAccess = null;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.Release(m_Safety);
m_Safety = default;
#endif
}
public unsafe static void Copy(T[] src, int srcIndex, NativeArray <T> dst, int dstIndex, int length)
{
AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety);
bool flag = src == null;
if (flag)
{
throw new ArgumentNullException("src");
}
NativeArray <T> .CheckCopyArguments(src.Length, srcIndex, dst.Length, dstIndex, length);
GCHandle gCHandle = GCHandle.Alloc(src, GCHandleType.Pinned);
IntPtr value = gCHandle.AddrOfPinnedObject();
UnsafeUtility.MemCpy((void *)((byte *)dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf <T>()), (void *)((byte *)((void *)value) + srcIndex * UnsafeUtility.SizeOf <T>()), (long)(length * UnsafeUtility.SizeOf <T>()));
gCHandle.Free();
}
/// <summary>
/// Resets the value contained within this result to the identity value.
/// </summary>
public void Reset()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
T identity;
m_Op.GetIdentity(out identity);
unsafe {
void *ptr = (void *)m_Buffer;
for (int i = 0; i < JobsUtility.MaxJobThreadCount; i++)
{
UnsafeUtility.WriteArrayElementWithStride(ptr, i, JobsUtility.CacheLineSize, identity);
}
}
}
public void CheckAccess()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
fixed(AtomicSafetyHandle *safety = &m_Safety0)
{
for (var i = 0; i < m_SafetyReadOnlyCount; i++)
{
AtomicSafetyHandle.CheckReadAndThrow(safety[i]);
}
for (var i = m_SafetyReadOnlyCount; i < m_SafetyReadOnlyCount + m_SafetyReadWriteCount; i++)
{
AtomicSafetyHandle.CheckWriteAndThrow(safety[i]);
}
}
#endif
}
private void CheckReinterpretStoreRange <U>(int destIndex) where U : struct
{
long tsize = UnsafeUtility.SizeOf <T>();
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
long usize = UnsafeUtility.SizeOf <U>();
long byteSize = Length * tsize;
long firstByte = destIndex * tsize;
long lastByte = firstByte + usize;
if (firstByte < 0 || lastByte > byteSize)
{
throw new ArgumentOutOfRangeException(nameof(destIndex), "stored byte range must fall inside container bounds");
}
}
public T this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
return(m_Impl[index]);
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
m_Impl[index] = value;
}
}
/// <summary>
/// Ends an exclusive entity transaction.
/// </summary>
/// <seealso cref="ExclusiveEntityTransaction"/>
/// <seealso cref="BeginExclusiveEntityTransaction()"/>
public void EndExclusiveEntityTransaction()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (m_IsInExclusiveTransaction == 1)
{
throw new InvalidOperationException("Transactions can only be ended from the main thread");
}
AtomicSafetyHandle.CheckExistsAndThrow(m_Safety);
#endif
m_EntityDataAccess->DependencyManager->PreEndExclusiveTransaction();
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
m_EntityDataAccess->DependencyManager->EndExclusiveTransaction();
m_EntityDataAccess->m_IsInExclusiveTransaction = 0;
}
public void SendCandidate(int candidate)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
int expectValue, realValue;
switch (m_Mode)
{
case MinMax.Min:
{
do
{
expectValue = *m_MinOrMax;
if (candidate < expectValue)
{
realValue = CompareExchange(ref *m_MinOrMax, candidate, expectValue);
}
else
{
realValue = expectValue;
}
} while (realValue != expectValue);
}
break;
case MinMax.Max:
{
do
{
expectValue = *m_MinOrMax;
if (candidate > expectValue)
{
realValue = CompareExchange(ref *m_MinOrMax, candidate, expectValue);
}
else
{
realValue = expectValue;
}
} while (realValue != expectValue);
}
break;
}
}
public static void Copy(T[] src, int srcIndex, NativeArray <T> dst, int dstIndex, int length)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(dst.m_Safety);
if (src == null)
{
throw new ArgumentNullException(nameof(src));
}
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length), "length must be equal or greater than zero.");
}
if (srcIndex < 0 || srcIndex > src.Length || (srcIndex == src.Length && src.Length > 0))
{
throw new ArgumentOutOfRangeException(nameof(srcIndex), "srcIndex is outside the range of valid indexes for the source array.");
}
if (dstIndex < 0 || dstIndex > dst.Length || (dstIndex == dst.Length && dst.Length > 0))
{
throw new ArgumentOutOfRangeException(nameof(dstIndex), "dstIndex is outside the range of valid indexes for the destination NativeArray.");
}
if (srcIndex + length > src.Length)
{
throw new ArgumentException("length is greater than the number of elements from srcIndex to the end of the source array.", nameof(length));
}
if (dstIndex + length > dst.Length)
{
throw new ArgumentException("length is greater than the number of elements from dstIndex to the end of the destination NativeArray.", nameof(length));
}
#endif
var handle = GCHandle.Alloc(src, GCHandleType.Pinned);
var addr = handle.AddrOfPinnedObject();
UnsafeUtility.MemCpy(
(byte *)dst.m_Buffer + dstIndex * UnsafeUtility.SizeOf <T>(),
(byte *)addr + srcIndex * UnsafeUtility.SizeOf <T>(),
length * UnsafeUtility.SizeOf <T>());
handle.Free();
}
public void AddRef(ref T data)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
int tlsIdx = m_ThreadIndex;
NativeBucketHeader *header = (NativeBucketHeader *)GetHeaderBlock(m_HeaderBlock, tlsIdx);
CheckAndAllocateBlock(header);
int incNum = Interlocked.Increment(ref header->itemsInBlock);
if (incNum > m_BlockNumCapacity)
{
throw new ArgumentOutOfRangeException(nameof(m_BlockNumCapacity), "exceeded.");
}
UnsafeUtility.WriteArrayElementWithStride((void *)header->block,
incNum - 1,
header->unitSize,
data);
}
public void WritePackedUInt(uint value, NetworkCompressionModel model)
{
int bucket = model.CalculateBucket(value);
uint offset = model.bucketOffsets[bucket];
int bits = model.bucketSizes[bucket];
ushort encodeEntry = model.encodeTable[bucket];
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
if (m_Data->length + ((m_Data->bitIndex + encodeEntry & 0xff + bits + 7) >> 3) > m_Data->capacity)
{
throw new System.ArgumentOutOfRangeException();
}
#endif
WriteRawBitsInternal((uint)(encodeEntry >> 8), encodeEntry & 0xFF);
WriteRawBitsInternal(value - offset, bits);
FlushBits();
}
public unsafe void CreateArchetypeChunkArray_SyncsChangeFilterTypes()
{
var group = m_Manager.CreateEntityQuery(typeof(EcsTestData));
group.SetFilterChanged(typeof(EcsTestData));
var ws1 = World.GetOrCreateSystem <WriteEcsTestDataSystem>();
ws1.Update();
var safetyHandle = m_Manager.ComponentJobSafetyManager->GetSafetyHandle(TypeManager.GetTypeIndex <EcsTestData>(), false);
Assert.Throws <InvalidOperationException>(() => AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle));
var chunks = group.CreateArchetypeChunkArray(Allocator.TempJob);
AtomicSafetyHandle.CheckWriteAndThrow(safetyHandle);
chunks.Dispose();
group.Dispose();
}
public unsafe void AddUniqueVertices(ref ChiselBlobArray <float3> uniqueVertices)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
// Add Unique vertex
for (int i = 0; i < uniqueVertices.Length; i++)
{
var vertex = uniqueVertices[i];
var centerIndex = new int3((int)(vertex.x / kCellSize), (int)(vertex.y / kCellSize), (int)(vertex.z / kCellSize));
var hashCode = HashedVerticesUtility.GetHash(centerIndex);
var prevChainIndex = ((ushort *)m_HashTable)[hashCode];
var newChainIndex = m_ChainedIndices->Length;
m_Vertices->AddNoResize(vertex);
m_ChainedIndices->AddNoResize((ushort)prevChainIndex);
((ushort *)m_HashTable)[(int)hashCode] = (ushort)(newChainIndex + 1);
}
}
public byte this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
return(*(m_Counter + index));
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
*(m_Counter + index) = value;
}
}
/// <summary>
/// Retrieve a member of the contaner by index.
/// </summary>
/// <param name="index">The zero-based index into the list.</param>
/// <value>The list item at the specified index.</value>
/// <exception cref="IndexOutOfRangeException">Thrown if index is negative or >= to <see cref="Length"/>.</exception>
public T this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
CheckIndexInRange(index, m_ListData->Length);
return(UnsafeUtility.ReadArrayElement <T>(m_ListData->Ptr, CollectionHelper.AssumePositive(index)));
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
CheckIndexInRange(index, m_ListData->Length);
UnsafeUtility.WriteArrayElement(m_ListData->Ptr, CollectionHelper.AssumePositive(index), value);
}
}
public NativeQuadTreeNode this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
CheckIndexInRange(index, m_ListData->Length);
return(UnsafeUtility.ReadArrayElement <NativeQuadTreeNode>(m_ListData->Ptr, index));
}
private set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
CheckIndexInRange(index, m_ListData->Length);
UnsafeUtility.WriteArrayElement(m_ListData->Ptr, index, value);
}
}
public DynamicBuffer <T> this[int index]
{
get
{
if (this.m_IsReadOnly)
{
AtomicSafetyHandle.CheckReadAndThrow(this.m_Safety0);
}
else
{
AtomicSafetyHandle.CheckWriteAndThrow(this.m_Safety0);
}
if ((index < 0) || (index >= this.Length))
{
throw new InvalidOperationException($"index {index} out of range in LowLevelBufferAccessor of length {this.Length}");
}
return(new DynamicBuffer <T>((BufferHeader *)(this.m_BasePointer + (index * this.m_Stride)), this.m_Safety0, this.m_ArrayInvalidationSafety, this.m_IsReadOnly));
}
}
// Ensure we have at least this many extra vertices in capacity
public void ReserveAdditionalVertices(int extraIndices)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
var requiredVertCapacity = m_Vertices->Length + extraIndices;
var requiredVertices = m_Vertices->Length + (extraIndices * 2);
if (m_Vertices->Capacity < requiredVertCapacity)
{
m_Vertices->SetCapacity(requiredVertices);
}
var requiredIndexCapacity = m_ChainedIndices->Length + extraIndices;
var requiredIndices = m_ChainedIndices->Length + (extraIndices * 2);
if (m_ChainedIndices->Capacity < requiredIndexCapacity)
{
m_ChainedIndices->SetCapacity(requiredIndices);
}
}
public T this[Entity entity]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
m_Entities->AssertEntityHasComponent(entity, m_TypeIndex);
// if the component is zero-sized, we return a default-initialized T.
// this is to support users who transition to zero-sized T and back,
// or who write generics over T and don't wish to branch over zero-sizedness.
if (m_IsZeroSized)
{
return(default(T));
}
T data;
void *ptr = m_Entities->GetComponentDataWithTypeRO(entity, m_TypeIndex, ref m_TypeLookupCache);
UnsafeUtility.CopyPtrToStructure(ptr, out data);
return(data);
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
m_Entities->AssertEntityHasComponent(entity, m_TypeIndex);
// if the component is zero-sized, we make no attempt to set a value.
// this is to support users who transition to zero-sized T and back,
// or who write generics over T and don't wish to branch over zero-sizedness.
if (m_IsZeroSized)
{
return;
}
void *ptr = m_Entities->GetComponentDataWithTypeRW(entity, m_TypeIndex, m_GlobalSystemVersion, ref m_TypeLookupCache);
UnsafeUtility.CopyStructureToPtr(ref value, ptr);
}
}
