pke: replace PkeArray with pk_arr_t

12 files changed, 68 insertions, 164 deletions

diff --git a/editor/editor-main.cpp b/editor/editor-main.cpp
index 4e26472..a037ca6 100644
--- a/editor/editor-main.cpp
+++ b/editor/editor-main.cpp
@@ -1,5 +1,6 @@
 #include <csignal>
 
+#include "pk.h"
 #include "arg-handler.hpp"
 #include "plugins.hpp"
 #include "editor.hpp"
@@ -21,12 +22,12 @@ int main(int argc, char *argv[]) {
 	{
 		pkeSettings.isSimulationPaused = true;
 		pkeSettings.isShowingEditor = true;
-		LoadedPkePlugins.Push({
-			.OnInit = PkeEditor_Init,
-			.OnTick = PkeEditor_Tick,
-			.OnTeardown = PkeEditor_Teardown,
-			.OnImGuiRender = PkeEditor_RecordImGui,
-		});
+		PKEPluginInterface itfc;
+		itfc.OnInit = PkeEditor_Init;
+		itfc.OnTick = PkeEditor_Tick;
+		itfc.OnTeardown = PkeEditor_Teardown;
+		itfc.OnImGuiRender = PkeEditor_RecordImGui;
+		pk_arr_append(&LoadedPkePlugins, &itfc);
 	}
 	// run
 	PkeArgs_Parse(argc, argv);
diff --git a/editor/editor.cpp b/editor/editor.cpp
index 14b2777..685d402 100644
--- a/editor/editor.cpp
+++ b/editor/editor.cpp
@@ -2,7 +2,6 @@
 #include "editor.hpp"
 
 #include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
-#include "array.hpp"
 #include "asset-manager.hpp"
 #include "camera.hpp"
 #include "ecs.hpp"
@@ -1662,22 +1661,22 @@ void RecordImGuiSceneEditor() {
 	ImGui::Spacing();
 
 	if (selectedEntity != nullptr) {
-		static PkeArray<CompGrBinds *> entGrBinds;
-		static PkeArray<CompInstance *> entInstances;
+		static pk_arr_t<CompGrBinds *> entGrBinds;
+		static pk_arr_t<CompInstance *> entInstances;
 		static EntityType *entType;
 		bool reset = false;
 		if (entGrBinds.next > 0) {
-			if (entGrBinds.data[0]->entHandle != selectedEntity->entHandle) {
+			if (entGrBinds[0]->entHandle != selectedEntity->entHandle) {
 				reset = true;
 			}
 		} else if (entInstances.next > 0) {
-			if (entInstances.data[0]->entHandle != selectedEntity->entHandle) {
+			if (entInstances[0]->entHandle != selectedEntity->entHandle) {
 				reset = true;
 			}
 		}
 		if (reset) {
-			PkeArray_SoftReset(&entGrBinds);
-			PkeArray_SoftReset(&entInstances);
+			pk_arr_clear(&entGrBinds);
+			pk_arr_clear(&entInstances);
 			entType = nullptr;
 		}
 		if (entGrBinds.next == 0)
@@ -1699,10 +1698,10 @@ void RecordImGuiSceneEditor() {
 		}
 		ImGui::Text("%s: %08x %08x", "Entity Handle: ", selectedEntity->entHandle.bucketIndex, selectedEntity->entHandle.itemIndex);
 		for (int64_t i = 0; i < entGrBinds.next; ++i) {
-			RecordImGui_CompGrBinds(true, entGrBinds.data[i]);
+			RecordImGui_CompGrBinds(true, entGrBinds[i]);
 		}
 		for (int64_t i = 0; i < entInstances.next; ++i) {
-			RecordImGui_CompInstPos(false, entInstances.data[i]);
+			RecordImGui_CompInstPos(false, entInstances[i]);
 		}
 	}
 
diff --git a/src/array.hpp b/src/array.hpp
deleted file mode 100644
index 883d512..0000000
--- a/src/array.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef PKE_ARRAY_HPP
-#define PKE_ARRAY_HPP
-
-#include "pk.h"
-
-#include <cstdint>
-#include <cstring>
-#include <type_traits>
-
-typedef uint32_t PkeArray_Count_T;
-
-struct PkeArray_Base {
-	PkeArray_Count_T next = 0;
-	PkeArray_Count_T reserved = 0;
-	struct pk_membucket *bkt;
-};
-
-template<typename D>
-struct PkeArray : PkeArray_Base {
-	using PkeArray_Base::next;
-	using PkeArray_Base::reserved;
-	using PkeArray_Base::bkt;
-	D *data = nullptr;
-};
-
-template<typename D>
-void PkeArray_HardReset(PkeArray_Base *arrIn) {
-	auto *arr = static_cast<PkeArray<D> *>(arrIn);
-	arr->next = 0;
-	arr->reserved = 0;
-	arr->data = CAFE_BABE(D);
-}
-
-inline void PkeArray_SoftReset(PkeArray_Base *arrIn) {
-	arrIn->next = 0;
-}
-
-template<typename D>
-inline void PkeArray_Add(PkeArray_Base *arrIn, const D &val) {
-	auto *arr = static_cast<PkeArray<D> *>(arrIn);
-	if (arr->reserved == arr->next) {
-		long originalCount = arr->reserved;
-		long diff = 0;
-		if (arr->reserved == 0) {
-			diff = 16;
-			arr->reserved = 16;
-		} else {
-			arr->reserved *= 2.5;
-			diff = arr->reserved - originalCount;
-		}
-		auto *newData = pk_new<D>(arr->reserved, arr->bkt);
-		if constexpr (std::is_trivial<D>::value) {
-			memset(newData + (sizeof(D) * originalCount), 0x00, sizeof(D) * diff);
-		} else {
-			for (int64_t i = originalCount; i < arr->reserved; ++i) {
-				newData[i] = {};
-			}
-		}
-		if (arr->data != nullptr && arr->data != CAFE_BABE(D)) {
-			if constexpr (std::is_trivial<D>::value) {
-				memcpy(newData, arr->data, sizeof(D) * originalCount);
-			} else {
-				for (int64_t i = 0; i < diff; ++i) {
-					newData[i] = arr->data[i];
-				}
-			}
-			pk_delete<D>(arr->data, originalCount, arr->bkt);
-		}
-		arr->data = newData;
-	}
-	if constexpr (std::is_assignable<D&, const D&>::value) {
-		arr->data[arr->next++] = val;
-	} else {
-		memcpy(arr->data[arr->next++], val, sizeof(D));
-	}
-}
-
-template<typename D, typename D2, typename F = bool(const D&, const D2&)>
-inline int64_t PkeArray_FindFirstIndex(PkeArray_Base *arrIn, F fn, const D2 &d2) {
-	auto *arr = static_cast<PkeArray<D> *>(arrIn);
-	for (int64_t i = 0; i < arr->next; ++i) {
-		if (fn(arr->data[i], d2)) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-#endif /* PKE_ARRAY_HPP */
diff --git a/src/ecs.cpp b/src/ecs.cpp
index ecdb1ee..3ab8a80 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -1,7 +1,6 @@
 
 #include "ecs.hpp"
 
-#include "array.hpp"
 #include "bucketed-array.hpp"
 #include "game-settings.hpp"
 #include "math-helpers.hpp"
@@ -408,14 +407,14 @@ CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
 	return &ecs.bc.grBinds.buckets[grBindsHandle.bucketIndex][grBindsHandle.itemIndex];
 }
 
-void ECS_GetGrBinds(Entity_Base *entity, PkeArray<CompGrBinds *> &arr) {
+void ECS_GetGrBinds(Entity_Base *entity, pk_arr_t<CompGrBinds *> &arr) {
 	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 (pk_handle_item_index_T i = 0; i < itemCount; ++i) {
-			auto &grBinds = bkt[i];
-			if (grBinds.entHandle == entity->handle) {
-				PkeArray_Add(&arr, &grBinds);
+			CompGrBinds *grBinds = &bkt[i];
+			if (grBinds->entHandle == entity->handle) {
+				pk_arr_append(&arr, &grBinds);
 			}
 		}
 	}
@@ -466,14 +465,14 @@ CompInstance *ECS_GetInstance(InstanceHandle instanceHandle ) {
 	return inst;
 }
 
-void ECS_GetInstances(Entity_Base *entity, PkeArray<CompInstance *> &arr) {
+void ECS_GetInstances(Entity_Base *entity, pk_arr_t<CompInstance *> &arr) {
 	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 (pk_handle_item_index_T i = 0; i < itemCount; ++i) {
-			auto &inst = bkt[i];
-			if (inst.entHandle == entity->handle) {
-				PkeArray_Add(&arr, &inst);
+			CompInstance *inst = &bkt[i];
+			if (inst->entHandle == entity->handle) {
+				pk_arr_append(&arr, &inst);
 			}
 		}
 	}
diff --git a/src/ecs.hpp b/src/ecs.hpp
index 8cfdb4c..eea7758 100644
--- a/src/ecs.hpp
+++ b/src/ecs.hpp
@@ -1,7 +1,6 @@
 #ifndef PKE_ECS_HPP
 #define PKE_ECS_HPP
 
-#include "array.hpp"
 #include "dynamic-array.hpp"
 #include "pk.h"
 #include "components.hpp"
@@ -24,13 +23,13 @@ void ECS_HandleCollision(CompInstance *lhs, CompInstance *rhs);
 
 CompGrBinds *ECS_CreateGrBinds(Entity_Base *);
 CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle);
-void ECS_GetGrBinds(Entity_Base *entity, PkeArray<CompGrBinds *> &arr);
+void ECS_GetGrBinds(Entity_Base *entity, pk_arr_t<CompGrBinds *> &arr);
 uint64_t ECS_GetGrBinds_BucketCount();
 CompGrBinds *ECS_GetGrBinds(pk_handle_bucket_index_T bucketIndex, pk_handle_item_index_T &itemCount);
 
 CompInstance *ECS_CreateInstance(Entity_Base *entity, CompGrBinds *entityTypeGrBinds);
 CompInstance *ECS_GetInstance(InstanceHandle instanceHandle);
-void ECS_GetInstances(Entity_Base *entity, PkeArray<CompInstance *> &arr);
+void ECS_GetInstances(Entity_Base *entity, pk_arr_t<CompInstance *> &arr);
 void ECS_UpdateInstance(CompInstance *instance, const InstPos &instPos, bool overridePhysics = false);
 uint64_t ECS_GetInstances_BucketCount();
 CompInstance *ECS_GetInstances(pk_handle_bucket_index_T bucketIndex, pk_handle_item_index_T &itemCount);
diff --git a/src/game.cpp b/src/game.cpp
index 3189624..6283d5c 100644
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -1,10 +1,8 @@
 
 #include "game.hpp"
 
-#include "array.hpp"
 #include "camera.hpp"
 #include "components.hpp"
-#include "dynamic-array.hpp"
 #include "ecs.hpp"
 #include "entities.hpp"
 #include "event.hpp"
@@ -42,7 +40,7 @@ struct InstMapping {
 	InstanceHandle newInstHandle;
 	InstPos newInstance{};
 };
-PkeArray<InstMapping> loadFileInstanceMappings{};
+pk_arr_t<InstMapping> loadFileInstanceMappings{};
 
 const char *levelName = "demo-level";
 
@@ -161,8 +159,9 @@ void SerializeInstance(std::ostringstream &stream, const CompInstance &comp) {
 	}
 }
 
-bool FindFirstInstanceHandle(const InstMapping &mapping, const InstanceHandle handle) {
-	return mapping.origHandle == handle;
+bool FindFirstInstanceHandle(void *handle, void *mapping) {
+	InstMapping *inst_mapping = reinterpret_cast<InstMapping *>(mapping);
+	return inst_mapping->origHandle == *reinterpret_cast<InstanceHandle *>(handle);
 }
 void ParseCamera(PkeLevel *level, std::ifstream &stream) {
 	PkeCamera cam{};
@@ -173,10 +172,10 @@ void ParseCamera(PkeLevel *level, std::ifstream &stream) {
 
 			int64_t instanceIndex = -1, targetInstanceIndex = -1;
 
-			instanceIndex = PkeArray_FindFirstIndex<InstMapping, InstanceHandle>(&loadFileInstanceMappings, FindFirstInstanceHandle, instanceHandle);
+			instanceIndex = pk_arr_find_first_index(&loadFileInstanceMappings, &instanceHandle, FindFirstInstanceHandle);
 
 			if (targetInstanceHandle != InstanceHandle_MAX) {
-				targetInstanceIndex = PkeArray_FindFirstIndex<InstMapping, InstanceHandle>(&loadFileInstanceMappings, FindFirstInstanceHandle, targetInstanceHandle);
+				targetInstanceIndex = pk_arr_find_first_index(&loadFileInstanceMappings, &targetInstanceHandle, FindFirstInstanceHandle);
 			}
 
 			InstPos instPos;
@@ -186,7 +185,7 @@ void ParseCamera(PkeLevel *level, std::ifstream &stream) {
 				instPos.scale = btVector3(1.f, 1.f, 1.f);
 				fprintf(stdout, "[ParseCamera] Failed to find instance mapping. Is this an outdated parse?\n");
 			} else {
-				instPos = loadFileInstanceMappings.data[instanceIndex].newInstance;
+				instPos = loadFileInstanceMappings[instanceIndex].newInstance;
 			}
 			auto &rCam = PkeCamera_Register(instPos);
 			rCam.type = cam.type;
@@ -195,7 +194,7 @@ void ParseCamera(PkeLevel *level, std::ifstream &stream) {
 			rCam.phys.targetInstHandle = targetInstanceHandle;
 			PkeLevel_RegisterCamera(level->levelHandle, rCam.camHandle);
 			if (targetInstanceIndex > -1) {
-				PkeCamera_TargetInstance(rCam.camHandle, ECS_GetInstance(loadFileInstanceMappings.data[targetInstanceIndex].newInstHandle));
+				PkeCamera_TargetInstance(rCam.camHandle, ECS_GetInstance(loadFileInstanceMappings[targetInstanceIndex].newInstHandle));
 			}
 			if (rCam.isPrimary == true) {
 				ActiveCamera = &rCam;
@@ -297,12 +296,12 @@ void ParseInstance(Entity_Base *parentEntity, std::ifstream &stream) {
 			}
 			if (mapping.newEntHandle != EntityHandle_MAX) {
 				// TODO this is messy
-				PkeArray<CompInstance *> instances{};
+				pk_arr_t<CompInstance *> instances{};
 				ECS_GetInstances(entity, instances);
 				assert(instances.next > 0);
-				mapping.newInstHandle = instances.data[0]->instanceHandle;
+				mapping.newInstHandle = instances[0]->instanceHandle;
 			}
-			PkeArray_Add(&loadFileInstanceMappings, mapping);
+			pk_arr_append(&loadFileInstanceMappings, &mapping);
 			break;
 		}
 		if (strstr(readLine, PKE_FILE_INSTANCE_ENTITY_HANDLE)) {
@@ -498,7 +497,7 @@ void Game_LoadSceneFile(PkeLevel *level, const char *sceneFilePath) {
 	}
 
 	f.close();
-	PkeArray_SoftReset(&loadFileInstanceMappings);
+	pk_arr_clear(&loadFileInstanceMappings);
 }
 
 const int64_t consoleBufferCount = 30;
@@ -572,8 +571,7 @@ void Game_Tick(double delta) {
 	pke_ui_tick(delta);
 	FontType_Tick(delta);
 
-	const auto pluginCount = LoadedPkePlugins.Count();
-	for (long i = 0; i < pluginCount; ++i) {
+	for (long i = 0; i < LoadedPkePlugins.next; ++i) {
 		if (LoadedPkePlugins[i].OnTick != nullptr) {
 			LoadedPkePlugins[i].OnTick(delta);
 		}
@@ -607,8 +605,7 @@ void Game_Main(PKEWindowProperties windowProps, const char *executablePath) {
 		if (pkeSettings.args.pluginPath != nullptr) {
 			PkePlugin_Load(pkeSettings.args.pluginPath);
 		}
-		const long pluginCount = LoadedPkePlugins.Count();
-		for (long i = 0; i < pluginCount; ++i) {
+		for (long i = 0; i < LoadedPkePlugins.next; ++i) {
 			if (LoadedPkePlugins[i].OnInit != nullptr) {
 				LoadedPkePlugins[i].OnInit();
 			}
@@ -740,8 +737,7 @@ void Game_Main(PKEWindowProperties windowProps, const char *executablePath) {
 #ifndef NDEBUG
 	pk_memory_debug_print();
 #endif
-	const auto pluginCount = LoadedPkePlugins.Count();
-	for (long i = 0; i < pluginCount; ++i) {
+	for (long i = 0; i < LoadedPkePlugins.next; ++i) {
 		if (LoadedPkePlugins[i].OnTeardown) {
 			LoadedPkePlugins[i].OnTeardown();
 		}
diff --git a/src/level-types.hpp b/src/level-types.hpp
index b0abce6..4de0f76 100644
--- a/src/level-types.hpp
+++ b/src/level-types.hpp
@@ -1,14 +1,13 @@
 #ifndef PKE_LEVEL_TYPES_HPP
 #define PKE_LEVEL_TYPES_HPP
 
-#include "array.hpp"
 #include "pk.h"
 #include "camera.hpp"
 #include "components.hpp"
 
 TypeSafeInt_constexpr(LevelHandle, uint16_t, 0xFFFF);
 
-struct LvlCamArr : public PkeArray<CameraHandle> { };
+struct LvlCamArr : public pk_arr_t<CameraHandle>{};
 
 struct PkeLevel : public Entity_Base {
 	struct pk_membucket *bkt = nullptr;
diff --git a/src/level.cpp b/src/level.cpp
index b7d42ec..047363b 100644
--- a/src/level.cpp
+++ b/src/level.cpp
@@ -3,6 +3,7 @@
 
 #include "camera.hpp"
 #include "ecs.hpp"
+#include "pk.h"
 
 LevelHandle nextHandle = LevelHandle{0};
 long levelCount = 0;
@@ -21,7 +22,7 @@ PkeLevel *PkeLevel_Get_Inner(LevelHandle handle) {
 void PkeLevel_Init() {
 	for (long i = 0; i < MAX_LEVEL_COUNT; ++i) {
 		new (&LEVELS[i]) PkeLevel{};
-		PkeArray_HardReset<CameraHandle>(&LEVELS[i].cameras);
+		pk_arr_reset(&LEVELS[i].cameras);
 	}
 }
 
@@ -69,7 +70,7 @@ void PkeLevel_RegisterCamera(LevelHandle levelHandle, CameraHandle cameraHandle)
 	assert(cameraHandle != CameraHandle_MAX);
 	PkeLevel *lvl = PkeLevel_Get_Inner(levelHandle);
 	assert(lvl != nullptr && "Failed to find level by requested LevelHandle");
-	PkeArray_Add(&lvl->cameras, cameraHandle);
+	pk_arr_append(&lvl->cameras, &cameraHandle);
 }
 
 void PkeLevel_Remove(LevelHandle handle) {
@@ -78,9 +79,9 @@ void PkeLevel_Remove(LevelHandle handle) {
 	levelCount -= 1;
 	ECS_MarkForRemoval(lvl);
 	for (long i = 0; i < lvl->cameras.next; ++i) {
-		PkeCamera_Destroy(lvl->cameras.data[i]);
+		PkeCamera_Destroy(lvl->cameras[i]);
 	}
-	PkeArray_HardReset<CameraHandle>(&lvl->cameras);
+	pk_arr_reset(&lvl->cameras);
 	pk_bucket_reset(lvl->bkt);
 	lvl->levelHandle = LevelHandle_MAX;
 }
diff --git a/src/physics.cpp b/src/physics.cpp
index d939e21..30620fa 100644
--- a/src/physics.cpp
+++ b/src/physics.cpp
@@ -5,6 +5,7 @@
 #include "dynamic-array.hpp"
 #include "ecs.hpp"
 #include "game-settings.hpp"
+#include "pk.h"
 
 #include <LinearMath/btAlignedAllocator.h>
 #include <btBulletDynamicsCommon.h>
@@ -30,7 +31,7 @@ btConstraintSolver *btSolver = nullptr;
 struct EntityCollision {
 	CompInstance *a, *b;
 };
-PkeArray<EntityCollision> collisionsThisTick{};
+pk_arr_t<EntityCollision> collisionsThisTick{};
 
 void *pke_btAlignedAllocFunc(size_t size, int alignment) {
 	void *ptr = pk_new_bkt(size, alignment, MemBkt_Bullet);
@@ -74,6 +75,7 @@ void pke_btFreeFunc(void *memBlock) {
 struct CollisionHandlerStruct : public btOverlapFilterCallback {
 	~CollisionHandlerStruct() override {}
 	bool needBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) const override {
+		EntityCollision col;
 		auto collided = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) |
 			(proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
 		if (collided) {
@@ -83,10 +85,9 @@ struct CollisionHandlerStruct : public btOverlapFilterCallback {
 				CompInstance *ent0 = reinterpret_cast<CompInstance *>(col0->getUserPointer());
 				CompInstance *ent1 = reinterpret_cast<CompInstance *>(col1->getUserPointer());
 				if (ent0 != nullptr && ent1 != nullptr) {
-					PkeArray_Add<EntityCollision>(&collisionsThisTick, {
-						.a = ent0,
-						.b = ent1,
-					});
+					col.a = ent0;
+					col.b = ent1;
+					pk_arr_append(&collisionsThisTick, &col);
 				}
 			}
 		}
@@ -123,10 +124,10 @@ void Physics_Init() {
 int32_t Physics_Tick(double delta) {
 	if (pkeSettings.isSimulationPaused == true)
 		return 0;
-	PkeArray_SoftReset(&collisionsThisTick);
+	pk_arr_clear(&collisionsThisTick);
 	auto tickCount = BtDynamicsWorld->stepSimulation(delta, 1);
 	for (long i = 0; i < collisionsThisTick.next; ++i) {
-		ECS_HandleCollision(collisionsThisTick.data[i].a, collisionsThisTick.data[i].b);
+		ECS_HandleCollision(collisionsThisTick[i].a, collisionsThisTick[i].b);
 	}
 	return tickCount;
 }
diff --git a/src/plugins.cpp b/src/plugins.cpp
index b6acc63..c7bd7c8 100644
--- a/src/plugins.cpp
+++ b/src/plugins.cpp
@@ -1,7 +1,6 @@
 
 #include "plugins.hpp"
 
-#include "array.hpp"
 #include "pk.h"
 
 #include <cassert>
@@ -14,9 +13,8 @@
 	#include <dlfcn.h>
 #endif
 
-DynArray<PKEPluginInterface> LoadedPkePlugins;
-PkeArray<PkeCallback> pkePluginCallbacks;
-PkeArray<CallbackSignature> sortedSignatures;
+pk_arr_t<PKEPluginInterface> LoadedPkePlugins;
+pk_arr_t<PkeCallback> pkePluginCallbacks;
 
 void PkePlugin_Load(const char *path) {
 	if (path == nullptr || path == CAFE_BABE(void)) {
@@ -36,13 +34,13 @@ void PkePlugin_Load(const char *path) {
 		return;
 	}
 	interface->pluginHandle = extension;
-	LoadedPkePlugins.Push(*interface);
+	pk_arr_append(&LoadedPkePlugins, interface);
 }
 
 PkeCallback *PkePlugin_FindSignature(const CallbackSignature &sig) {
 	for (long i = 0; i < pkePluginCallbacks.next; ++i) {
-		if (strncmp(sig, pkePluginCallbacks.data[i].name, 16) == 0) {
-			return &pkePluginCallbacks.data[i];
+		if (strncmp(sig, pkePluginCallbacks[i].name, 16) == 0) {
+			return &pkePluginCallbacks[i];
 		}
 	}
 	return nullptr;
@@ -66,12 +64,13 @@ int pstrncmp(const void* a, const void* b)
 	return strncmp(static_cast<const CallbackSignature *>(a)[0], static_cast<const CallbackSignature *>(b)[0], 16);
 }
 CallbackSignature *PkePlugin_GetSortedSignatures(long &count) {
+	static pk_arr_t<CallbackSignature> sortedSignatures;
 	if (sortedSignatures.next != pkePluginCallbacks.next) {
 		while (sortedSignatures.next != pkePluginCallbacks.next) {
-			PkeArray_Add(&sortedSignatures, pkePluginCallbacks.data[sortedSignatures.next].name);
+			pk_arr_append(&sortedSignatures, pkePluginCallbacks[sortedSignatures.next].name);
 		}
 		qsort(sortedSignatures.data, sortedSignatures.next, sizeof(CallbackSignature), pstrncmp);
 	}
 	count = sortedSignatures.next;
-	return sortedSignatures.data;
+	return &sortedSignatures[0];
 }
diff --git a/src/plugins.hpp b/src/plugins.hpp
index 697fbf1..360f692 100644
--- a/src/plugins.hpp
+++ b/src/plugins.hpp
@@ -1,12 +1,11 @@
 #ifndef PKE_PLUGINS_HPP
 #define PKE_PLUGINS_HPP
 
-#include "array.hpp"
-#include "dynamic-array.hpp"
+#include "pk.h"
 #include "plugin-types.hpp"
 
-extern DynArray<PKEPluginInterface> LoadedPkePlugins;
-extern PkeArray<PkeCallback> pkePluginCallbacks;
+extern pk_arr_t<PKEPluginInterface> LoadedPkePlugins;
+extern pk_arr_t<PkeCallback> pkePluginCallbacks;
 
 void PkePlugin_Load(const char *path);
 PkeCallback *PkePlugin_FindSignature(const CallbackSignature &sig);
diff --git a/src/window.cpp b/src/window.cpp
index 3d2f492..24dc1bf 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -3299,19 +3299,19 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 	vkCmdDraw(commandBuffer, 3, 1, 0, 0);
 
 	// ImGui
-	const auto plugin_count = LoadedPkePlugins.Count();
 	bool any = false;
-	for (long i = 0; i < plugin_count; ++i) {
+	for (long i = 0; i < LoadedPkePlugins.next; ++i) {
 		if (LoadedPkePlugins[i].OnImGuiRender != nullptr) {
 			any = true;
 			break;
 		}
 	}
+	// TODO move this 'any' check to happen on plugin load and store in global?
 	if (any) {
 		ImGui_ImplVulkan_NewFrame();
 		ImGui_ImplGlfw_NewFrame();
 		ImGui::NewFrame();
-		for (long i = 0; i < plugin_count; ++i) {
+		for (long i = 0; i < LoadedPkePlugins.next; ++i) {
 			if (LoadedPkePlugins[i].OnImGuiRender != nullptr) {
 				LoadedPkePlugins[i].OnImGuiRender();
 			}