bucket cleanup

7 files changed, 53 insertions, 52 deletions

diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp
index b980154..e608dec 100644
--- a/src/asset-manager.cpp
+++ b/src/asset-manager.cpp
@@ -3,33 +3,32 @@
 
 TypeSafeInt_B(AssetHandle);
 
+const uint64_t maxAssetItemsPerBucket = 256;
+
 struct AssetBucket {
-	Asset assets[256];
+	Asset assets[maxAssetItemsPerBucket];
 };
 
-uint64_t assetBucketIncrementer = 2;
-AssetHandle_T assetBucketCounter{0};
-AssetHandle_T assetCounter{0};
-AssetBucket *assetBuckets = nullptr;
+BucketContainer<AssetBucket, AssetHandle_T> Asset_BucketContainer{};
 
 void AM_Init() {
-	assetBuckets = Pke_New<AssetBucket>(assetBucketIncrementer);
+	Buckets_Init(Asset_BucketContainer);
 }
 
 AssetHandle AM_Register_Inner(const void *src, void *dst, int64_t size, const char *key) {
-
-	AssetHandle_T assetHandle_T{Buckets_NewHandle<AssetBucket>(256ULL, assetBucketIncrementer, assetBucketCounter, assetCounter, assetBuckets)};
-	AssetHandle assetHandle{assetHandle_T};
+	AssetHandle_T assetHandle_T{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer)};
 
 	if (src != nullptr) {
 		std::memcpy(dst, src, size);
 	}
-	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
+	auto b = Buckets_GetBucketIndex(assetHandle_T);
+	auto e = Buckets_GetItemIndex(assetHandle_T);
+	Asset *asset = &Asset_BucketContainer.buckets[b].assets[e];
 	asset->ptr = dst;
 	asset->size = size;
 	int64_t keyLen = std::strlen(key);
 	std::memcpy(asset->key, key, keyLen > 16 ? 16 : keyLen);
