public static void Construct(EntityQueryCache *cache) { cache->typeLookup = HashMap <EntityQuery> .Empty(); cache->count = 0; cache->capacity = cache->typeLookup.capacity; cache->queries = MemoryUtility.Malloc <EntityQueryData>(cache->capacity); }
public static void Construct(ArchetypeStore *store) { store->typeLookup = HashMap <EntityArchetype> .Empty(); store->count = 0; store->capacity = store->typeLookup.capacity; store->archetypes = MemoryUtility.Malloc <Archetype>(store->capacity); }
private HashMap(int capacity) { this.count = 0; this.capacity = capacity; this.m_Hashes = MemoryUtility.Malloc <int>(this.capacity); this.m_Elements = MemoryUtility.Malloc <T>(this.capacity); MemoryUtility.MemSet(this.m_Hashes, 0, sizeof(int) * this.capacity); }
public static void Construct(EntityStore *store) { store->version = 1; store->capacity = DefaultCapacity; store->count = 0; store->entitiesInChunk = MemoryUtility.Malloc <EntityInChunk>(store->capacity); store->freeSlots = FreeEntitySlotList.Empty(); Unsafe.InitBlock(store->entitiesInChunk, 0, (uint)(sizeof(EntityInChunk) * store->capacity)); }
public static ArchetypeChunkArray *Allocate(Archetype *archetype) { ArchetypeChunkArray *array = MemoryUtility.Malloc <ArchetypeChunkArray>(); array->archetype = archetype; array->count = 0; array->capacity = 2; array->chunks = MemoryUtility.MallocPtrArray <Chunk>(array->capacity); return(array); }
private void Construct() { // Revisit with threading (cache invalidation). byte *ptr = MemoryUtility.Malloc <byte>( sizeof(ArchetypeStore) + sizeof(EntityStore) + sizeof(EntityQueryCache)); this.archetypeStore = (ArchetypeStore *)ptr; this.entityStore = (EntityStore *)(ptr += sizeof(ArchetypeStore)); this.queryCache = (EntityQueryCache *)(ptr += sizeof(EntityStore)); ArchetypeStore.Construct(this.archetypeStore); EntityStore.Construct(this.entityStore); EntityQueryCache.Construct(this.queryCache); }
public static void CalculateComponentOffsets(Archetype *archetype, int chunkCapacity) { var count = archetype->componentCount; var componentSizes = archetype->componentSizes; int *offsets = MemoryUtility.Malloc <int>(count); // This can be done in ConstructComponentData. offsets[0] = sizeof(Entity) * chunkCapacity; for (int i = 1; i < count; ++i) { offsets[i] = offsets[i - 1] + (chunkCapacity * componentSizes[i - 1]); } archetype->componentOffsets = offsets; }
public static void ConstructComponentData(Archetype *archetype, Span <int> componentTypes, Span <int> componentSizes, int hashCode) { archetype->entityCount = 0; archetype->componentCount = componentSizes.Length; // Temporary fix... see CreateArchetype() archetype->componentHashCode = hashCode; if (componentSizes.Length == 0) { return; } var size = componentSizes.Length * sizeof(int); archetype->componentTypes = (int *)MemoryUtility.Malloc(size); archetype->componentSizes = (int *)MemoryUtility.Malloc(size); fixed(int *srcTypes = componentTypes, srcSizes = componentSizes) { Buffer.MemoryCopy(srcTypes, archetype->componentTypes, size, size); Buffer.MemoryCopy(srcSizes, archetype->componentSizes, size, size); } }
internal EntityQuery CreateQueryInternal(Span <int> types, int includeTypesCount, int excludeTypesCount) { int hashCode = GetQueryTypeHash(types.Slice(0, includeTypesCount), types.Slice(includeTypesCount)); if (this.queryCache->typeLookup.TryGet(hashCode, out EntityQuery query)) { return(query); } this.queryCache->EnsureCapacity(); int index = this.queryCache->count++; // InitBlock the struct? EntityQueryData *queryData = this.queryCache->queries + index; queryData->matchedArchetypeCount = 0; queryData->archetypeCount = 0; queryData->includeTypesCount = includeTypesCount; queryData->excludeTypesCount = excludeTypesCount; queryData->componentTypes = null; queryData->archetypes = MemoryUtility.MallocPtrArray <Archetype>(0); // This is dumb but works, otherwise realloc throws. if (types.Length > 0) // Because Marshal.AllocHGlobal(0) does not return IntPtr.Zero. { queryData->componentTypes = MemoryUtility.Malloc <int>(types.Length); types.CopyTo(new Span <int>(queryData->componentTypes, types.Length)); } MatchArchetypesToQueryData(queryData); // Lazy? query = new EntityQuery(index); this.queryCache->typeLookup.Add(hashCode, query); return(query); }
public static Chunk *AllocateChunk() { Chunk *chunk = (Chunk *)MemoryUtility.Malloc(Chunk.ChunkSize); return(chunk); }
private FreeEntitySlotList(int capacity) { this.count = 0; this.capacity = capacity; this.slots = MemoryUtility.Malloc <int>(this.capacity); }