bucket cleanup

1 files changed, 22 insertions, 21 deletions

diff --git a/src/ecs.cpp b/src/ecs.cpp
index 33fec2b..d91cd1a 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -2,40 +2,40 @@
 #include "ecs.hpp"
 
 TypeSafeInt_B(EntityHandle);
-const uint64_t bucketItemCount = 256;
+const uint64_t maxBucketItemCount = 256;
 
 struct EntityBucket{
-	Entity entities[bucketItemCount];
+	Entity entities[maxBucketItemCount];
 };
 struct GrBindsBucket{
-	CompGrBinds compGrBinds[bucketItemCount];
+	GrBindsComp compGrBinds[maxBucketItemCount];
 };
 
-uint64_t entityBucketIncrementer = 2;
-EntityHandle_T entityBucketCounter{0};
-EntityHandle_T entityCounter{0};
-EntityBucket *entityBuckets = nullptr;
 DynArray<EntityHandle> entitiesMarkedForRemoval{16};
 DynArray<EntityHandle> EntitiesToBeRemoved{16};
-
+BucketContainer<EntityBucket, EntityHandle_T> Entities_BucketContainer{};
 BucketContainer<GrBindsBucket, GrBindsHandle_T> Comp_GrBinds_BucketContainer{};
 
 void ECS_GetEntity_Inner(EntityHandle entHandle, Entity*& ent) {
 	EntityHandle_T entHandle_t{static_cast<EntityHandle_T>(entHandle)};
 	assert(entHandle_t == ECS_UNSET_VAL && "Unknown entity handle");
-	ent = &entityBuckets[Buckets_GetBucketIndex(entHandle_t)].entities[Buckets_GetItemIndex(entHandle_t)];
+	auto b = Buckets_GetBucketIndex(static_cast<EntityHandle_T>(entHandle));
+	auto e = Buckets_GetItemIndex(static_cast<EntityHandle_T>(entHandle));
+	ent = &Entities_BucketContainer.buckets[b].entities[e];
 }
 
 void ECS_Init() {
-	entityBuckets = Pke_New<EntityBucket>(entityBucketIncrementer);
+	Buckets_Init(Entities_BucketContainer);
 	Buckets_Init(Comp_GrBinds_BucketContainer);
 }
 
 EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntityHandle) {
-	EntityHandle_T entityHandle_T{Buckets_NewHandle<EntityBucket>(bucketItemCount, entityBucketIncrementer, entityBucketCounter, entityCounter, entityBuckets)};
+	EntityHandle_T entityHandle_T{Buckets_NewHandle<EntityBucket>(maxBucketItemCount, Entities_BucketContainer)};
 	EntityHandle entityHandle{entityHandle_T};
 
-	Entity *entity = &entityBuckets[Buckets_GetBucketIndex(entityHandle_T)].entities[Buckets_GetItemIndex(entityHandle_T)];
+	auto b = Buckets_GetBucketIndex(static_cast<EntityHandle_T>(entityHandle));
+	auto e = Buckets_GetItemIndex(static_cast<EntityHandle_T>(entityHandle));
+	Entity *entity = &Entities_BucketContainer.buckets[b].entities[e];
 
 	entity->handle = entityHandle;
 	entity->parentHandle = parentEntityHandle;
@@ -50,22 +50,23 @@ EntityHandle ECS_CreateEntity(EntityHandle parentEntityHandle) {
 void ECS_MarkForRemoval(EntityHandle entityHandle) {
 	auto b = Buckets_GetBucketIndex(static_cast<EntityHandle_T>(entityHandle));
 	auto e = Buckets_GetItemIndex(static_cast<EntityHandle_T>(entityHandle));
-	const Entity *ent = &entityBuckets[b].entities[e];
+	const Entity *ent = &Entities_BucketContainer.buckets[b].entities[e];
 	assert(ent->isMarkedForRemoval == false && "Entity already marked for removal");
 	entitiesMarkedForRemoval.Push(entityHandle);
 }
 
 void ECS_Tick(double delta) {
 	EntitiesToBeRemoved.Resize(0);
-	for (long b = 0; b <= entityBucketCounter; ++b) {
-		uint64_t entCount = b == entityBucketCounter ? entityCounter >> 32 : bucketItemCount;
+	for (long b = 0; b <= Entities_BucketContainer.bucketCounter; ++b) {
+		uint64_t entCount = b == Entities_BucketContainer.bucketCounter ? Entities_BucketContainer.itemCounter >> 32 : maxBucketItemCount;
 		for (long e  = 0; e < entCount; ++e) {
-			Entity *ent = &entityBuckets[b].entities[e];
+			Entity *ent = &Entities_BucketContainer.buckets[b].entities[e];
 			if (ent->handle == EntityHandle{EntityHandle_T{0xFFFFFFFFFFFFFFFF}}) continue;
 			if (ent->isMarkedForRemoval) {
 				ent->handle = EntityHandle{EntityHandle_T{0xFFFFFFFFFFFFFFFF}};
 				ent->parentHandle = EntityHandle{EntityHandle_T{0xFFFFFFFFFFFFFFFF}};
 				ent->isMarkedForRemoval = false;
+				// TODO destroy components
 			} else {
 				if (entitiesMarkedForRemoval.Has(ent->handle)) {
 					ent->isMarkedForRemoval = true;
@@ -82,15 +83,15 @@ void ECS_Tick(double delta) {
 	entitiesMarkedForRemoval.Resize(0);
 }
 
-CompGrBinds &ECS_CreateGrBinds(EntityHandle handle) {
+GrBindsComp &ECS_CreateGrBinds(EntityHandle handle) {
 	Entity *ent = nullptr;
 	ECS_GetEntity_Inner(handle, ent);
-	GrBindsHandle_T newHandle{Buckets_NewHandle(bucketItemCount, Comp_GrBinds_BucketContainer)};
+	GrBindsHandle_T newHandle{Buckets_NewHandle(maxBucketItemCount, Comp_GrBinds_BucketContainer)};
 	ent->grBindsHandle = GrBindsHandle{newHandle};
 	return Comp_GrBinds_BucketContainer.buckets[Buckets_GetBucketIndex(newHandle)].compGrBinds[Buckets_GetItemIndex(newHandle)];
 }
 
-CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle) {
+GrBindsComp *ECS_GetGrBinds(EntityHandle entHandle) {
 	Entity *ent = nullptr;
 	ECS_GetEntity_Inner(entHandle, ent);
 	GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(ent->grBindsHandle)};
@@ -102,11 +103,11 @@ uint64_t ECS_GetGrBinds_BucketCount() {
 	return Comp_GrBinds_BucketContainer.bucketCounter;
 }
 
-CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
+GrBindsComp *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
 	if (bucketIndex == Comp_GrBinds_BucketContainer.bucketCounter) {
 		itemCount = Comp_GrBinds_BucketContainer.itemCounter;
 	} else {
-		itemCount = bucketItemCount;
+		itemCount = maxBucketItemCount;
 	}
 	return Comp_GrBinds_BucketContainer.buckets[bucketIndex].compGrBinds;
 }