protected ComponentGroupArray <T> GetEntities <T>() where T : struct
{
for (var i = 0; i != m_CachedComponentGroupArrays.Length; i++)
{
if (m_CachedComponentGroupArrays[i].CachedType == typeof(T))
{
return(new ComponentGroupArray <T>(m_CachedComponentGroupArrays[i]));
}
}
var cache = new ComponentGroupArrayStaticCache(typeof(T), EntityManager, this);
ArrayUtilityAdd(ref m_CachedComponentGroupArrays, cache);
return(new ComponentGroupArray <T>(cache));
}
internal ComponentGroupArray(ComponentGroupArrayStaticCache cache)
{
m_Data = new ComponentGroupArrayData(cache);
}
public ComponentGroupArrayData(ComponentGroupArrayStaticCache staticCache)
{
var length = 0;
staticCache.ComponentGroup.GetComponentChunkIterator(out length, out m_ChunkIterator);
m_ChunkIterator.IndexInComponentGroup = 0;
m_Length = length;
m_MinIndex = 0;
m_MaxIndex = length - 1;
CacheBeginIndex = 0;
CacheEndIndex = 0;
m_ArchetypeManager = staticCache.ComponentGroup.GetArchetypeManager();
m_ComponentDataCount = staticCache.ComponentDataCount;
m_ComponentCount = staticCache.ComponentCount;
fixed(int *indexInComponentGroup = m_IndexInComponentGroup)
fixed(byte *cacheBytes = m_Caches)
fixed(bool *isWriting = m_IsWriting)
{
var streams = (ComponentGroupStream *)cacheBytes;
for (var i = 0; i < staticCache.ComponentDataCount + staticCache.ComponentCount; i++)
{
indexInComponentGroup[i] = staticCache.ComponentGroup.GetIndexInComponentGroup(staticCache.ComponentTypes[i].TypeIndex);
streams[i].FieldOffset = (ushort)staticCache.ComponentFieldOffsets[i];
isWriting[i] = staticCache.ComponentTypes[i].AccessModeType == ComponentType.AccessMode.ReadWrite;
}
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_Safety0 = new AtomicSafetyHandle();
m_Safety1 = new AtomicSafetyHandle();
m_Safety2 = new AtomicSafetyHandle();
m_Safety3 = new AtomicSafetyHandle();
m_Safety4 = new AtomicSafetyHandle();
m_Safety5 = new AtomicSafetyHandle();
Assert.AreEqual(6, kMaxStream);
m_SafetyReadWriteCount = 0;
m_SafetyReadOnlyCount = 0;
var safetyManager = staticCache.SafetyManager;
fixed(AtomicSafetyHandle *safety = &m_Safety0)
{
for (var i = 0; i != staticCache.ComponentTypes.Length; i++)
{
var type = staticCache.ComponentTypes[i];
if (type.AccessModeType != ComponentType.AccessMode.ReadOnly)
{
continue;
}
safety[m_SafetyReadOnlyCount] = safetyManager.GetSafetyHandle(type.TypeIndex, true);
m_SafetyReadOnlyCount++;
}
for (var i = 0; i != staticCache.ComponentTypes.Length; i++)
{
var type = staticCache.ComponentTypes[i];
if (type.AccessModeType != ComponentType.AccessMode.ReadWrite)
{
continue;
}
safety[m_SafetyReadOnlyCount + m_SafetyReadWriteCount] =
safetyManager.GetSafetyHandle(type.TypeIndex, false);
m_SafetyReadWriteCount++;
}
}
#endif
}
public unsafe ComponentGroupArrayData(ComponentGroupArrayStaticCache staticCache)
{
int outLength = 0;
staticCache.ComponentGroup.GetComponentChunkIterator(out outLength, out this.m_ChunkIterator);
this.m_ChunkIterator.IndexInComponentGroup = 0;
this.m_Length = outLength;
this.m_MinIndex = 0;
this.m_MaxIndex = outLength - 1;
this.CacheBeginIndex = 0;
this.CacheEndIndex = 0;
this.m_ArchetypeManager = staticCache.ComponentGroup.GetArchetypeManager();
this.m_ComponentDataCount = staticCache.ComponentDataCount;
this.m_ComponentCount = staticCache.ComponentCount;
int * numPtr = &this.m_IndexInComponentGroup.FixedElementField;
bool *flagPtr = &this.m_IsWriting.FixedElementField;
ComponentGroupStream *streamPtr = (ComponentGroupStream *)&this.m_Caches.FixedElementField;
int index = 0;
while (true)
{
if (index >= (staticCache.ComponentDataCount + staticCache.ComponentCount))
{
fixed(bool **flagPtrRef = null)
{
fixed(byte **numPtrRef2 = null)
{
fixed(int **numPtrRef = null)
{
this.m_Safety0 = new AtomicSafetyHandle();
this.m_Safety1 = new AtomicSafetyHandle();
this.m_Safety2 = new AtomicSafetyHandle();
this.m_Safety3 = new AtomicSafetyHandle();
this.m_Safety4 = new AtomicSafetyHandle();
this.m_Safety5 = new AtomicSafetyHandle();
Assert.AreEqual(6, 6);
this.m_SafetyReadWriteCount = 0;
this.m_SafetyReadOnlyCount = 0;
ComponentJobSafetyManager safetyManager = staticCache.SafetyManager;
AtomicSafetyHandle * handlePtr = &this.m_Safety0;
int num3 = 0;
while (true)
{
if (num3 == staticCache.ComponentTypes.Length)
{
int num4 = 0;
while (true)
{
if (num4 == staticCache.ComponentTypes.Length)
{
fixed(AtomicSafetyHandle *handleRef = null)
{
return;
}
}
ComponentType type2 = staticCache.ComponentTypes[num4];
if (type2.AccessModeType == ComponentType.AccessMode.ReadWrite)
{
handlePtr[this.m_SafetyReadOnlyCount + this.m_SafetyReadWriteCount] = safetyManager.GetSafetyHandle(type2.TypeIndex, false);
this.m_SafetyReadWriteCount++;
}
num4++;
}
}
ComponentType type = staticCache.ComponentTypes[num3];
if (type.AccessModeType == ComponentType.AccessMode.ReadOnly)
{
handlePtr[this.m_SafetyReadOnlyCount] = safetyManager.GetSafetyHandle(type.TypeIndex, true);
this.m_SafetyReadOnlyCount++;
}
num3++;
}
}
}
}
}
numPtr[index] = staticCache.ComponentGroup.GetIndexInComponentGroup(staticCache.ComponentTypes[index].TypeIndex);
streamPtr[index].FieldOffset = (ushort)staticCache.ComponentFieldOffsets[index];
*((sbyte *)(flagPtr + index)) = staticCache.ComponentTypes[index].AccessModeType == ComponentType.AccessMode.ReadWrite;
index++;
}
}
