replace handles with union struct

1 files changed, 45 insertions, 87 deletions

diff --git a/src/ecs.cpp b/src/ecs.cpp
index 6556bd2..fdc2473 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -12,8 +12,7 @@
 #include <BulletCollision/CollisionShapes/btConvexHullShape.h>
 #include <glm/gtc/type_ptr.hpp>
 
-TypeSafeInt_B(EntityHandle);
-const uint64_t maxBucketItemCount = 256;
+const uint32_t maxBucketItemCount = 256;
 
 struct EntityBucket {
 	Entity entities[maxBucketItemCount];
@@ -48,16 +47,13 @@ DynArray<Entity> entitiesYetToBeRemoved{0, nullptr};
 
 DynArray<EntityHandle> EntitiesWithExcessInstances{16};
 
-BucketContainer<EntityBucket, EntityHandle_T> Entities_BucketContainer{};
-BucketContainer<GrBindsBucket, GrBindsHandle_T> Comp_GrBinds_BucketContainer{};
-BucketContainer<InstanceBucket, InstanceHandle_T> Comp_Instance_BucketContainer{};
+BucketContainer<EntityBucket, EntityHandle> Entities_BucketContainer{};
+BucketContainer<GrBindsBucket, GrBindsHandle> Comp_GrBinds_BucketContainer{};
+BucketContainer<InstanceBucket, InstanceHandle> Comp_Instance_BucketContainer{};
 
 void ECS_GetEntity_Inner(EntityHandle entHandle, Entity*& ent) {
-	EntityHandle_T entHandle_t{static_cast<EntityHandle_T>(entHandle)};
-	assert(entHandle_t != EntityHandle_T_MAX && "Unknown entity handle");
-	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];
+	assert(entHandle != EntityHandle_MAX && "Unknown entity handle");
+	ent = &Entities_BucketContainer.buckets[entHandle.bucketIndex].entities[entHandle.itemIndex];
 }
 
 void ECS_Init() {
@@ -67,22 +63,19 @@ void ECS_Init() {
 }
 
 uint64_t ECS_GetEntities_BucketCount() {
-	return Entities_BucketContainer.bucketCounter + 1;
+	return Entities_BucketContainer.pkeHandle.bucketIndex + 1;
 }
 Entity *ECS_GetEntities(uint64_t bucketIndex, uint64_t &itemCount) {
-	assert(bucketIndex <= Entities_BucketContainer.bucketCounter);
-	itemCount = bucketIndex == Entities_BucketContainer.bucketCounter ? Entities_BucketContainer.itemCounter >> 32 : maxBucketItemCount;
+	assert(bucketIndex <= Entities_BucketContainer.pkeHandle.bucketIndex);
+	itemCount = bucketIndex == Entities_BucketContainer.pkeHandle.bucketIndex ? Entities_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
 	return Entities_BucketContainer.buckets[bucketIndex].entities;
 }
 
 EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntHandle) {
 	bool moved;
-	EntityHandle_T entityHandle_T{Buckets_NewHandle<EntityBucket>(maxBucketItemCount, Entities_BucketContainer, moved)};
-	EntityHandle entityHandle{entityHandle_T};
+	EntityHandle entityHandle{Buckets_NewHandle<EntityBucket>(maxBucketItemCount, Entities_BucketContainer, moved)};
 
-	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 *entity = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
 	entity = new (entity) Entity{};
 	entity->handle = entityHandle;
 	entity->parentHandle = parentEntHandle;
@@ -95,9 +88,7 @@ EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle) {
 }
 
 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 = &Entities_BucketContainer.buckets[b].entities[e];
+	const Entity *ent = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
 	assert(ent->isMarkedForRemoval == false && "Entity already marked for removal");
 	entitiesMarkedForRemoval.Push(entityHandle);
 }
