checkpoint - handle breaking ECS changes - compiles

1 files changed, 174 insertions, 112 deletions

diff --git a/src/entities.cpp b/src/entities.cpp
index 91c94d8..bd24830 100644
--- a/src/entities.cpp
+++ b/src/entities.cpp
@@ -1,7 +1,10 @@
 
 #include "entities.hpp"
 
+#include "bucketed-array.hpp"
 #include "ecs.hpp"
+#include "game-settings.hpp"
+#include "level.hpp"
 #include "math-helpers.hpp"
 #include "memory.hpp"
 #include "physics.hpp"
@@ -14,7 +17,8 @@
 #include <type_traits>
 #include <vulkan/vulkan_core.h>
 
-DynArray<EntityType> GlobalEntityTypes{16};
+BucketContainer<EntityType> EntityType_BC{};
+
 struct EntToTeardown {
 	EntityHandle handle = EntityHandle_MAX;
 	CompGrBinds *grBinds[1] = {nullptr};
@@ -23,37 +27,85 @@ struct EntToTeardown {
 DynArray<EntToTeardown> EntityTypesToTeardown{16};
 
 void EntityType_Init() {
-	long entityTypeCount = GlobalEntityTypes.Count();
-	for (long i = 0; i < entityTypeCount; ++i) {
-		EntityType_Load(GlobalEntityTypes[i]);
-	}
+	Buckets_Init(EntityType_BC);
 }
 
-int64_t EntityType_FindByTypeCode(const char *typeCode) {
-	for (int64_t i = 0; i < GlobalEntityTypes.Count(); ++i) {
-		if (strcmp(typeCode, GlobalEntityTypes[i].entityTypeCode) == 0) {
-			return i;
+EntityType *EntityType_Create() {
+	EntityTypeHandle entTypeHandle{Buckets_NewHandle(EntityType_BC)};
+	EntityType &entityType = EntityType_BC.buckets[entTypeHandle.bucketIndex][entTypeHandle.itemIndex];
+	new (&entityType) EntityType{};
+	ECS_CreateEntity(&entityType);
+	return &entityType;
+}
+
+Entity_Base *EntityType_CreateGenericInstance(EntityType *et, CompInstance *srcInstance) {
+	assert(et != nullptr);
+	Entity_Base *genericEntity = ECS_CreateGenericEntity();
+	auto *level = PkeLevel_Get(pkeSettings.rt.activeLevel);
+	ECS_CreateEntity(genericEntity, level);
+
+	for (size_t i = 0; i < et->detailsCount; ++i) {
+		auto &etd = et->details[i];
+		auto *compInst = ECS_CreateInstance(genericEntity, etd.grBinds);
+
+		if (srcInstance != nullptr) {
+			if (srcInstance->collisionCallback.name[0] != '\0') {
+				strncpy(compInst->collisionCallback.name, srcInstance->collisionCallback.name, CallbackSignatureLength);
+				PkePlugin_SetSignatureFunc(&compInst->collisionCallback);
+			}
+			compInst->physicsLayer = srcInstance->physicsLayer;
+			compInst->physicsMask = srcInstance->physicsMask;
+		} else {
+			compInst->physicsLayer = etd.bt.startingCollisionLayer;
+			compInst->physicsMask = etd.bt.startingCollisionMask;
 		}
+		btVector3 localInertia(0, 0, 0);
+		etd.bt.shape->calculateLocalInertia(etd.bt.startingMass, localInertia);
+		btTransform posRot{};
+		posRot.setIdentity();
+		compInst->bt.motionState = Pke_New<btDefaultMotionState>(MemBkt_Bullet);
+		new (compInst->bt.motionState) btDefaultMotionState(posRot);
+		compInst->bt.rigidBody = Pke_New<btRigidBody>(MemBkt_Bullet);
+		new (compInst->bt.rigidBody) btRigidBody(etd.bt.startingMass, compInst->bt.motionState, etd.bt.shape, localInertia);
+		compInst->bt.rigidBody->setLinearVelocity(btVector3(0,0,0));
+		compInst->bt.rigidBody->setAngularVelocity(btVector3(0,0,0));
+		compInst->bt.rigidBody->getCollisionShape()->setLocalScaling(btVector3(1, 1, 1));
+		BtDynamicsWorld->addRigidBody(compInst->bt.rigidBody);
+		compInst->bt.rigidBody->getBroadphaseProxy()->m_collisionFilterGroup = static_cast<PhysicsCollision_T>(compInst->physicsLayer);
+		compInst->bt.rigidBody->getBroadphaseProxy()->m_collisionFilterMask = static_cast<PhysicsCollision_T>(compInst->physicsMask);
+		compInst->bt.rigidBody->setUserPointer(reinterpret_cast<void *>(compInst->entHandle.hash));
 	}
-	return -1;
+	return genericEntity;
 }
 
-int64_t EntityType_FindByEntity(Entity_Base *entity, int64_t &detailIndex) {
-	assert(entity != nullptr);
-	for (int64_t i = 0; i < GlobalEntityTypes.Count(); ++i) {
-		for (int64_t k = 0; k < GlobalEntityTypes[i].detailsCount; ++k) {
-			if (GlobalEntityTypes[i].details[k].entityHandle == entity->handle) {
-				detailIndex = k;
-				return i;
+EntityType *EntityType_FindByTypeCode(const char *typeCode) {
+	for (PkeHandleBucketIndex_T b = 0; b <= EntityType_BC.pkeHandle.bucketIndex; ++b) {
+		auto &bkt = EntityType_BC.buckets[b];
+		long itemCount = EntityType_BC.pkeHandle.bucketIndex == b ? EntityType_BC.pkeHandle.itemIndex : EntityType_BC.limits.itemIndex;
+		for (PkeHandleItemIndex_T i = 0; i < itemCount; ++i) {
+			auto &entityType = bkt[i];
+			if (entityType.handle == EntityHandle_MAX) continue;
+			if (strcmp(typeCode, entityType.entityTypeCode) == 0) {
+				return &entityType;
 			}
 		}
-		if (GlobalEntityTypes[i].entityHandle == entity->handle) {
-			detailIndex = -1;
-			return i;
+	}
+	return nullptr;
+}
+
+EntityType *EntityType_FindByEntityHandle(EntityHandle handle) {
+	if (handle == EntityHandle_MAX) return nullptr;
+	for (PkeHandleBucketIndex_T b = 0; b <= EntityType_BC.pkeHandle.bucketIndex; ++b) {
+		auto &bkt = EntityType_BC.buckets[b];
+		long itemCount = EntityType_BC.pkeHandle.bucketIndex == b ? EntityType_BC.pkeHandle.itemIndex : EntityType_BC.limits.itemIndex;
+		for (PkeHandleItemIndex_T i = 0; i < itemCount; ++i) {
+			auto &entityType = bkt[i];
+			if (entityType.handle == handle) {
+				return &entityType;
+			}
 		}
 	}
-	detailIndex = -1;
-	return -1;
+	return nullptr;
 }
 
 void CalculateCombinedMemReqs(uint64_t memReqsCount, VkMemoryRequirements *memReqs, VkMemoryRequirements &combinedMemReqs) {
@@ -94,7 +146,6 @@ struct EntityTypeDetails_LoadHelperStruct {
 	EntityTypeDetails *etd = nullptr;
 	AssetHandle textureAssetHandle = AssetHandle_MAX;
 	const Asset *textureAsset = nullptr;
-	CompGrBinds *grBinds = nullptr;
 	struct {
 		DynArray<glm::vec3> *vertexes = nullptr;
 		DynArray<glm::vec3> *normals = nullptr;
@@ -155,10 +206,7 @@ void EntityType_PreLoad(EntityType_LoadHelperStruct &helper) {
 		EntityTypeDetails &etd = helper.et.details[i];
 		EntityTypeDetails_LoadHelperStruct &etdHelper = helper.etdHelpers->Push();
 		etdHelper.etd = &etd;
-		etd.entityHandle = ECS_CreateEntity(helper.et.entityHandle);
-		auto &grBinds = ECS_CreateGrBinds(etd.entityHandle);
-		etdHelper.grBinds = &grBinds;
-		etd.grBindsHandle = grBinds.grBindsHandle;
+		etd.grBinds = ECS_CreateGrBinds(&helper.et);;
 		etdHelper.physDbg.vertexes = reinterpret_cast<DynArray<glm::vec3> *>(Pke_New(sizeof(DynArray<glm::vec3>), 64, helper.bkt));
 		etdHelper.physDbg.normals = reinterpret_cast<DynArray<glm::vec3> *>(Pke_New(sizeof(DynArray<glm::vec3>), 64, helper.bkt));
 		etdHelper.physDbg.uv = reinterpret_cast<DynArray<glm::vec2> *>(Pke_New(sizeof(DynArray<glm::vec2>), 64, helper.bkt));
@@ -580,11 +628,11 @@ void EntityType_LoadTexture(EntityType_LoadHelperStruct &helper, const int64_t i
 	vkDescriptorSetAllocateInfo.descriptorSetCount = MAX_FRAMES_IN_FLIGHT;
 	vkDescriptorSetAllocateInfo.pSetLayouts = descriptorSets;
 
-	etdHelper.grBinds->vkDescriptorSets = Pke_New<VkDescriptorSet>(MAX_FRAMES_IN_FLIGHT);
+	etdHelper.etd->grBinds->vkDescriptorSets = Pke_New<VkDescriptorSet>(MAX_FRAMES_IN_FLIGHT);
 	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
-		etdHelper.grBinds->vkDescriptorSets[i] = VkDescriptorSet{};
+		etdHelper.etd->grBinds->vkDescriptorSets[i] = VkDescriptorSet{};
 	}
-	vkResult = vkAllocateDescriptorSets(vkDevice, &vkDescriptorSetAllocateInfo, etdHelper.grBinds->vkDescriptorSets);
+	vkResult = vkAllocateDescriptorSets(vkDevice, &vkDescriptorSetAllocateInfo, etdHelper.etd->grBinds->vkDescriptorSets);
 	assert(vkResult == VK_SUCCESS);
 
 	VkWriteDescriptorSet writeDescriptorSets[2 * MAX_FRAMES_IN_FLIGHT];
@@ -618,10 +666,10 @@ void EntityType_LoadTexture(EntityType_LoadHelperStruct &helper, const int64_t i
 		long samplerIndex = uboIndex + 1;
 
 		writeDescriptorSets[uboIndex].pBufferInfo = &vkDescriptorBufferInfo[i];
-		writeDescriptorSets[uboIndex].dstSet = etdHelper.grBinds->vkDescriptorSets[i];
+		writeDescriptorSets[uboIndex].dstSet = etdHelper.etd->grBinds->vkDescriptorSets[i];
 
 		writeDescriptorSets[samplerIndex].pImageInfo = &textureDescriptorInfo;
-		writeDescriptorSets[samplerIndex].dstSet = etdHelper.grBinds->vkDescriptorSets[i];
+		writeDescriptorSets[samplerIndex].dstSet = etdHelper.etd->grBinds->vkDescriptorSets[i];
 	}
 
 	vkUpdateDescriptorSets(vkDevice, 2 * MAX_FRAMES_IN_FLIGHT, writeDescriptorSets, 0, nullptr);
@@ -656,15 +704,15 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 	const auto &accVert = helper.gltfData->accessors[accessorIndexVertex];
 	uint32_t offsetVert = runningOffset;
 	uint32_t sizeVert = accVert.buffer_view->size;
-	etdHelper.grBinds->vertexFirstBinding = index;
-	etdHelper.grBinds->vertexBindingCount = 1;
+	etdHelper.etd->grBinds->vertexFirstBinding = index;
+	etdHelper.etd->grBinds->vertexBindingCount = 1;
 	alignmentPadding = sizeVert % helper.vertMemoryRequirementsCombined.alignment;
 	alignmentPadding = alignmentPadding == 0 ? 0 : helper.vertMemoryRequirementsCombined.alignment - alignmentPadding;
 	sizeVert += alignmentPadding;
 	bufferCI.size = sizeVert;
 	bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->vertexBuffer);
-	vkBindBufferMemory(vkDevice, etdHelper.grBinds->vertexBuffer, helper.et.deviceMemoryVert, offsetVert);
+	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->vertexBuffer);
+	vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->vertexBuffer, helper.et.deviceMemoryVert, offsetVert);
 	runningOffset += sizeVert;
 	index += 1;
 
@@ -672,14 +720,14 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 	const auto &accNorm = helper.gltfData->accessors[accessorIndexNormal];
 	uint32_t offsetNorm = runningOffset;
 	uint32_t sizeNorm = accNorm.buffer_view->size;
-	etdHelper.grBinds->normalsFirstBinding = index;
-	etdHelper.grBinds->normalsBindingCount = 1;
+	etdHelper.etd->grBinds->normalsFirstBinding = index;
+	etdHelper.etd->grBinds->normalsBindingCount = 1;
 	alignmentPadding = sizeNorm % helper.vertMemoryRequirementsCombined.alignment;
 	alignmentPadding = alignmentPadding == 0 ? 0 : helper.vertMemoryRequirementsCombined.alignment - alignmentPadding;
 	sizeNorm += alignmentPadding;
 	bufferCI.size = sizeNorm;
-	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->normalsBuffer);
-	vkBindBufferMemory(vkDevice, etdHelper.grBinds->normalsBuffer, helper.et.deviceMemoryVert, offsetNorm);
+	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->normalsBuffer);
+	vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->normalsBuffer, helper.et.deviceMemoryVert, offsetNorm);
 	runningOffset += sizeNorm;
 	index += 1;
 
@@ -687,21 +735,21 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 	const auto &accUV = helper.gltfData->accessors[accessorIndexUV];
 	uint32_t offsetUV = runningOffset;
 	uint32_t sizeUV = accUV.buffer_view->size;
-	etdHelper.grBinds->uvFirstBinding = index;
-	etdHelper.grBinds->uvBindingCount = 1;
+	etdHelper.etd->grBinds->uvFirstBinding = index;
+	etdHelper.etd->grBinds->uvBindingCount = 1;
 	alignmentPadding = sizeUV % helper.vertMemoryRequirementsCombined.alignment;
 	alignmentPadding = alignmentPadding == 0 ? 0 : helper.vertMemoryRequirementsCombined.alignment - alignmentPadding;
 	sizeUV += alignmentPadding;
 	bufferCI.size = sizeUV;
-	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->uvBuffer);
-	vkBindBufferMemory(vkDevice, etdHelper.grBinds->uvBuffer	, helper.et.deviceMemoryVert, offsetUV);
+	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->uvBuffer);
+	vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->uvBuffer	, helper.et.deviceMemoryVert, offsetUV);
 	runningOffset += sizeUV;
 	index += 1;
 
 	// 2023-09-27 - JCB
 	// I don't know where else to put this
-	etdHelper.grBinds->instanceFirstBinding = index;
-	etdHelper.grBinds->instanceBindingCount = 1;
+	etdHelper.etd->grBinds->instanceFirstBinding = index;
+	etdHelper.etd->grBinds->instanceBindingCount = 1;
 	// no index += 1 because index just happens to be the right value here for
 	//  the binding index, whereas binding the IndexBuffer doesn't need a binding index.
 
@@ -709,15 +757,15 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 	const auto &accIndex = helper.gltfData->accessors[accessorIndexIndex];
 	uint32_t offsetIndex = runningOffset;
 	uint32_t sizeIndex = accIndex.buffer_view->size;
-	etdHelper.grBinds->indexBindingCount = 1;
-	etdHelper.grBinds->indexCount = accIndex.count;
+	etdHelper.etd->grBinds->indexBindingCount = 1;
+	etdHelper.etd->grBinds->indexCount = accIndex.count;
 	alignmentPadding = sizeIndex % helper.vertMemoryRequirementsCombined.alignment;
 	alignmentPadding = alignmentPadding == 0 ? 0 : helper.vertMemoryRequirementsCombined.alignment - alignmentPadding;
 	sizeIndex += alignmentPadding;
 	bufferCI.size = sizeIndex;
 	bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
-	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->indexBuffer);
-	vkBindBufferMemory(vkDevice, etdHelper.grBinds->indexBuffer, helper.et.deviceMemoryVert, offsetIndex);
+	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->indexBuffer);
+	vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->indexBuffer, helper.et.deviceMemoryVert, offsetIndex);
 	runningOffset += sizeIndex;
 	// index += 1;
 
@@ -764,22 +812,22 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 		index = 0;
 		bufferCopys[index].srcOffset = offsetVert;
 		bufferCopys[index].size = sizeVert;
-		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->vertexBuffer, 1, &bufferCopys[index]);
+		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->vertexBuffer, 1, &bufferCopys[index]);
 		index+=1;
 
 		bufferCopys[index].srcOffset = offsetNorm;
 		bufferCopys[index].size = sizeNorm;
