refactor and simplify bucketed-array

1 files changed, 42 insertions, 54 deletions

diff --git a/src/ecs.cpp b/src/ecs.cpp
index 34eb701..1e62988 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -1,6 +1,7 @@
 
 #include "ecs.hpp"
 
+#include "bucketed-array.hpp"
 #include "game-settings.hpp"
 #include "math-helpers.hpp"
 #include "memory.hpp"
@@ -12,17 +13,7 @@
 #include <BulletCollision/CollisionShapes/btConvexHullShape.h>
 #include <glm/gtc/type_ptr.hpp>
 
-const PkeHandleItemIndex_T maxBucketItemCount = 256;
-
-struct EntityBucket {
-	Entity entities[maxBucketItemCount];
-};
-struct GrBindsBucket {
-	CompGrBinds compGrBinds[maxBucketItemCount];
-};
-struct InstanceBucket {
-	CompInstance instances[maxBucketItemCount];
-};
+constexpr PkeHandleItemIndex_T maxBucketItemCount = 256;
 
 /*
  * Entities that have been marked for removal by calling ECS_MarkForRemoval
@@ -47,19 +38,19 @@ DynArray<Entity> entitiesYetToBeRemoved{0, nullptr};
 
 DynArray<EntityHandle> EntitiesWithExcessInstances{16};
 
-BucketContainer<EntityBucket, EntityHandle> Entities_BucketContainer{};
-BucketContainer<GrBindsBucket, GrBindsHandle> Comp_GrBinds_BucketContainer{};
-BucketContainer<InstanceBucket, InstanceHandle> Comp_Instance_BucketContainer{};
+BucketContainer<Entity, EntityHandle> Entities_BucketContainer{};
+BucketContainer<CompGrBinds, GrBindsHandle> Comp_GrBinds_BucketContainer{};
+BucketContainer<CompInstance, InstanceHandle> Comp_Instance_BucketContainer{};
 
 void ECS_GetEntity_Inner(EntityHandle entHandle, Entity*& ent) {
 	assert(entHandle != EntityHandle_MAX && "Unknown entity handle");
-	ent = &Entities_BucketContainer.buckets[entHandle.bucketIndex].entities[entHandle.itemIndex];
+	ent = &Entities_BucketContainer.buckets[entHandle.bucketIndex][entHandle.itemIndex];
 }
 
 void ECS_Init() {
-	Buckets_Init(Entities_BucketContainer);
-	Buckets_Init(Comp_GrBinds_BucketContainer);
-	Buckets_Init(Comp_Instance_BucketContainer);
+	Buckets_Init(Entities_BucketContainer, maxBucketItemCount);
+	Buckets_Init(Comp_GrBinds_BucketContainer, maxBucketItemCount);
+	Buckets_Init(Comp_Instance_BucketContainer, maxBucketItemCount);
 }
 
 uint64_t ECS_GetEntities_BucketCount() {
@@ -68,14 +59,13 @@ uint64_t ECS_GetEntities_BucketCount() {
 Entity *ECS_GetEntities(uint64_t bucketIndex, uint64_t &itemCount) {
 	assert(bucketIndex <= Entities_BucketContainer.pkeHandle.bucketIndex);
 	itemCount = bucketIndex == Entities_BucketContainer.pkeHandle.bucketIndex ? Entities_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
-	return Entities_BucketContainer.buckets[bucketIndex].entities;
+	return Entities_BucketContainer.buckets[bucketIndex];
 }
 
 EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntHandle) {
-	bool moved;
-	EntityHandle entityHandle{Buckets_NewHandle<EntityBucket>(maxBucketItemCount, Entities_BucketContainer, moved)};
+	EntityHandle entityHandle{Buckets_NewHandle<Entity>(Entities_BucketContainer)};
 
-	Entity *entity = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
+	Entity *entity = &Entities_BucketContainer.buckets[entityHandle.bucketIndex][entityHandle.itemIndex];
 	entity = new (entity) Entity{};
 	entity->handle = entityHandle;
 	entity->parentHandle = parentEntHandle;
@@ -88,7 +78,7 @@ EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle) {
 }
 
 void ECS_MarkForRemoval(EntityHandle entityHandle) {
-	const Entity *ent = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
+	const Entity *ent = &Entities_BucketContainer.buckets[entityHandle.bucketIndex][entityHandle.itemIndex];
 	assert(ent->isMarkedForRemoval == false && "Entity already marked for removal");
 	entitiesMarkedForRemoval.Push(entityHandle);
 }
@@ -102,7 +92,7 @@ void ECS_Tick_Early(double delta) {
 	for (long b = 0; b <= Entities_BucketContainer.pkeHandle.bucketIndex; ++b) {
 		uint64_t entCount = b == Entities_BucketContainer.pkeHandle.bucketIndex ? Entities_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
 		for (long e  = 0; e < entCount; ++e) {
-			Entity *ent = &Entities_BucketContainer.buckets[b].entities[e];
+			Entity *ent = &Entities_BucketContainer.buckets[b][e];
 			if (ent->handle == EntityHandle_MAX) continue;
 			if (ent->isMarkedForRemoval) {
 				entitiesYetToBeRemoved.Push(*ent);
@@ -120,19 +110,19 @@ void ECS_Tick_Early(double delta) {
 	for (long e = 0; e < entitiesYetToBeRemoved.Count(); ++e) {
 		Entity &clonedEnt = entitiesYetToBeRemoved[e];
 		CompGrBinds *grBinds = nullptr;
-		InstanceBucket *instBucket = nullptr;
+		CompInstance *instBucket = nullptr;
 		CompInstance *inst = nullptr;
 		uint64_t instBucketIndex = 0;
 		if (clonedEnt.instanceHandle != InstanceHandle_MAX) {
 			instBucketIndex = clonedEnt.instanceHandle.bucketIndex;
-			instBucket = &Comp_Instance_BucketContainer.buckets[instBucketIndex];
-			inst = &instBucket->instances[clonedEnt.instanceHandle.itemIndex];
+			instBucket = Comp_Instance_BucketContainer.buckets[instBucketIndex];
+			inst = &instBucket[clonedEnt.instanceHandle.itemIndex];
 			if (inst->grBindsHandle != GrBindsHandle_MAX) {
-				grBinds = &Comp_GrBinds_BucketContainer.buckets[inst->grBindsHandle.bucketIndex].compGrBinds[inst->grBindsHandle.itemIndex];
+				grBinds = &Comp_GrBinds_BucketContainer.buckets[inst->grBindsHandle.bucketIndex][inst->grBindsHandle.itemIndex];
 			}
 		}
 		if (grBinds == nullptr && clonedEnt.grBindsHandle != GrBindsHandle_MAX) {
-			grBinds = &Comp_GrBinds_BucketContainer.buckets[clonedEnt.grBindsHandle.bucketIndex].compGrBinds[clonedEnt.grBindsHandle.itemIndex];
+			grBinds = &Comp_GrBinds_BucketContainer.buckets[clonedEnt.grBindsHandle.bucketIndex][clonedEnt.grBindsHandle.itemIndex];
 		}
 		if (inst != nullptr) {
 			assert(grBinds != nullptr);
@@ -145,17 +135,17 @@ void ECS_Tick_Early(double delta) {
 				}
 				auto &bucket = Comp_Instance_BucketContainer.buckets[bi];
 				for (long ii = 0; ii < instCounter; ++ii) {
-					if (bucket.instances[ii].entHandle == EntityHandle_MAX) {
+					if (bucket[ii].entHandle == EntityHandle_MAX) {
 						continue;
 					}
-					if (bucket.instances[ii].grBindsHandle != inst->grBindsHandle) {
+					if (bucket[ii].grBindsHandle != inst->grBindsHandle) {
 						continue;
 					}
-					if (bucket.instances[ii].instanceHandle.itemIndex < clonedEnt.instanceHandle.itemIndex) {
+					if (bucket[ii].instanceHandle.itemIndex < clonedEnt.instanceHandle.itemIndex) {
 						continue;
 					}
-					bucket.instances[ii].index -= 1;
-					bucket.instances[ii].isNeedingUpdated = true;
+					bucket[ii].index -= 1;
+					bucket[ii].isNeedingUpdated = true;
 				}
 			}
 			grBinds->instanceCounter -= 1;
@@ -192,7 +182,7 @@ void ECS_Tick(double delta) {
 			auto &bkt = Comp_Instance_BucketContainer.buckets[b];
 			long count = Comp_Instance_BucketContainer.pkeHandle.bucketIndex == b ? Comp_Instance_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
 			for (uint32_t i = 0; i < count; ++i) {
-				auto &inst = bkt.instances[i];
+				auto &inst = bkt[i];
 				if (inst.entHandle == EntityHandle_MAX)
 					continue;
 				auto activationState = inst.bt.rigidBody->getActivationState();
@@ -225,13 +215,13 @@ void ECS_Tick_Late(double delta) {
 		auto &bkt = Comp_Instance_BucketContainer.buckets[b];
 		long count = Comp_Instance_BucketContainer.pkeHandle.bucketIndex == b ? Comp_Instance_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
 		for (uint32_t i = 0; i < count; ++i) {
-			auto &inst = bkt.instances[i];
+			auto &inst = bkt[i];
 			if (inst.isNeedingUpdated == false)
 				continue;
 			if (inst.entHandle == EntityHandle_MAX)
 				continue;
 
-			auto &grBinds = Comp_GrBinds_BucketContainer.buckets[inst.grBindsHandle.bucketIndex].compGrBinds[inst.grBindsHandle.itemIndex];
+			auto &grBinds = Comp_GrBinds_BucketContainer.buckets[inst.grBindsHandle.bucketIndex][inst.grBindsHandle.itemIndex];
 
 			InstanceBufferCopy *bfrUpdate = nullptr;
 			for (long u = 0; u < bufferUpdates.Count(); ++u) {
@@ -340,12 +330,12 @@ void FindComponents(EntityHandle handle, Entity *&ent, CompInstance *&compInst,
 		return;
 	GrBindsHandle grBindsHandle = ent->grBindsHandle;
 	if (ent->instanceHandle != InstanceHandle_MAX) {
-		compInst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
+		compInst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex][ent->instanceHandle.itemIndex];
 		if (grBindsHandle == GrBindsHandle_MAX)
 			grBindsHandle = compInst->grBindsHandle;
 	}
 	if (grBindsHandle != GrBindsHandle_MAX) {
-		grBinds = &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex].compGrBinds[grBindsHandle.itemIndex];
+		grBinds = &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex][grBindsHandle.itemIndex];
 	}
 }
 
@@ -393,9 +383,8 @@ CompGrBinds &ECS_CreateGrBinds(EntityHandle entHandle) {
 
 	assert(ent->grBindsHandle == GrBindsHandle_MAX);
 
-	bool moved;
-	ent->grBindsHandle = Buckets_NewHandle(maxBucketItemCount, Comp_GrBinds_BucketContainer, moved);
-	auto *comp = &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
+	ent->grBindsHandle = Buckets_NewHandle(Comp_GrBinds_BucketContainer);
+	auto *comp = &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex][ent->grBindsHandle.itemIndex];
 	comp = new (comp) CompGrBinds{};
 	comp->entHandle = entHandle;
 	comp->grBindsHandle = ent->grBindsHandle;
@@ -406,11 +395,11 @@ CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle) {
 	Entity *ent = nullptr;
 	ECS_GetEntity_Inner(entHandle, ent);
 	if (ent->grBindsHandle == GrBindsHandle_MAX) return nullptr;
-	return &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
+	return &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex][ent->grBindsHandle.itemIndex];
 }
 CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
 	if (grBindsHandle == GrBindsHandle_MAX) return nullptr;
-	return &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex].compGrBinds[grBindsHandle.itemIndex];
+	return &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex][grBindsHandle.itemIndex];
 }
 
 uint64_t ECS_GetGrBinds_BucketCount() {
@@ -423,7 +412,7 @@ CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
 	} else {
 		itemCount = maxBucketItemCount;
 	}
-	return Comp_GrBinds_BucketContainer.buckets[bucketIndex].compGrBinds;
+	return Comp_GrBinds_BucketContainer.buckets[bucketIndex];
 }
 
 CompInstance &ECS_CreateInstance(EntityHandle entHandle, EntityHandle entityTypeEntityHandle) {
@@ -438,15 +427,14 @@ CompInstance &ECS_CreateInstance(EntityHandle entHandle, EntityHandle entityType
 	assert(ent->grBindsHandle == GrBindsHandle_MAX);
 	assert(entTypeEnt->grBindsHandle != GrBindsHandle_MAX);
 
-	bool moved;
-	ent->instanceHandle = Buckets_NewHandle(maxBucketItemCount, Comp_Instance_BucketContainer, moved);
+	ent->instanceHandle = Buckets_NewHandle(Comp_Instance_BucketContainer);
 
-	auto *instBkt = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex];
-	auto *comp = &instBkt->instances[ent->instanceHandle.itemIndex];
-	comp = new (comp) CompInstance{};
+	auto *instBkt = Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex];
+	auto *comp = &instBkt[ent->instanceHandle.itemIndex];
+	new (comp) CompInstance{};
 	comp->entHandle = entHandle;
 
-	auto *grBinds = &Comp_GrBinds_BucketContainer.buckets[entTypeEnt->grBindsHandle.bucketIndex].compGrBinds[entTypeEnt->grBindsHandle.itemIndex];
+	auto *grBinds = &Comp_GrBinds_BucketContainer.buckets[entTypeEnt->grBindsHandle.bucketIndex][entTypeEnt->grBindsHandle.itemIndex];
 
 	comp->grBindsHandle = grBinds->grBindsHandle;
 	comp->instanceHandle = ent->instanceHandle;
@@ -467,7 +455,7 @@ CompInstance *ECS_GetInstance(EntityHandle entHandle) {
 	if (ent->instanceHandle == InstanceHandle_MAX)
 		return nullptr;
 
-	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
+	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex][ent->instanceHandle.itemIndex];
 
 	return inst;
 }
@@ -479,7 +467,7 @@ void ECS_UpdateInstance(EntityHandle entHandle, const InstPos &instPos, bool ove
 	if (ent->instanceHandle == InstanceHandle_MAX)
 		return;
 
-	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
+	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex][ent->instanceHandle.itemIndex];
 
 	if (BtDynamicsWorld && overridePhysics) {
 		btVector3 localInertia(0, 0, 0);
@@ -505,7 +493,7 @@ CompInstance *ECS_GetInstances(uint64_t bucketIndex, uint64_t &itemCount) {
 	} else {
 		itemCount = maxBucketItemCount;
 	}
-	return Comp_Instance_BucketContainer.buckets[bucketIndex].instances;
+	return Comp_Instance_BucketContainer.buckets[bucketIndex];
 }
 
 void ECS_Teardown() {