@@ -108,8 +99,8 @@ void ECS_Tick_Early(double delta) {
 	EntitiesToBeRemoved.Resize(entitiesMarkedForRemoval.Count());
 	memcpy(EntitiesToBeRemoved.GetPtr(), entitiesMarkedForRemoval.GetPtr(), sizeof(EntityHandle) * entitiesMarkedForRemoval.Count());
 	entitiesYetToBeRemoved.Resize(0);
-	for (long b = 0; b <= Entities_BucketContainer.bucketCounter; ++b) {
-		uint64_t entCount = b == Entities_BucketContainer.bucketCounter ? Entities_BucketContainer.itemCounter >> 32 : maxBucketItemCount;
+	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];
 			if (ent->handle == EntityHandle_MAX) continue;
@@ -133,29 +124,20 @@ void ECS_Tick_Early(double delta) {
 		CompInstance *inst = nullptr;
 		uint64_t instBucketIndex = 0;
 		if (clonedEnt.instanceHandle != InstanceHandle_MAX) {
-			InstanceHandle_T instanceHandle_t{static_cast<InstanceHandle_T>(clonedEnt.instanceHandle)};
-			auto b = Buckets_GetBucketIndex(instanceHandle_t);
-			auto i = Buckets_GetItemIndex(instanceHandle_t);
-			instBucketIndex = b;
-			instBucket = &Comp_Instance_BucketContainer.buckets[b];
-			inst = &instBucket->instances[i];
-			GrBindsHandle_T grBindsHandle_t = static_cast<GrBindsHandle_T>(inst->grBindsHandle);
-			b = Buckets_GetBucketIndex(grBindsHandle_t);
-			i = Buckets_GetItemIndex(grBindsHandle_t);
-			grBinds = &Comp_GrBinds_BucketContainer.buckets[b].compGrBinds[i];
+			instBucketIndex = clonedEnt.instanceHandle.bucketIndex;
+			instBucket = &Comp_Instance_BucketContainer.buckets[instBucketIndex];
+			inst = &instBucket->instances[clonedEnt.instanceHandle.itemIndex];
+			grBinds = &Comp_GrBinds_BucketContainer.buckets[inst->grBindsHandle.bucketIndex].compGrBinds[inst->grBindsHandle.itemIndex];
 		}
 		if (grBinds == nullptr && clonedEnt.grBindsHandle != GrBindsHandle_MAX) {
-			GrBindsHandle_T bindsHandle_t{static_cast<GrBindsHandle_T>(clonedEnt.grBindsHandle)};
-			auto b = Buckets_GetBucketIndex(bindsHandle_t);
-			auto i = Buckets_GetItemIndex(bindsHandle_t);
-			grBinds = &Comp_GrBinds_BucketContainer.buckets[b].compGrBinds[i];
+			grBinds = &Comp_GrBinds_BucketContainer.buckets[clonedEnt.grBindsHandle.bucketIndex].compGrBinds[clonedEnt.grBindsHandle.itemIndex];
 		}
 		if (inst != nullptr) {
 			assert(grBinds != nullptr);
-			for (long bi = instBucketIndex; bi <= Comp_Instance_BucketContainer.bucketCounter; ++bi) {
+			for (long bi = instBucketIndex; bi <= Comp_Instance_BucketContainer.pkeHandle.bucketIndex; ++bi) {
 				uint64_t instCounter = 0;
-				if (bi == Comp_Instance_BucketContainer.bucketCounter) {
-					instCounter = Comp_Instance_BucketContainer.itemCounter >> 32;
+				if (bi == Comp_Instance_BucketContainer.pkeHandle.bucketIndex) {
+					instCounter = Comp_Instance_BucketContainer.pkeHandle.itemIndex;
 				} else {
 					instCounter = maxBucketItemCount;
 				}
@@ -167,7 +149,7 @@ void ECS_Tick_Early(double delta) {
 					if (bucket.instances[ii].grBindsHandle != clonedEnt.grBindsHandle) {
 						continue;
 					}
-					if (bucket.instances[ii].instanceHandle < clonedEnt.instanceHandle) {
+					if (bucket.instances[ii].instanceHandle.itemIndex < clonedEnt.instanceHandle.itemIndex) {
 						continue;
 					}
 					bucket.instances[ii].index -= 1;
@@ -197,9 +179,9 @@ void ECS_Tick_Early(double delta) {
 void ECS_Tick(double delta) {
 	int32_t physicsTickCount = Physics_Tick(delta);
 	if (physicsTickCount != 0) {
-		for (long b = 0; b <= Comp_Instance_BucketContainer.bucketCounter; ++b) {
+		for (long b = 0; b <= Comp_Instance_BucketContainer.pkeHandle.bucketIndex; ++b) {
 			auto &bkt = Comp_Instance_BucketContainer.buckets[b];
-			long count = Comp_Instance_BucketContainer.bucketCounter == b ? Comp_Instance_BucketContainer.itemCounter >> 32 : maxBucketItemCount;
+			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];
 				if (inst.entHandle == EntityHandle_MAX)
@@ -230,9 +212,9 @@ void ECS_Tick_Late(double delta) {
 	DynArray<InstanceBufferCopy> *bufferUpdatesPtr = Pke_New<DynArray<InstanceBufferCopy>>(pkeSettings.mem.bkt);
 	new (bufferUpdatesPtr) DynArray<InstanceBufferCopy>(0, pkeSettings.mem.bkt);
 	DynArray<InstanceBufferCopy> &bufferUpdates = *bufferUpdatesPtr;
-	for (long b = 0; b <= Comp_Instance_BucketContainer.bucketCounter; ++b) {
+	for (long b = 0; b <= Comp_Instance_BucketContainer.pkeHandle.bucketIndex; ++b) {
 		auto &bkt = Comp_Instance_BucketContainer.buckets[b];
-		long count = Comp_Instance_BucketContainer.bucketCounter == b ? Comp_Instance_BucketContainer.itemCounter >> 32 : maxBucketItemCount;
+		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];
 			if (inst.isNeedingUpdated == false)
@@ -240,10 +222,7 @@ void ECS_Tick_Late(double delta) {
 			if (inst.entHandle == EntityHandle_MAX)
 				continue;
 
-			GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(inst.grBindsHandle)};
-			auto b_inner = Buckets_GetBucketIndex(grBindsHandle_t);
-			auto bi_inner = Buckets_GetItemIndex(grBindsHandle_t);
-			auto &grBinds = Comp_GrBinds_BucketContainer.buckets[b_inner].compGrBinds[bi_inner];
+			auto &grBinds = Comp_GrBinds_BucketContainer.buckets[inst.grBindsHandle.bucketIndex].compGrBinds[inst.grBindsHandle.itemIndex];
 
 			InstanceBufferCopy *bfrUpdate = nullptr;
 			for (long u = 0; u < bufferUpdates.Count(); ++u) {
@@ -355,11 +334,8 @@ CompGrBinds &ECS_CreateGrBinds(EntityHandle entHandle) {
 	assert(ent->grBindsHandle == GrBindsHandle_MAX);
 
 	bool moved;
-	GrBindsHandle_T newHandle{Buckets_NewHandle(maxBucketItemCount, Comp_GrBinds_BucketContainer, moved)};
-	ent->grBindsHandle = GrBindsHandle{newHandle};
-	auto b = Buckets_GetBucketIndex(newHandle);
-	auto i = Buckets_GetItemIndex(newHandle);
-	auto *comp = &Comp_GrBinds_BucketContainer.buckets[b].compGrBinds[i];
+	ent->grBindsHandle = Buckets_NewHandle(maxBucketItemCount, Comp_GrBinds_BucketContainer, moved);
+	auto *comp = &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
 	comp = new (comp) CompGrBinds{};
 	comp->entHandle = entHandle;
 	comp->grBindsHandle = ent->grBindsHandle;
@@ -370,26 +346,20 @@ CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle) {
 	Entity *ent = nullptr;
 	ECS_GetEntity_Inner(entHandle, ent);
 	if (ent->grBindsHandle == GrBindsHandle_MAX) return nullptr;
-	GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(ent->grBindsHandle)};
-	auto b = Buckets_GetBucketIndex(grBindsHandle_t);
-	auto i = Buckets_GetItemIndex(grBindsHandle_t);
-	return &Comp_GrBinds_BucketContainer.buckets[b].compGrBinds[i];
+	return &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
 }
 CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
 	if (grBindsHandle == GrBindsHandle_MAX) return nullptr;
-	GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(grBindsHandle)};
-	auto b = Buckets_GetBucketIndex(grBindsHandle_t);
-	auto i = Buckets_GetItemIndex(grBindsHandle_t);
-	return &Comp_GrBinds_BucketContainer.buckets[b].compGrBinds[i];
+	return &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex].compGrBinds[grBindsHandle.itemIndex];
 }
 
 uint64_t ECS_GetGrBinds_BucketCount() {
-	return Comp_GrBinds_BucketContainer.bucketCounter + 1;
+	return Comp_GrBinds_BucketContainer.pkeHandle.bucketIndex + 1;
 }
 
 CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
-	if (bucketIndex == Comp_GrBinds_BucketContainer.bucketCounter) {
-		itemCount = Comp_GrBinds_BucketContainer.itemCounter >> 32;
+	if (bucketIndex == Comp_GrBinds_BucketContainer.pkeHandle.bucketIndex) {
+		itemCount = Comp_GrBinds_BucketContainer.pkeHandle.itemIndex;
 	} else {
 		itemCount = maxBucketItemCount;
 	}
@@ -409,20 +379,14 @@ CompInstance &ECS_CreateInstance(EntityHandle entHandle, EntityHandle entityType
 	assert(entTypeEnt->grBindsHandle != GrBindsHandle_MAX);
 
 	bool moved;
-	InstanceHandle_T newHandle{Buckets_NewHandle(maxBucketItemCount, Comp_Instance_BucketContainer, moved)};
-	ent->instanceHandle = InstanceHandle{newHandle};
-	GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(entTypeEnt->grBindsHandle)};
-
-	auto b = Buckets_GetBucketIndex(newHandle);
-	auto i = Buckets_GetItemIndex(newHandle);
-	auto *instBkt = &Comp_Instance_BucketContainer.buckets[b];
-	auto *comp = &instBkt->instances[i];
+	ent->instanceHandle = Buckets_NewHandle(maxBucketItemCount, Comp_Instance_BucketContainer, moved);
+
+	auto *instBkt = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex];
+	auto *comp = &instBkt->instances[ent->instanceHandle.itemIndex];
 	comp = new (comp) CompInstance{};
 	comp->entHandle = entHandle;
 
-	auto b2 = Buckets_GetBucketIndex(grBindsHandle_t);
-	auto i2 = Buckets_GetItemIndex(grBindsHandle_t);
-	auto *grBinds = &Comp_GrBinds_BucketContainer.buckets[b2].compGrBinds[i2];
+	auto *grBinds = &Comp_GrBinds_BucketContainer.buckets[entTypeEnt->grBindsHandle.bucketIndex].compGrBinds[entTypeEnt->grBindsHandle.itemIndex];
 
 	comp->grBindsHandle = grBinds->grBindsHandle;
 	comp->instanceHandle = ent->instanceHandle;
@@ -443,10 +407,7 @@ CompInstance *ECS_GetInstance(EntityHandle entHandle) {
 	if (ent->instanceHandle == InstanceHandle_MAX)
 		return nullptr;
 
-	InstanceHandle_T instanceHandle_t{static_cast<InstanceHandle_T>(ent->instanceHandle)};
-	auto b = Buckets_GetBucketIndex(instanceHandle_t);
-	auto i = Buckets_GetItemIndex(instanceHandle_t);
-	auto *inst = &Comp_Instance_BucketContainer.buckets[b].instances[i];
+	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
 
 	return inst;
 }
@@ -458,10 +419,7 @@ void ECS_UpdateInstance(EntityHandle entHandle, const InstPos &instPos, bool ove
 	if (ent->instanceHandle == InstanceHandle_MAX)
 		return;
 
-	InstanceHandle_T instanceHandle_t{static_cast<InstanceHandle_T>(ent->instanceHandle)};
-	auto b = Buckets_GetBucketIndex(instanceHandle_t);
-	auto i = Buckets_GetItemIndex(instanceHandle_t);
-	auto *inst = &Comp_Instance_BucketContainer.buckets[b].instances[i];
+	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
 
 	if (BtDynamicsWorld && overridePhysics) {
 		btVector3 localInertia(0, 0, 0);
@@ -478,12 +436,12 @@ void ECS_UpdateInstance(EntityHandle entHandle, const InstPos &instPos, bool ove
 }
 
 uint64_t ECS_GetInstances_BucketCount() {
-	return Comp_Instance_BucketContainer.bucketCounter + 1;
+	return Comp_Instance_BucketContainer.pkeHandle.bucketIndex + 1;
 }
 
 CompInstance *ECS_GetInstances(uint64_t bucketIndex, uint64_t &itemCount) {
-	if (bucketIndex == Comp_Instance_BucketContainer.bucketCounter) {
-		itemCount = Comp_Instance_BucketContainer.itemCounter >> 32;
+	if (bucketIndex == Comp_Instance_BucketContainer.pkeHandle.bucketIndex) {
+		itemCount = Comp_Instance_BucketContainer.pkeHandle.itemIndex;
 	} else {
 		itemCount = maxBucketItemCount;
 	}