-		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->normalsBuffer, 1, &bufferCopys[index]);
+		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->normalsBuffer, 1, &bufferCopys[index]);
 		index+=1;
 
 		bufferCopys[index].srcOffset = offsetUV;
 		bufferCopys[index].size = sizeUV;
-		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->uvBuffer, 1, &bufferCopys[index]);
+		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->uvBuffer, 1, &bufferCopys[index]);
 		index+=1;
 
 		bufferCopys[index].srcOffset = offsetIndex;
 		bufferCopys[index].size = sizeIndex;
-		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->indexBuffer, 1, &bufferCopys[index]);
+		vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->indexBuffer, 1, &bufferCopys[index]);
 		// index+=1;
 
 		vkEndCommandBuffer(transferCommandBuffer);
@@ -801,12 +849,12 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 	}
 
 	// set up instance buffer
-	etdHelper.grBinds->instanceBufferMaxCount = etdHelper.etd->startingInstanceCount;
-	etdHelper.grBinds->instanceBufferMaxCount = etdHelper.grBinds->instanceBufferMaxCount < 1 ? 1 : etdHelper.grBinds->instanceBufferMaxCount;
-	bufferCI.size = sizeof(glm::mat4) * etdHelper.grBinds->instanceBufferMaxCount;
+	etdHelper.etd->grBinds->instanceBufferMaxCount = etdHelper.etd->startingInstanceCount;
+	etdHelper.etd->grBinds->instanceBufferMaxCount = etdHelper.etd->grBinds->instanceBufferMaxCount < 1 ? 1 : etdHelper.etd->grBinds->instanceBufferMaxCount;
+	bufferCI.size = sizeof(glm::mat4) * etdHelper.etd->grBinds->instanceBufferMaxCount;
 	bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->instanceBuffer);