-	return assetHandle;
+	return AssetHandle{assetHandle_T};
 }
 
 AssetHandle AM_Register(const void *data, int64_t size, const char *key) {
@@ -50,8 +49,9 @@ AssetHandle AM_Register(const char *path) {
 
 	int64_t pathLen = strlen(path);
 	auto assetHandle = AM_Register_Inner(nullptr, target, 0, path + (pathLen > 16 ? pathLen - 16 : 0));
-	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
-	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
+	auto b = Buckets_GetBucketIndex(static_cast<AssetHandle_T>(assetHandle));
+	auto e = Buckets_GetItemIndex(static_cast<AssetHandle_T>(assetHandle));
+	Asset *asset = &Asset_BucketContainer.buckets[b].assets[e];
 	file.seekg(0);
 	file.read(static_cast<char *>(asset->ptr), fileSize);
 	file.close();
@@ -61,21 +61,23 @@ AssetHandle AM_Register(const char *path) {
 
 void AM_Destroy(AssetHandle assetHandle) {
 	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
-	auto itemIndex = Buckets_GetItemIndex(assetHandle_T);
-	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[itemIndex];
+	auto b = Buckets_GetBucketIndex(assetHandle_T);
+	auto i = Buckets_GetItemIndex(assetHandle_T);
+	Asset *asset = &Asset_BucketContainer.buckets[b].assets[i];
 	Pke_Delete(asset->ptr, asset->size);
-	for (long i = 0; i < 16; ++i) {
-		asset->key[i] = 0;
-	}
+	memset(asset->key, '\0', 16);
 	asset->size = 0;
 	asset->ptr = CAFE_BABE(void);
-	if (itemIndex == assetCounter - (1ULL << 32)) {
-		assetCounter -= (1ULL << 32);
+	auto lastGivenIndex = Asset_BucketContainer.itemCounter - (1ULL << 32);
+	if (i == lastGivenIndex) {
+		Asset_BucketContainer.itemCounter = lastGivenIndex;
 	}
 }
 
 const Asset *AM_Get(AssetHandle assetHandle) {
 	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
-	return &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
+	auto b = Buckets_GetBucketIndex(assetHandle_T);
+	auto i = Buckets_GetItemIndex(assetHandle_T);
+	return &Asset_BucketContainer.buckets[b].assets[i];
 }
 
diff --git a/src/asset-manager.hpp b/src/asset-manager.hpp
index 73d19a1..85f866a 100644
--- a/src/asset-manager.hpp
+++ b/src/asset-manager.hpp
@@ -12,7 +12,7 @@
 TypeSafeInt_H(AssetHandle, uint64_t, UINT64_MAX);
 
 struct Asset{
-	char key[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+	char key[16] = {'\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'};
 	int64_t size = 0;
 	void *ptr = nullptr;
 };
diff --git a/src/components.hpp b/src/components.hpp
index 4c40927..f0a46a9 100644
--- a/src/components.hpp
+++ b/src/components.hpp
@@ -16,9 +16,7 @@ struct Entity {
 	GrBindsHandle grBindsHandle = GrBindsHandle{GrBindsHandle_T{ECS_UNSET_VAL}};
 };
 
-struct CompGrBinds {
-	EntityHandle entityHandle = EntityHandle{EntityHandle_T{ECS_UNSET_VAL}};
-	GrBindsHandle grBindsHandle = GrBindsHandle{GrBindsHandle_T{ECS_UNSET_VAL}};
+struct GrBindsComp {
 	VkBuffer vertexBuffer = VK_NULL_HANDLE;
 	uint32_t vertexFirstBinding = 0;
 	uint32_t vertexCount = 0;
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;
 }
diff --git a/src/ecs.hpp b/src/ecs.hpp
index a777a4a..c6cb42b 100644
--- a/src/ecs.hpp
+++ b/src/ecs.hpp
@@ -20,9 +20,9 @@ void ECS_Tick(double delta);
 EntityHandle ECS_CreateEntity(EntityHandle parentEntityHandle = EntityHandle{EntityHandle_T{0xFFFFFFFFFFFFFFFF}});
 void ECS_MarkForRemoval(EntityHandle entityHandle);
 
-CompGrBinds &ECS_CreateGrBinds(EntityHandle entHandle);
-CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle);
+GrBindsComp &ECS_CreateGrBinds(EntityHandle entHandle);
+GrBindsComp *ECS_GetGrBinds(EntityHandle entHandle);
 uint64_t ECS_GetGrBinds_BucketCount();
-CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount);
+GrBindsComp *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount);
 
 #endif /* PKE_ECS_HPP */
diff --git a/src/memory.hpp b/src/memory.hpp
index 8e733bf..9fbe1ff 100644
--- a/src/memory.hpp
+++ b/src/memory.hpp
@@ -15,7 +15,7 @@ struct MemBucket;
 
 template<typename T, typename CT>
 struct BucketContainer {
-	uint64_t incrementer;
+	uint64_t incrementer = 2;
 	CT bucketCounter{0};
 	CT itemCounter{0};
 	T *buckets = nullptr;
diff --git a/src/window.cpp b/src/window.cpp
index 8293c81..54ebbf1 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -1001,9 +1001,9 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 	const uint64_t bindBucketCount = ECS_GetGrBinds_BucketCount();
 	for (long b = 0; b < bindBucketCount; ++b) {
 		uint64_t itemCount;
-		CompGrBinds *items = ECS_GetGrBinds(b, itemCount);
+		GrBindsComp *items = ECS_GetGrBinds(b, itemCount);
 		for (long i = 0; i < itemCount; ++i) {
-			CompGrBinds *binder = &items[i];
+			GrBindsComp *binder = &items[i];
 			vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, binder->vkPipelineLayout, 0U, 1U, &binder->vkDescriptorSet, 0, {});
 			vkCmdBindVertexBuffers(commandBuffer, binder->indexFirstBinding, binder->vertexCount, &binder->vertexBuffer, &binder->vertexOffsets);
 			vkCmdBindIndexBuffer(commandBuffer, binder->indexBuffer, binder->vertexOffsets, VK_INDEX_TYPE_UINT16);