replace handles with union struct

16 files changed, 151 insertions, 204 deletions

diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp
index d6a14a4..4350e87 100644
--- a/src/asset-manager.cpp
+++ b/src/asset-manager.cpp
@@ -1,15 +1,13 @@
 
 #include "asset-manager.hpp"
 
-TypeSafeInt_B(AssetHandle);
-
-const uint64_t maxAssetItemsPerBucket = 256;
+const uint32_t maxAssetItemsPerBucket = 256;
 
 struct AssetBucket {
 	Asset assets[maxAssetItemsPerBucket];
 };
 
-BucketContainer<AssetBucket, AssetHandle_T> Asset_BucketContainer{};
+BucketContainer<AssetBucket, AssetHandle> Asset_BucketContainer{};
 
 void AM_Init() {
 	Buckets_Init(Asset_BucketContainer);
@@ -17,19 +15,17 @@ void AM_Init() {
 
 AssetHandle AM_Register_Inner(const void *src, void *dst, int64_t size, const char *key) {
 	bool moved = false;
-	AssetHandle_T assetHandle_T{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
+	AssetHandle assetHandle{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
 
 	if (src != nullptr) {
 		std::memcpy(dst, src, size);
 	}
-	auto b = Buckets_GetBucketIndex(assetHandle_T);
-	auto e = Buckets_GetItemIndex(assetHandle_T);
-	Asset *asset = &Asset_BucketContainer.buckets[b].assets[e];
+	Asset *asset = &Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
 	asset->ptr = dst;
 	asset->size = size;
 	int64_t keyLen = std::strlen(key);
 	std::memcpy(asset->key, key, keyLen > 16 ? 16 : keyLen);
-	return AssetHandle{assetHandle_T};
+	return assetHandle;
 }
 
 AssetHandle AM_Register(const void *data, int64_t size, std::size_t alignment, const char *key) {
@@ -50,9 +46,7 @@ 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));
-	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];
+	Asset *asset = &Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
 	file.seekg(0);
 	file.read(static_cast<char *>(asset->ptr), fileSize);
 	file.close();
@@ -61,38 +55,33 @@ AssetHandle AM_Register(const char *path) {
 }
 
 void AM_Destroy(AssetHandle assetHandle) {
-	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
-	auto b = Buckets_GetBucketIndex(assetHandle_T);
-	auto i = Buckets_GetItemIndex(assetHandle_T);
-	Asset *asset = &Asset_BucketContainer.buckets[b].assets[i];
+	assert(assetHandle != AssetHandle_MAX);
+	Asset *asset = &Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
 	Pke_Delete(asset->ptr, asset->size);
 	asset->size = 0;
 	asset->ptr = CAFE_BABE(void);
-	auto lastGivenIndex = ((Asset_BucketContainer.itemCounter - (1ULL << 32)) >> 32);
-	if (i == lastGivenIndex) {
-		Asset_BucketContainer.itemCounter = lastGivenIndex;
+	if (assetHandle.itemIndex == Asset_BucketContainer.pkeHandle.itemIndex) {
+		Asset_BucketContainer.pkeHandle.itemIndex -= 1;
 	}
 }
 
 const Asset *AM_Get(AssetHandle assetHandle) {
-	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
-	auto b = Buckets_GetBucketIndex(assetHandle_T);
-	auto i = Buckets_GetItemIndex(assetHandle_T);
-	return &Asset_BucketContainer.buckets[b].assets[i];
+	assert(assetHandle != AssetHandle_MAX);
+	return &Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
 }
 
 void AM_DebugPrint() {
 	printf("Asset Manager printout:\n");
-	for (uint64_t b = 0; b <= Asset_BucketContainer.bucketCounter; ++b) {
+	for (uint64_t b = 0; b <= Asset_BucketContainer.pkeHandle.bucketIndex; ++b) {
 		auto &bkt = Asset_BucketContainer.buckets[b];
-		long counter = b == Asset_BucketContainer.bucketCounter ? Asset_BucketContainer.itemCounter >> 32 : maxAssetItemsPerBucket;
+		uint64_t counter = b == Asset_BucketContainer.pkeHandle.bucketIndex ? Asset_BucketContainer.pkeHandle.itemIndex : maxAssetItemsPerBucket;
 		for (uint64_t i = 0; i < counter; ++i) {
 			auto &asset = bkt.assets[i];
 			/*
 			if (asset.size == 0)
 				continue;
 			*/
-			printf("-Asset: 0x%016lX\n", b + (i << 32));
+			printf("-Asset: 0x%016lX\n", (b << 32) + i);
 			printf("\tkey:  %s\n", asset.key);
 			printf("\tsize: %ld\n", asset.size);
 			printf("\tptr   %p\n", asset.ptr);
diff --git a/src/asset-manager.hpp b/src/asset-manager.hpp
index 7459fd0..001ec4f 100644
--- a/src/asset-manager.hpp
+++ b/src/asset-manager.hpp
@@ -9,7 +9,9 @@
 #include <cstring>
 #include <cassert>
 
-TypeSafeInt_H(AssetHandle, uint64_t, UINT64_MAX);
+struct AssetHandle : public PkeHandle { };
+
+constexpr AssetHandle AssetHandle_MAX = AssetHandle{};
 
 struct Asset{
 	char key[16] = {'\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'};
diff --git a/src/camera.cpp b/src/camera.cpp
index f5e1cfc..07c00b8 100644
--- a/src/camera.cpp
+++ b/src/camera.cpp
@@ -2,8 +2,6 @@
 #include "camera.hpp"
 #include "memory.hpp"
 
-TypeSafeInt_B(CameraHandle);
-
 PkeCamera NullCamera {
 	.handle = CameraHandle_MAX,
 	.pos = glm::vec3(3.f, 3.f, 3.f),
@@ -19,34 +17,28 @@ const long MAX_CAMERAS_PER_BUCKET = 32;
 struct CameraBucket {
 	PkeCamera cameras[MAX_CAMERAS_PER_BUCKET];
 };
-BucketContainer<CameraBucket, CameraHandle_T> Camera_BucketContainer{};
+BucketContainer<CameraBucket, CameraHandle> Camera_BucketContainer{};
 
 PkeCamera &PkeCamera_Register() {
 	bool moved = false;
 	CameraHandle activeHandle = ActiveCamera->handle;
-	CameraHandle_T cameraHandle_T{Buckets_NewHandle<CameraBucket>(MAX_CAMERAS_PER_BUCKET, Camera_BucketContainer, moved)};
+	CameraHandle cameraHandle{Buckets_NewHandle<CameraBucket>(MAX_CAMERAS_PER_BUCKET, Camera_BucketContainer, moved)};
 	if (moved) {
 		ActiveCamera = PkeCamera_Get(activeHandle);
 	}
-	auto b = Buckets_GetBucketIndex(cameraHandle_T);
-	auto c = Buckets_GetItemIndex(cameraHandle_T);
-	auto &cam = Camera_BucketContainer.buckets[b].cameras[c];
-	cam.handle = CameraHandle{cameraHandle_T};
+	auto &cam = Camera_BucketContainer.buckets[cameraHandle.bucketIndex].cameras[cameraHandle.itemIndex];
+	cam.handle = cameraHandle;
 	return cam;
 }
 
 PkeCamera *PkeCamera_Get(CameraHandle cameraHandle) {
-	CameraHandle_T cameraHandle_T = static_cast<CameraHandle_T>(cameraHandle);
-	auto b = Buckets_GetBucketIndex(cameraHandle_T);
-	auto c = Buckets_GetItemIndex(cameraHandle_T);
-	return &Camera_BucketContainer.buckets[b].cameras[c];
+	assert(cameraHandle != CameraHandle_MAX);
+	return &Camera_BucketContainer.buckets[cameraHandle.bucketIndex].cameras[cameraHandle.itemIndex];
 }
 
 void PkeCamera_Destroy(CameraHandle cameraHandle) {
-	CameraHandle_T cameraHandle_T = static_cast<CameraHandle_T>(cameraHandle);
-	auto b = Buckets_GetBucketIndex(cameraHandle_T);
-	auto c = Buckets_GetItemIndex(cameraHandle_T);
-	auto &cam = Camera_BucketContainer.buckets[b].cameras[c];
+	assert(cameraHandle != CameraHandle_MAX);
+	auto &cam = Camera_BucketContainer.buckets[cameraHandle.bucketIndex].cameras[cameraHandle.itemIndex];
 	cam.handle = CameraHandle_MAX;
 	cam.pos = glm::vec3(0);
 	cam.rot = glm::quat{};
@@ -57,12 +49,12 @@ void PkeCamera_Destroy(CameraHandle cameraHandle) {
 }
 
 int64_t PkeCamera_GetBucketCount() {
-	return Camera_BucketContainer.bucketCounter + 1;
+	return Camera_BucketContainer.pkeHandle.bucketIndex + 1;
 }
 
 PkeCamera *PkeCamera_GetCameras(int64_t bucketIndex, int64_t &count) {
-	if (Camera_BucketContainer.bucketCounter == bucketIndex) {
-		count = Camera_BucketContainer.itemCounter >> 32;
+	if (Camera_BucketContainer.pkeHandle.bucketIndex == bucketIndex) {
+		count = Camera_BucketContainer.pkeHandle.itemIndex;
 	} else {
 		count = MAX_CAMERAS_PER_BUCKET;
 	}
diff --git a/src/camera.hpp b/src/camera.hpp
index 94923b7..844cb26 100644
--- a/src/camera.hpp
+++ b/src/camera.hpp
@@ -3,6 +3,7 @@
 
 #include "macros.hpp"
 #include "vendor/glm_include.hpp"
+#include "memory-type-defs.hpp"
 
 #include <cstdint>
 
@@ -10,7 +11,9 @@ TypeSafeInt_Const_Expr(PkeCameraType, uint8_t, 0xFF);
 TypeSafeInt_Const_Expr(PkeCameraOrientation, uint8_t, 0xFF);
 TypeSafeInt_Const_Expr(PkeCameraStaleFlags, uint8_t, 0xFF);
 
-TypeSafeInt_H(CameraHandle, uint64_t, UINT64_MAX);
+struct CameraHandle : public PkeHandle {};
+
+constexpr CameraHandle CameraHandle_MAX = CameraHandle{};
 
 const PkeCameraType PKE_CAMERA_TYPE_PERSPECTIVE = PkeCameraType{1 << 0};
 const PkeCameraType PKE_CAMERA_TYPE_ORTHOGONAL  = PkeCameraType{1 << 1};
@@ -24,7 +27,7 @@ const PkeCameraStaleFlags PKE_CAMERA_STALE_ORIENTATION = PkeCameraStaleFlags{1 <
 const PkeCameraStaleFlags PKE_CAMERA_STALE_ALL         = PkeCameraStaleFlags{0xFF};
 
 struct PkeCamera {
-	CameraHandle handle = CameraHandle{0};
+	CameraHandle handle = CameraHandle_MAX;
 	glm::vec3 pos = glm::vec3(0);
 	glm::quat rot = glm::quat{};
 	glm::vec3 target = glm::vec3(0);
diff --git a/src/components.cpp b/src/components.cpp
index 03366d5..587b0c3 100644
--- a/src/components.cpp
+++ b/src/components.cpp
@@ -1,6 +1,3 @@
 
 #include "components.hpp"
 
-TypeSafeInt_B(EntityHandle);
-TypeSafeInt_B(GrBindsHandle);
-TypeSafeInt_B(InstanceHandle);
diff --git a/src/components.hpp b/src/components.hpp
index 4223845..e99481e 100644
--- a/src/components.hpp
+++ b/src/components.hpp
@@ -11,9 +11,13 @@
 
 const uint64_t ECS_UNSET_VAL = 0xFFFFFFFFFFFFFFFF;
 
-TypeSafeInt_H(EntityHandle, uint64_t, ECS_UNSET_VAL);
-TypeSafeInt_H(GrBindsHandle, uint64_t, ECS_UNSET_VAL);
-TypeSafeInt_H(InstanceHandle, uint64_t, ECS_UNSET_VAL);
+struct EntityHandle : public PkeHandle { };
+struct GrBindsHandle : public PkeHandle { };
+struct InstanceHandle : public PkeHandle { };
+
+constexpr EntityHandle EntityHandle_MAX = EntityHandle{};
+constexpr GrBindsHandle GrBindsHandle_MAX = GrBindsHandle{};
+constexpr InstanceHandle InstanceHandle_MAX = InstanceHandle{};
 
 struct Entity {
 	EntityHandle handle = EntityHandle_MAX;
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;
 	}
diff --git a/src/ecs.hpp b/src/ecs.hpp
index 28e52ad..7ac08e2 100644
--- a/src/ecs.hpp
+++ b/src/ecs.hpp
@@ -22,7 +22,7 @@ void ECS_Teardown();
 void ECS_Tick_Early(double delta);
 void ECS_Tick(double delta);
 void ECS_Tick_Late(double delta);
-EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle = EntityHandle{EntityHandle_T{0xFFFFFFFFFFFFFFFF}});
+EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle = EntityHandle{});
 void ECS_MarkForRemoval(EntityHandle entHandle);
 uint64_t ECS_GetEntities_BucketCount();
 Entity *ECS_GetEntities(uint64_t bucketIndex, uint64_t &itemCount);
diff --git a/src/entities.hpp b/src/entities.hpp
index 85feb04..8429d7f 100644
--- a/src/entities.hpp
+++ b/src/entities.hpp
@@ -16,7 +16,7 @@ struct EntityType {
 	const char *modelsDir = nullptr;
 	const char *modelFile = nullptr;
 	const char *entityTypeCode = nullptr;
-	EntityHandle entityHandle = EntityHandle_MAX;
+	EntityHandle entityHandle;
 	GrBindsHandle grBindsHandle = GrBindsHandle_MAX;
 	VkDeviceMemory deviceMemoryVert = VK_NULL_HANDLE;
 	VkDeviceMemory deviceMemoryInst = VK_NULL_HANDLE;
diff --git a/src/game.cpp b/src/game.cpp
index 80cc593..bf30cfe 100644
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -83,7 +83,7 @@ void SerializeCamera(std::ofstream &stream, const PkeCamera &cam) {
 
 void SerializeInstance(std::ofstream &stream, const CompInstance &comp) {
 	char handleStr[19] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
-	snprintf(handleStr, 19, "0x%016lX",static_cast<EntityHandle_T>(comp.entHandle));
+	snprintf(handleStr, 19, "0x%016lX", comp.entHandle.hash);
 	EntityType *et = nullptr;
 	for (long i = 0; i < GlobalEntityTypes.Count(); ++i) {
 		if (GlobalEntityTypes[i].grBindsHandle == comp.grBindsHandle) {
@@ -249,15 +249,13 @@ void ParseInstance(std::ifstream &stream) {
 			auto *broadphaseProxy = compInst.bt.rigidBody->getBroadphaseProxy();
 			broadphaseProxy->m_collisionFilterGroup = static_cast<PhysicsCollision_T>(comp.physicsLayer);
 			broadphaseProxy->m_collisionFilterMask = static_cast<PhysicsCollision_T>(comp.physicsMask);
-			compInst.bt.rigidBody->setUserPointer(reinterpret_cast<void *>(compInst.entHandle));
+			compInst.bt.rigidBody->setUserPointer(reinterpret_cast<void *>(compInst.entHandle.hash));
 			break;
 		}
 		if (strstr(readLine, PKE_FILE_INSTANCE_ENTITY_HANDLE)) {
 			uint64_t prefixLen = strlen(PKE_FILE_INSTANCE_ENTITY_HANDLE);
-			EntityHandle_T handle_t;
-			STR2NUM_ERROR result = str2num(handle_t, readLine + prefixLen);
+			STR2NUM_ERROR result = str2num(comp.entHandle.hash, readLine + prefixLen);
 			assert(result == STR2NUM_ERROR::SUCCESS);
-			comp.entHandle = EntityHandle{handle_t};
 			continue;
 		}
 		if (strstr(readLine, PKE_FILE_INSTANCE_ENTITY_TYPE_CODE)) {
diff --git a/src/memory-type-defs.hpp b/src/memory-type-defs.hpp
index fea8b36..bc45160 100644
--- a/src/memory-type-defs.hpp
+++ b/src/memory-type-defs.hpp
@@ -1,6 +1,22 @@
 #ifndef PKE_MEMORY_TYPE_DEFS_HPP
 #define PKE_MEMORY_TYPE_DEFS_HPP
 
+#include <cstdint>
+
+struct PkeHandle {
+	union {
+		struct {
+			uint32_t bucketIndex;
+			uint32_t itemIndex;
+		};
+		uint64_t hash = 0xFFFFFFFFFFFFFFFF;
+	};
+};
+
+constexpr bool operator==(const PkeHandle &a, const PkeHandle &b) {
+	return a.hash == b.hash;
+}
+
 struct MemBucket;
 
 #endif /* PKE_MEMORY_TYPE_DEFS_HPP */
diff --git a/src/memory.cpp b/src/memory.cpp
index 9d235db..7ad282c 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -344,18 +344,20 @@ void Pke_MemoryFlush() {
 	}
 }
 
-uint64_t Buckets_NewHandle(std::size_t bucketBytes, std::size_t alignment, uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, void*& buckets, bool &moved) {
+PkeHandle Buckets_NewHandle(std::size_t bucketBytes, std::size_t alignment, uint32_t bucketItemCount, uint32_t &bucketIncrementer, uint32_t &bucketCounter, uint32_t &itemCounter, void*& buckets, bool &moved) {
 	moved = false;
-	uint64_t newHandle{itemCounter | bucketCounter};
+	PkeHandle returnValue {
+		.bucketIndex = bucketCounter,
+		.itemIndex = itemCounter,
+	};
 
-	std::size_t calculatedAlignment = alignment < MINIMUM_ALIGNMENT ? MINIMUM_ALIGNMENT : alignment;
-
-	itemCounter += uint64_t{1ULL << 32};
-	if (itemCounter > uint64_t{(bucketItemCount - 1) << 32}) {
+	itemCounter += 1;
+	if (itemCounter > bucketItemCount) {
 		itemCounter = 0ULL;
 		bucketCounter += 1;
 	}
 	if (bucketCounter > bucketIncrementer) {
+		std::size_t calculatedAlignment = alignment < MINIMUM_ALIGNMENT ? MINIMUM_ALIGNMENT : alignment;
 		moved = true;
 		int64_t newIncrement = bucketIncrementer * 1.5;
 		char * newBuckets = reinterpret_cast<char *>(Pke_New(bucketBytes * newIncrement, calculatedAlignment));
@@ -365,7 +367,7 @@ uint64_t Buckets_NewHandle(std::size_t bucketBytes, std::size_t alignment, uint6
 		bucketIncrementer = newIncrement;
 	}
 
-	return newHandle;
+	return returnValue;
 }
 
 void Pke_DebugPrint() {
diff --git a/src/memory.hpp b/src/memory.hpp
index 339d972..41e215f 100644
--- a/src/memory.hpp
+++ b/src/memory.hpp
@@ -19,9 +19,8 @@ extern const std::size_t MAXIMUM_ALIGNMENT;
 
 template<typename T, typename CT>
 struct BucketContainer {
-	uint64_t incrementer = 2;
-	CT bucketCounter{0};
-	CT itemCounter{0};
+	uint32_t incrementer = 2;
+	CT pkeHandle;
 	T *buckets = nullptr;
 };
 
@@ -93,21 +92,23 @@ inline void Pke_Delete(const void *ptr, long count, MemBucket *bucket = nullptr)
 template <typename T, typename CT>
 void Buckets_Init(BucketContainer<T, CT> &bktContainer) {
 	assert(bktContainer.buckets == nullptr && "bucket container already initialized");
+	bktContainer.pkeHandle.hash = 0;
 	bktContainer.buckets = Pke_New<T>(bktContainer.incrementer);
 }
 
-uint64_t Buckets_NewHandle(std::size_t bucketBytes, std::size_t alignment, uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, void*& buckets, bool &moved);
-
-template <typename T> inline uint64_t Buckets_NewHandle(uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, T*& buckets, bool &moved) {
+PkeHandle Buckets_NewHandle(std::size_t bucketBytes, std::size_t alignment, uint32_t bucketItemCount, uint32_t &bucketIncrementer, uint32_t &bucketCounter, uint32_t &itemCounter, void*& buckets, bool &moved);
+template <typename T> inline PkeHandle Buckets_NewHandle(uint32_t bucketItemCount, uint32_t &bucketIncrementer, uint32_t &bucketCounter, uint32_t &itemCounter, T*& buckets, bool &moved) {
 	void *ptr = reinterpret_cast<void *>(buckets);
-	uint64_t handle = Buckets_NewHandle(sizeof(T), alignof(T), bucketItemCount, bucketIncrementer, bucketCounter, itemCounter, ptr, moved);
+	PkeHandle handle = Buckets_NewHandle(sizeof(T), alignof(T), bucketItemCount, bucketIncrementer, bucketCounter, itemCounter, ptr, moved);
 	buckets = reinterpret_cast<T *>(ptr);
 	return handle;
 }
 
-template <typename T, typename CT>
-inline CT Buckets_NewHandle(uint64_t maxBucketItemCount, BucketContainer<T, CT> &bktContainer, bool &moved) {
-	return Buckets_NewHandle<T>(maxBucketItemCount, bktContainer.incrementer, bktContainer.bucketCounter, bktContainer.itemCounter, bktContainer.buckets, moved);
+template <typename T, typename CT = PkeHandle>
+inline CT Buckets_NewHandle(uint32_t maxBucketItemCount, BucketContainer<T, CT> &bktContainer, bool &moved) {
+	CT returnValue{};
+	returnValue.hash = Buckets_NewHandle<T>(maxBucketItemCount, bktContainer.incrementer, bktContainer.pkeHandle.bucketIndex, bktContainer.pkeHandle.itemIndex, bktContainer.buckets, moved).hash;
+	return returnValue;
 }
 
 static inline constexpr uint64_t Buckets_GetBucketIndex(uint64_t handle) {
@@ -121,7 +122,7 @@ static inline constexpr uint64_t Buckets_GetItemIndex(uint64_t handle) {
 template <typename T, typename CT>
 static inline constexpr void Buckets_Destroy(BucketContainer<T, CT> &bktContainer) {
 	if (bktContainer.buckets == nullptr || bktContainer.buckets == CAFE_BABE(T)) return;
-	Pke_Delete<T>(bktContainer.buckets, bktContainer.bucketCounter);
+	Pke_Delete<T>(bktContainer.buckets, bktContainer.pkeHandle.bucketIndex + 1);
 	bktContainer.buckets = CAFE_BABE(T);
 }
 
diff --git a/src/project.cpp b/src/project.cpp
index 741361c..f7200dd 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -61,7 +61,7 @@ void Proj_SerializeProjectSettings(std::ofstream &stream) {
 
 void Proj_SerializeEntityType(std::ofstream &stream, const EntityType &et) {
 	char handleStr[19] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
-	snprintf(handleStr, 19, "0x%016lX",static_cast<EntityHandle_T>(et.entityHandle));
+	snprintf(handleStr, 19, "0x%016lX", et.entityHandle.hash);
 	EntityType e{};
 	if (et.modelsDir != e.modelsDir)
 		stream << PKE_PROJ_FILE_ENTITY_TYPE_MODELS_DIR << et.modelsDir << std::endl;
@@ -169,10 +169,8 @@ void Proj_ParseEntityType(std::ifstream &stream) {
 		}
 		if (strstr(projReadLine, PKE_PROJ_FILE_ENTITY_TYPE_ENTITY_HANDLE)) {
 			uint64_t prefixLen = strlen(PKE_PROJ_FILE_ENTITY_TYPE_ENTITY_HANDLE);
-			EntityHandle_T handle_t;
-			STR2NUM_ERROR result = str2num(handle_t, projReadLine + prefixLen);
+			STR2NUM_ERROR result = str2num(et.entityHandle.hash, projReadLine + prefixLen);
 			assert(result == STR2NUM_ERROR::SUCCESS);
-			et.entityHandle = EntityHandle{handle_t};
 			continue;
 		}
 		if (strstr(projReadLine, PKE_PROJ_FILE_ENTITY_TYPE_STARTING_INSTANCE_COUNT)) {
diff --git a/src/thread_pool.cpp b/src/thread_pool.cpp
index 15cc4e9..48338e5 100644
--- a/src/thread_pool.cpp
+++ b/src/thread_pool.cpp
@@ -4,8 +4,6 @@
 #include <functional>
 #include <future>
 
-TypeSafeInt_B(ThreadPoolHandle);
-
 struct ThreadPool {
 	bool isRunning;
 	bool isPaused;
@@ -18,11 +16,12 @@ struct ThreadPool {
 	MemBucket *bkt = nullptr;
 };
 
+const uint32_t MAX_THREADS_PER_BUCKET = 8;
 struct ThreadBucket {
-	ThreadPool threadPools[8];
+	ThreadPool threadPools[MAX_THREADS_PER_BUCKET];
 };
 
-BucketContainer<ThreadBucket, ThreadPoolHandle_T> ThreadPool_BucketContainer{};
+BucketContainer<ThreadBucket, ThreadPoolHandle> ThreadPool_BucketContainer{};
 
 void ThreadRun(ThreadPool *tp) {
 	std::packaged_task<void()> *j = nullptr;
@@ -118,11 +117,9 @@ ThreadPoolHandle PkeThreads_Init(uint8_t threadCount, uint8_t maxQueueCount, Mem
 	}
 	assert(threadCount > 0);
 	bool moved;
-	ThreadPoolHandle_T newHandle{Buckets_NewHandle(255, ThreadPool_BucketContainer, moved)};
+	ThreadPoolHandle newHandle{Buckets_NewHandle(255, ThreadPool_BucketContainer, moved)};
 
-	auto b = Buckets_GetBucketIndex(newHandle);
-	auto i = Buckets_GetItemIndex(newHandle);
-	auto *tp = &ThreadPool_BucketContainer.buckets[b].threadPools[i];
+	auto *tp = &ThreadPool_BucketContainer.buckets[newHandle.bucketIndex].threadPools[newHandle.itemIndex];
 
 	tp->bkt = bkt;
 	tp->isRunning = true;
@@ -137,22 +134,18 @@ ThreadPoolHandle PkeThreads_Init(uint8_t threadCount, uint8_t maxQueueCount, Mem
 		(*tp->threads)[l] = std::thread(std::bind(ThreadRun, tp));
 	}
 
-	return ThreadPoolHandle{newHandle};
+	return newHandle;
 }
 
 void PkeThreads_Reset(ThreadPoolHandle handle) {
-	ThreadPoolHandle_T handle_T{static_cast<ThreadPoolHandle_T>(handle)};
-	auto b = Buckets_GetBucketIndex(handle_T);
-	auto i = Buckets_GetItemIndex(handle_T);
-	auto *tp = &ThreadPool_BucketContainer.buckets[b].threadPools[i];
+	assert(handle != ThreadPoolHandle_MAX);
+	auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
 	PkeThreads_Reset_Inner(*tp);
 }
 
 bool PkeThreads_Enqueue(ThreadPoolHandle handle, std::packaged_task<void()> job) {
-	ThreadPoolHandle_T handle_T{static_cast<ThreadPoolHandle_T>(handle)};
-	auto b = Buckets_GetBucketIndex(handle_T);
-	auto i = Buckets_GetItemIndex(handle_T);
-	auto *tp = &ThreadPool_BucketContainer.buckets[b].threadPools[i];
+	assert(handle != ThreadPoolHandle_MAX);
+	auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
 
 	auto jobPtr = Pke_New<std::packaged_task<void()>>(tp->bkt);
 	*jobPtr = std::move(job);
@@ -161,37 +154,29 @@ bool PkeThreads_Enqueue(ThreadPoolHandle handle, std::packaged_task<void()> job)
 }
 
 void PkeThreads_Pause(ThreadPoolHandle handle) {
-	ThreadPoolHandle_T handle_T{static_cast<ThreadPoolHandle_T>(handle)};
-	auto b = Buckets_GetBucketIndex(handle_T);
-	auto i = Buckets_GetItemIndex(handle_T);
-	auto *tp = &ThreadPool_BucketContainer.buckets[b].threadPools[i];
+	assert(handle != ThreadPoolHandle_MAX);
+	auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
 
 	PkeThreads_Pause_Inner(*tp);
 }
 
 void PkeThreads_Resume(ThreadPoolHandle handle) {
-	ThreadPoolHandle_T handle_T{static_cast<ThreadPoolHandle_T>(handle)};
-	auto b = Buckets_GetBucketIndex(handle_T);
-	auto i = Buckets_GetItemIndex(handle_T);
-	auto *tp = &ThreadPool_BucketContainer.buckets[b].threadPools[i];
+	assert(handle != ThreadPoolHandle_MAX);
+	auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
 
 	PkeThreads_Resume_Inner(*tp);
 }
 
 void PkeThreads_Shutdown(ThreadPoolHandle handle) {
-	ThreadPoolHandle_T handle_T{static_cast<ThreadPoolHandle_T>(handle)};
-	auto b = Buckets_GetBucketIndex(handle_T);
-	auto i = Buckets_GetItemIndex(handle_T);
-	auto *tp = &ThreadPool_BucketContainer.buckets[b].threadPools[i];
+	assert(handle != ThreadPoolHandle_MAX);
+	auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
 
 	PkeThreads_Shutdown_Inner(*tp);
 }
 
 void PkeThreads_Teardown(ThreadPoolHandle handle) {
-	ThreadPoolHandle_T handle_T{static_cast<ThreadPoolHandle_T>(handle)};
-	auto b = Buckets_GetBucketIndex(handle_T);
-	auto i = Buckets_GetItemIndex(handle_T);
-	auto *tp = &ThreadPool_BucketContainer.buckets[b].threadPools[i];
+	assert(handle != ThreadPoolHandle_MAX);
+	auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
 
 	PkeThreads_Shutdown_Inner(*tp);
 	PkeThreads_Reset_Inner(*tp);
diff --git a/src/thread_pool.hpp b/src/thread_pool.hpp
index 12962dd..dc75f33 100644
--- a/src/thread_pool.hpp
+++ b/src/thread_pool.hpp
@@ -9,7 +9,9 @@
 #include <cstdint>
 #include <future>
 
-TypeSafeInt_H(ThreadPoolHandle, uint64_t, 0xFFFFFFFFFFFFFFFF);
+struct ThreadPoolHandle : public PkeHandle { };
+
+constexpr ThreadPoolHandle ThreadPoolHandle_MAX = ThreadPoolHandle{};
 
 ThreadPoolHandle PkeThreads_Init     (uint8_t threadCount, uint8_t maxQueueCount, MemBucket *bkt = nullptr);
 void             PkeThreads_Reset    (ThreadPoolHandle handle);