-	vkBindBufferMemory(vkDevice, etdHelper.grBinds->instanceBuffer, helper.et.deviceMemoryInst, 0);
+	vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->instanceBuffer);
+	vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->instanceBuffer, helper.et.deviceMemoryInst, 0);
 
 	// bullet
 
@@ -818,60 +866,60 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 		// vertex
 		offsetVert = runningOffset;
 		sizeVert = sizeof(glm::vec3) * etdHelper.physDbg.vertexes->Count();
-		etdHelper.grBinds->physVertBD.firstBinding = index;
-		etdHelper.grBinds->physVertBD.bindingCount = 1;
+		etdHelper.etd->grBinds->physVertBD.firstBinding = index;
+		etdHelper.etd->grBinds->physVertBD.bindingCount = 1;
 		alignmentPadding = sizeVert % helper.physVertMemoryRequirementsCombined.alignment;
 		alignmentPadding = alignmentPadding == 0 ? 0 : helper.physVertMemoryRequirementsCombined.alignment - alignmentPadding;
 		sizeVert += alignmentPadding;
 		bufferCI.size = sizeVert;
 		bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->physVertBD.buffer);
-		vkBindBufferMemory(vkDevice, etdHelper.grBinds->physVertBD.buffer, helper.et.deviceMemoryPhysVert, offsetVert);
+		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->physVertBD.buffer);
+		vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->physVertBD.buffer, helper.et.deviceMemoryPhysVert, offsetVert);
 		runningOffset += sizeVert;
 
 		// norm
 		index = 1;
 		offsetNorm = runningOffset;
 		sizeNorm = sizeof(glm::vec3) * etdHelper.physDbg.normals->Count();
