add pk.h and major pkmem refactor

Completely replaces the memory module with pkmem
pkmem is a newer implementation of the same
bucket memory structure.

Also includes replacing pkstr.h with pk.h's pkstr

1 files changed, 26 insertions, 28 deletions

diff --git a/src/ecs.cpp b/src/ecs.cpp
index 80a4daf..d6bf8df 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -5,8 +5,6 @@
 #include "bucketed-array.hpp"
 #include "game-settings.hpp"
 #include "math-helpers.hpp"
-#include "memory-type-defs.hpp"
-#include "memory.hpp"
 #include "physics.hpp"
 #include "vendor/glm_include.hpp"
 #include "window.hpp"
@@ -16,16 +14,16 @@
 #include <glm/gtc/type_ptr.hpp>
 
 constexpr struct {
-	const PkeHandleItemIndex_T generics = 256;
-	const PkeHandleItemIndex_T entityPtrs = 256;
-	const PkeHandleItemIndex_T grBinds = 64;
-	const PkeHandleItemIndex_T instances = 256;
+	const pk_handle_item_index_T generics = 256;
+	const pk_handle_item_index_T entityPtrs = 256;
+	const pk_handle_item_index_T grBinds = 64;
+	const pk_handle_item_index_T instances = 256;
 } bcSizes;
 
 struct ECS {
-	MemBucket *bkt = nullptr;
+	struct pk_membucket *bkt = nullptr;
 	struct ECSBucketContainers {
-		BucketContainer<Entity_Base, PkeHandle, 4> generics{};
+		BucketContainer<Entity_Base, pk_handle, 4> generics{};
 		BucketContainer<Entity_Base *, EntityHandle, 4> entityPtrs{};
 		BucketContainer<CompGrBinds, GrBindsHandle, 4> grBinds{};
 		BucketContainer<CompInstance, InstanceHandle, 4> instances{};
@@ -60,7 +58,7 @@ DynArray<Entity_Base *> entitiesYetToBeRemoved{0, nullptr};
 DynArray<Entity_Base *> EntitiesWithExcessInstances{16};
 
 void ECS_GetEntity_Inner(EntityHandle entHandle, Entity_Base*& ent) {
-	assert(ValidateHandle(entHandle, ecs.bc.entityPtrs.pkeHandle, ecs.bc.entityPtrs.limits.itemIndex) == PKE_HANDLE_VALIDATION_VALID);
+	assert(pk_handle_validate(entHandle, ecs.bc.entityPtrs.pkeHandle, ecs.bc.entityPtrs.limits.itemIndex) == PK_HANDLE_VALIDATION_VALID);
 	ent = ecs.bc.entityPtrs.buckets[entHandle.bucketIndex][entHandle.itemIndex];
 }
 
@@ -72,7 +70,7 @@ void ECS_Init() {
 }
 
 Entity_Base *ECS_CreateGenericEntity() {
-	PkeHandle newHandle{Buckets_NewHandle(ecs.bc.generics)};
+	pk_handle newHandle{Buckets_NewHandle(ecs.bc.generics)};
 	return &ecs.bc.generics.buckets[newHandle.bucketIndex][newHandle.itemIndex];
 }
 
@@ -87,7 +85,7 @@ EntityHandle ECS_CreateEntity(Entity_Base *entity, Entity_Base *parentEntity) {
 }
 
 Entity_Base *ECS_GetEntity(EntityHandle handle) {
-	ValidateHandle(handle, ecs.bc.entityPtrs.pkeHandle, ecs.bc.entityPtrs.limits.itemIndex);
+	pk_handle_validate(handle, ecs.bc.entityPtrs.pkeHandle, ecs.bc.entityPtrs.limits.itemIndex);
 	return ecs.bc.entityPtrs.buckets[handle.bucketIndex][handle.itemIndex];
 }
 
@@ -108,9 +106,9 @@ void ECS_Tick_Early(double delta) {
 	entitiesMarkedForRemoval.Resize(0);
 
 	// this has the potential to be slow as balls
-	for (PkeHandleBucketIndex_T b = 0; b <= ecs.bc.entityPtrs.pkeHandle.bucketIndex; ++b) {
-		PkeHandleItemIndex_T entCount = b == ecs.bc.entityPtrs.pkeHandle.bucketIndex ? ecs.bc.entityPtrs.pkeHandle.itemIndex : ecs.bc.entityPtrs.limits.itemIndex;
-		for (PkeHandleItemIndex_T e = 0; e < entCount; ++e) {
+	for (pk_handle_bucket_index_T b = 0; b <= ecs.bc.entityPtrs.pkeHandle.bucketIndex; ++b) {
+		pk_handle_item_index_T entCount = b == ecs.bc.entityPtrs.pkeHandle.bucketIndex ? ecs.bc.entityPtrs.pkeHandle.itemIndex : ecs.bc.entityPtrs.limits.itemIndex;
+		for (pk_handle_item_index_T e = 0; e < entCount; ++e) {
 			Entity_Base *ent = ecs.bc.entityPtrs.buckets[b][e];
 			if (ent->handle == EntityHandle_MAX) continue;
 			Entity_Base *parentEnt = nullptr;
@@ -144,7 +142,7 @@ void ECS_Tick(double delta) {
 	int64_t entityRemovalCount = entitiesYetToBeRemoved.Count();
 	if (physicsTickCount == 0 && entityRemovalCount == 0) return;
 
-	DynArray<updateGrBindsAfter> *updateGrBindsPtr = Pke_New<DynArray<updateGrBindsAfter>>(pkeSettings.mem.bkt);
+	DynArray<updateGrBindsAfter> *updateGrBindsPtr = pk_new<DynArray<updateGrBindsAfter>>(pkeSettings.mem.bkt);
 	DynArray<updateGrBindsAfter> &updateGrBinds = *updateGrBindsPtr;
 	for (long b = 0; b <= ecs.bc.instances.pkeHandle.bucketIndex; ++b) {
 		auto &bkt = ecs.bc.instances.buckets[b];
@@ -179,8 +177,8 @@ void ECS_Tick(double delta) {
 				inst.instanceHandle = InstanceHandle_MAX;
 				inst.isNeedingUpdated = false;
 				BtDynamicsWorld->removeRigidBody(inst.bt.rigidBody);
-				Pke_Delete<btDefaultMotionState>(inst.bt.motionState, MemBkt_Bullet);
-				Pke_Delete<btRigidBody>(inst.bt.rigidBody, MemBkt_Bullet);
+				pk_delete<btDefaultMotionState>(inst.bt.motionState, MemBkt_Bullet);
+				pk_delete<btRigidBody>(inst.bt.rigidBody, MemBkt_Bullet);
 				inst.bt.rigidBody = CAFE_BABE(btRigidBody);
 				inst.bt.motionState = CAFE_BABE(btDefaultMotionState);
 				continue;
@@ -197,10 +195,10 @@ void ECS_Tick(double delta) {
 	}
 
 	if (entityRemovalCount > 0 || updateGrBinds.Count() > 0) {
-		for (PkeHandleBucketIndex_T b = 0; b <= ecs.bc.grBinds.pkeHandle.bucketIndex; ++b) {
+		for (pk_handle_bucket_index_T b = 0; b <= ecs.bc.grBinds.pkeHandle.bucketIndex; ++b) {
 			auto &bkt = ecs.bc.grBinds.buckets[b];
 			long count = ecs.bc.grBinds.pkeHandle.bucketIndex == b ? ecs.bc.grBinds.pkeHandle.itemIndex : ecs.bc.grBinds.limits.itemIndex;
-			for (PkeHandleItemIndex_T i = 0; i < count; ++i) {
+			for (pk_handle_item_index_T i = 0; i < count; ++i) {
 				auto &grBinds = bkt[i];
 				if (grBinds.entHandle == EntityHandle_MAX) {
 					continue;
@@ -241,7 +239,7 @@ struct InstanceBufferCopy {
 };
 void ECS_Tick_Late(double delta) {
 	// using a pointer here avoids calling the destructor when the object goes out of scope
-	DynArray<InstanceBufferCopy> *bufferUpdatesPtr = Pke_New<DynArray<InstanceBufferCopy>>(pkeSettings.mem.bkt);
+	DynArray<InstanceBufferCopy> *bufferUpdatesPtr = pk_new<DynArray<InstanceBufferCopy>>(pkeSettings.mem.bkt);
 	new (bufferUpdatesPtr) DynArray<InstanceBufferCopy>(0, pkeSettings.mem.bkt);
 	DynArray<InstanceBufferCopy> &bufferUpdates = *bufferUpdatesPtr;
 	for (long b = 0; b <= ecs.bc.instances.pkeHandle.bucketIndex; ++b) {
@@ -269,7 +267,7 @@ void ECS_Tick_Late(double delta) {
 					.grBinds = &grBinds,
 				});
 				bfrUpdate = &bufferUpdates[bufferUpdates.Count() - 1];
-				bfrUpdate->chunks = Pke_New<DynArray<InstanceBufferCopyChunk>>(pkeSettings.mem.bkt);
+				bfrUpdate->chunks = pk_new<DynArray<InstanceBufferCopyChunk>>(pkeSettings.mem.bkt);
 				new (bfrUpdate->chunks) DynArray<InstanceBufferCopyChunk>(4, pkeSettings.mem.bkt);
 			}
 
@@ -288,7 +286,7 @@ void ECS_Tick_Late(double delta) {
 				});
 				chunk = &(*bfrUpdate->chunks)[bfrUpdate->chunks->Count() - 1];
 				chunk->dstBufferCopy.dstOffset = sizeof(glm::mat4) * inst.index;
-				chunk->mats = Pke_New<DynArray<glm::mat4>>(pkeSettings.mem.bkt);
+				chunk->mats = pk_new<DynArray<glm::mat4>>(pkeSettings.mem.bkt);
 				new (chunk->mats) DynArray<glm::mat4>(0, pkeSettings.mem.bkt);
 			}
 
@@ -405,15 +403,15 @@ CompGrBinds *ECS_CreateGrBinds(Entity_Base *entity) {
 CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
 	if (grBindsHandle == GrBindsHandle_MAX) return nullptr;
 
-	assert(ValidateHandle(grBindsHandle, ecs.bc.grBinds.pkeHandle, ecs.bc.grBinds.limits.itemIndex) == PKE_HANDLE_VALIDATION_VALID);
+	assert(pk_handle_validate(grBindsHandle, ecs.bc.grBinds.pkeHandle, ecs.bc.grBinds.limits.itemIndex) == PK_HANDLE_VALIDATION_VALID);
 	return &ecs.bc.grBinds.buckets[grBindsHandle.bucketIndex][grBindsHandle.itemIndex];
 }
 
 void ECS_GetGrBinds(Entity_Base *entity, PkeArray<CompGrBinds *> &arr) {
-	for (PkeHandleBucketIndex_T b = 0; b <= ecs.bc.grBinds.pkeHandle.bucketIndex; ++b) {
+	for (pk_handle_bucket_index_T b = 0; b <= ecs.bc.grBinds.pkeHandle.bucketIndex; ++b) {
 		auto &bkt = ecs.bc.grBinds.buckets[b];
 		long itemCount = ecs.bc.grBinds.pkeHandle.bucketIndex == b ? ecs.bc.grBinds.pkeHandle.itemIndex : ecs.bc.grBinds.limits.itemIndex;
-		for (PkeHandleItemIndex_T i = 0; i < itemCount; ++i) {
+		for (pk_handle_item_index_T i = 0; i < itemCount; ++i) {
 			auto &grBinds = bkt[i];
 			if (grBinds.entHandle == entity->handle) {
 				PkeArray_Add(&arr, &grBinds);
@@ -461,17 +459,17 @@ CompInstance *ECS_CreateInstance(Entity_Base *entity, CompGrBinds *entityTypeGrB
 CompInstance *ECS_GetInstance(InstanceHandle instanceHandle ) {
 	if (instanceHandle == InstanceHandle_MAX) return nullptr;
 
-	assert(ValidateHandle(instanceHandle, ecs.bc.instances.pkeHandle, ecs.bc.instances.limits.itemIndex) == PKE_HANDLE_VALIDATION_VALID);
+	assert(pk_handle_validate(instanceHandle, ecs.bc.instances.pkeHandle, ecs.bc.instances.limits.itemIndex) == PK_HANDLE_VALIDATION_VALID);
 	auto *inst = &ecs.bc.instances.buckets[instanceHandle.bucketIndex][instanceHandle.itemIndex];
 
 	return inst;
 }
 
 void ECS_GetInstances(Entity_Base *entity, PkeArray<CompInstance *> &arr) {
-	for (PkeHandleBucketIndex_T b = 0; b <= ecs.bc.instances.pkeHandle.bucketIndex; ++b) {
+	for (pk_handle_bucket_index_T b = 0; b <= ecs.bc.instances.pkeHandle.bucketIndex; ++b) {
 		auto &bkt = ecs.bc.instances.buckets[b];
 		long itemCount = ecs.bc.instances.pkeHandle.bucketIndex == b ? ecs.bc.instances.pkeHandle.itemIndex : ecs.bc.instances.limits.itemIndex;
-		for (PkeHandleItemIndex_T i = 0; i < itemCount; ++i) {
+		for (pk_handle_item_index_T i = 0; i < itemCount; ++i) {
 			auto &inst = bkt[i];
 			if (inst.entHandle == entity->handle) {
 				PkeArray_Add(&arr, &inst);