public EntityArchetype CreateArchetype(ReadOnlySpan <Type> types) { if (types.Length == 0) { return(CreateArchetype()); } // The allocation > 16 is not cool. Is it possible to avoid this? Span <int> componentData = types.Length > 16 ? new int[types.Length * 2] : stackalloc int[types.Length * 2]; Span <int> componentTypes = componentData.Slice(0, types.Length); Span <int> componentSizes = componentData.Slice(types.Length); int blockSize = 0; for (int i = 0; i < types.Length; ++i) { componentTypes[i] = TypeRegistry.ToTypeIndex(types[i]); componentSizes[i] = Marshal.SizeOf(types[i]); blockSize += componentSizes[i]; } SortUtility.Sort(componentTypes, componentSizes); return(CreateArchetypeInternal(componentTypes, componentSizes, blockSize)); }
public EntityQuery CreateQuery(Span <Type> includeTypes, Span <Type> excludeTypes) { var typeCount = includeTypes.Length + excludeTypes.Length; Span <int> types = typeCount > 16 ? new int[typeCount] : stackalloc int[typeCount]; for (int i = 0; i < includeTypes.Length; ++i) { types[i] = TypeRegistry.ToTypeIndex(includeTypes[i]); } for (int i = 0; i < excludeTypes.Length; ++i) { types[i + includeTypes.Length] = TypeRegistry.ToTypeIndex(excludeTypes[i]); } SortUtility.Sort(types.Slice(0, includeTypes.Length)); SortUtility.Sort(types.Slice(includeTypes.Length)); // TODO: Same as archetypes: Allow only distinct types. return(CreateQueryInternal(types, includeTypes.Length, excludeTypes.Length)); }
internal EntityArchetype AddTypeToArchetype <T>(Archetype *archetype) where T : unmanaged { // TODO: Needs a check if the archetypes contains typeof(T). var srcCount = archetype->componentCount; if (srcCount == 0) { return(CreateArchetype <T>()); } int destCount = srcCount + 1; Span <int> componentData = destCount > 16 ? new int[destCount * 2] : stackalloc int[destCount * 2]; var destTypes = componentData.Slice(0, destCount); var destSizes = componentData.Slice(destCount); var sourceTypes = new Span <int>(archetype->componentTypes, srcCount); var sourceSizes = new Span <int>(archetype->componentSizes, srcCount); sourceTypes.CopyTo(destTypes); sourceSizes.CopyTo(destSizes); destTypes[srcCount] = TypeRegistry <T> .typeIndex; destSizes[srcCount] = sizeof(T); // Sometimes the added type is a new type, therefore the typeIndex is // higher than the indices in the array. In this case skip the sorting. if (destTypes[srcCount] < destTypes[srcCount - 1]) { SortUtility.Sort(destTypes, destSizes); } int blockSize = 0; for (int i = 0; i < destSizes.Length; ++i) // TODO: Use CalculateBlockSize instead. { blockSize += destSizes[i]; } return(CreateArchetypeInternal(destTypes, destSizes, blockSize)); }