-		etdHelper.grBinds->physNormBD.firstBinding = index;
-		etdHelper.grBinds->physNormBD.bindingCount = 1;
+		etdHelper.etd->grBinds->physNormBD.firstBinding = index;
+		etdHelper.etd->grBinds->physNormBD.bindingCount = 1;
 		alignmentPadding = sizeNorm % helper.physVertMemoryRequirementsCombined.alignment;
 		alignmentPadding = alignmentPadding == 0 ? 0 : helper.physVertMemoryRequirementsCombined.alignment - alignmentPadding;
 		sizeNorm += alignmentPadding;
 		bufferCI.size = sizeNorm;
 		bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->physNormBD.buffer);
-		vkBindBufferMemory(vkDevice, etdHelper.grBinds->physNormBD.buffer, helper.et.deviceMemoryPhysVert, offsetNorm);
+		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->physNormBD.buffer);
+		vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->physNormBD.buffer, helper.et.deviceMemoryPhysVert, offsetNorm);
 		runningOffset += sizeNorm;
 
 		// uv
 		index = 2;
 		offsetUV = runningOffset;
 		sizeUV = sizeof(glm::vec2) * etdHelper.physDbg.uv->Count();
-		etdHelper.grBinds->physUvBD.firstBinding = index;
-		etdHelper.grBinds->physUvBD.bindingCount = 1;
+		etdHelper.etd->grBinds->physUvBD.firstBinding = index;
+		etdHelper.etd->grBinds->physUvBD.bindingCount = 1;
 		alignmentPadding = sizeUV % helper.physVertMemoryRequirementsCombined.alignment;
 		alignmentPadding = alignmentPadding == 0 ? 0 : helper.physVertMemoryRequirementsCombined.alignment - alignmentPadding;
 		sizeUV += alignmentPadding;
 		bufferCI.size = sizeUV;
 		bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->physUvBD.buffer);
