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++; } }