-		vkBindBufferMemory(vkDevice, etdHelper.grBinds->physUvBD.buffer, helper.et.deviceMemoryPhysVert, offsetUV);
+		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->physUvBD.buffer);
+		vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->physUvBD.buffer, helper.et.deviceMemoryPhysVert, offsetUV);
 		runningOffset += sizeUV;
 
 		// index
 		index = 3;
 		offsetIndex = runningOffset;
 		sizeIndex = sizeof(uint16_t) * etdHelper.physDbg.indexes->Count();
-		etdHelper.grBinds->physIndxBD.firstBinding = index;
-		etdHelper.grBinds->physIndxBD.bindingCount = 1;
+		etdHelper.etd->grBinds->physIndxBD.firstBinding = index;
+		etdHelper.etd->grBinds->physIndxBD.bindingCount = 1;
 		alignmentPadding = sizeIndex % helper.physVertMemoryRequirementsCombined.alignment;
 		alignmentPadding = alignmentPadding == 0 ? 0 : helper.physVertMemoryRequirementsCombined.alignment - alignmentPadding;
 		sizeIndex += alignmentPadding;
 		bufferCI.size = sizeIndex;
 		bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
-		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.grBinds->physIndxBD.buffer);
-		vkBindBufferMemory(vkDevice, etdHelper.grBinds->physIndxBD.buffer, helper.et.deviceMemoryPhysVert, offsetIndex);
+		vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &etdHelper.etd->grBinds->physIndxBD.buffer);
+		vkBindBufferMemory(vkDevice, etdHelper.etd->grBinds->physIndxBD.buffer, helper.et.deviceMemoryPhysVert, offsetIndex);
 		runningOffset += sizeIndex;
 
 		assert(runningOffset == helper.physVertMemoryRequirementsCombined.size);
@@ -922,25 +970,25 @@ void EntityType_LoadMesh(EntityType_LoadHelperStruct &helper, const int64_t mesh
 			runningOffset = 0;
 			bufferCopys[index].srcOffset = runningOffset;
 			bufferCopys[index].size = sizeVert;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->physVertBD.buffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->physVertBD.buffer, 1, &bufferCopys[index]);
 			runningOffset += sizeVert;
 			index+=1;
 
 			bufferCopys[index].srcOffset = runningOffset;
 			bufferCopys[index].size = sizeNorm;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->physNormBD.buffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->physNormBD.buffer, 1, &bufferCopys[index]);
 			runningOffset += sizeNorm;
 			index+=1;
 
 			bufferCopys[index].srcOffset = runningOffset;
 			bufferCopys[index].size = sizeUV;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->physUvBD.buffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->physUvBD.buffer, 1, &bufferCopys[index]);
 			runningOffset += sizeUV;
 			index+=1;
 
 			bufferCopys[index].srcOffset = runningOffset;
 			bufferCopys[index].size = sizeIndex;
-			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.grBinds->physIndxBD.buffer, 1, &bufferCopys[index]);
+			vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, etdHelper.etd->grBinds->physIndxBD.buffer, 1, &bufferCopys[index]);
 			// runningOffset += sizeIndex;
 			// index+=1;
 
@@ -1012,14 +1060,14 @@ void EntityType_Load(EntityType &et) {
 	EntityType_PreLoad(helper);
 
 	for (int64_t i = 0; i < et.detailsCount; ++i) {
-		EntityTypeDetails_LoadHelperStruct &etd = (*helper.etdHelpers)[i];
+		EntityTypeDetails_LoadHelperStruct &etdHelper = (*helper.etdHelpers)[i];
 		/*
 		 * 2023-09-13 - JCB
 		 * I don't like that we're just copying this.
 		 * This should be moved to window.cpp.
 		 */
-		etd.grBinds->vkPipelineLayout = pkePipelines.vkPipelineLayout_Texture;
-		etd.grBinds->graphicsPipeline = pkePipelines.pipelines.Texture;
+		etdHelper.etd->grBinds->vkPipelineLayout = pkePipelines.vkPipelineLayout_Texture;
+		etdHelper.etd->grBinds->graphicsPipeline = pkePipelines.pipelines.Texture;
 
 		// handle texture
 		EntityType_LoadTexture(helper, i);
@@ -1151,17 +1199,15 @@ void EntityType_Unload(EntityType &et, CompGrBinds *grBindsArr[1]) {
 
 void EntityType_Tick(double delta) {
 	const auto count = EntitiesToBeRemoved.Count();
-	int64_t detailIndex = -1;
 	for (long i = 0; i < count; ++i) {
-		if (auto index = EntityType_FindByEntity(EntitiesToBeRemoved[i], detailIndex); index > -1) {
-			auto &entType = GlobalEntityTypes[index];
-			if (auto *grBinds = ECS_GetGrBinds(entType.details[detailIndex].grBindsHandle); grBinds != nullptr) {
-				auto &td = EntityTypesToTeardown.Push();
-				td.handle = EntitiesToBeRemoved[i]->handle;
-				td.ticksToWait = 1;
-				for (long k = 0; k < GlobalEntityTypes[index].detailsCount; ++k) {
-					td.grBinds[k] = grBinds;
-				}
+		auto *entTypePtr = EntityType_FindByEntityHandle(EntitiesToBeRemoved[i]->handle);
+		if (entTypePtr != nullptr) {
+			auto &entType = *entTypePtr;
+			auto &td = EntityTypesToTeardown.Push();
+			td.handle = EntitiesToBeRemoved[i]->handle;
+			td.ticksToWait = 1;
+			for (long k = 0; k < entType.detailsCount; ++k) {
+				td.grBinds[k] = entType.details[k].grBinds;
 			}
 		}
 	}
@@ -1170,21 +1216,22 @@ void EntityType_Tick(double delta) {
 void EntityType_Tick_Late(double delta) {
 	while (EntitiesWithExcessInstances.Count() != 0) {
 		auto *entity = EntitiesWithExcessInstances.Pop();
-		int64_t detailIndex = 0;
-		auto index = EntityType_FindByEntity(entity, detailIndex);
-		auto &et = GlobalEntityTypes[index];
-		auto &etd = GlobalEntityTypes[index].details[detailIndex];
-		auto *grBinds = ECS_GetGrBinds(etd.grBindsHandle);
-		EntityType_RolloverInstances(et, *grBinds);
+		auto *etPtr = EntityType_FindByEntityHandle(entity->handle);
+		assert(etPtr != nullptr);
+		auto &et = *etPtr;
+		for (int64_t i = 0; i < et.detailsCount; ++i) {
+			auto &etd = et.details[i];
+			assert(etd.grBinds != nullptr);
+			EntityType_RolloverInstances(et, *etd.grBinds);
+		}
 	}
 	for (int64_t i = EntityTypesToTeardown.Count() - 1; i >= 0; --i) {
 		auto &td = EntityTypesToTeardown[i];
 		td.ticksToWait -= 1;
 		if (td.ticksToWait == 0) {
-			int64_t detailIndex = -1;
-			auto index = EntityType_FindByEntityHandle(td.handle, detailIndex);
-			EntityType_Unload(GlobalEntityTypes[index], td.grBinds);
-			GlobalEntityTypes.Remove(index);
+			auto *entityType = EntityType_FindByEntityHandle(td.handle);
+			assert(entityType != nullptr);
+			EntityType_Unload(*entityType, td.grBinds);
 			EntityTypesToTeardown.Remove(i);
 		}
 	}
@@ -1286,18 +1333,33 @@ void EntityType_RolloverInstances(EntityType &et, CompGrBinds &grBinds) {
 	vkFreeMemory(vkDevice, oldMemory, vkAllocator);
 }
 
+PkeHandleBucketIndex_T EntityType_GetBucketCount() {
+	return EntityType_BC.pkeHandle.bucketIndex + 1;
+}
+
+EntityType *EntityType_GetEntityTypes(PkeHandleBucketIndex_T bucketIndex, PkeHandleItemIndex_T &itemCount) {
+	assert(bucketIndex <= EntityType_BC.pkeHandle.bucketIndex);
+	if (bucketIndex == EntityType_BC.pkeHandle.bucketIndex) itemCount = EntityType_BC.pkeHandle.itemIndex;
+	itemCount = EntityType_BC.limits.itemIndex;
+	return EntityType_BC.buckets[bucketIndex];
+}
+
 void EntityType_Teardown() {
-	for (int64_t i = GlobalEntityTypes.Count() - 1; i >= 0; --i) {
-		if (GlobalEntityTypes[i].modelAssetKey[0] == '\0') continue;
-		EntityType &et = GlobalEntityTypes[i];
-		CompGrBinds *grBindsArr[1] = {nullptr};
-
-		for (long k = 0; k < et.detailsCount; ++k) {
-			const EntityTypeDetails &etd = et.details[k];
-			grBindsArr[k] = ECS_GetGrBinds(etd.entityHandle);
+
+	for (PkeHandleBucketIndex_T b = 0; b <= EntityType_BC.pkeHandle.bucketIndex; ++b) {
+		auto &bkt = EntityType_BC.buckets[b];
+		long itemCount = EntityType_BC.pkeHandle.bucketIndex == b ? EntityType_BC.pkeHandle.itemIndex : EntityType_BC.limits.itemIndex;
+		for (PkeHandleItemIndex_T i = 0; i < itemCount; ++i) {
+			auto &et = bkt[i];
+			if (et.modelAssetKey[0] == '\0') continue;
+			CompGrBinds *grBindsArr[EntityTypeDetails_MAX] = {nullptr};
+			for (long k = 0; k < et.detailsCount; ++k) {
+				const EntityTypeDetails &etd = et.details[k];
+				grBindsArr[k] = etd.grBinds;
+			}
+			EntityType_Unload(et, grBindsArr);
 		}
-		EntityType_Unload(et, grBindsArr);
 	}
-	GlobalEntityTypes.~DynArray();
+	Buckets_Destroy(EntityType_BC);
 	EntityTypesToTeardown.~DynArray();
 }