pke: use new pk_iter_t from pk.h

8 files changed, 210 insertions, 163 deletions

diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp
index 519698e..0ff1cf2 100644
--- a/src/asset-manager.cpp
+++ b/src/asset-manager.cpp
@@ -218,10 +218,12 @@ pk_bkt_arr *AM_GetAssets() {
 }
 
 void AM_DebugPrint() {
+	bool b;
+	pk_iter_t<Asset> iter_asset{};
 	fprintf(stdout, "Asset Manager printout:\n");
-	auto asset_iter_fn = [](void *user_data, void *arr_obj_data) {
-		(void)user_data;
-		Asset &asset = *reinterpret_cast<Asset *>(arr_obj_data);
+	b = pk_bkt_arr_iter_begin(&asset_mstr.bc, &iter_asset);
+	while (b == true) {
+		Asset &asset = *iter_asset;
 		printf("-Asset: 0x%.08X 0x%.08X\n", asset.handle.b, asset.handle.i);
 		printf("\tkey:  %.16s\n", asset.key);
 		if (asset.basePath != nullptr) {
@@ -234,28 +236,33 @@ void AM_DebugPrint() {
 		printf("\tfuture: %i\n", asset.future.valid());
 		printf("\treferenceCount: %i\n", asset.referenceCount);
 		printf("\tAssetLoadingState: %hhu\n", static_cast<AssetLoadingState_T>(asset.state));
-	};
-	pk_bkt_arr_iterate(&asset_mstr.bc, asset_iter_fn, NULL);
+		b = pk_bkt_arr_iter_increment(&asset_mstr.bc, &iter_asset);
+	}
 }
 
 void AM_GC() {
-	auto asset_iter_fn = [](void *user_data, void *arr_obj_data) {
-		(void)user_data;
-		Asset &asset = *reinterpret_cast<Asset *>(arr_obj_data);
+	bool b;
+	pk_iter_t<Asset> iter_asset{};
+	b = pk_bkt_arr_iter_begin(&asset_mstr.bc, &iter_asset);
+	while (b == true) {
+		Asset &asset = *iter_asset;
 		if (PK_HAS_FLAG(asset.flags, PKE_ASSET_FLAGS_MEM_STATIC)) {
 			fprintf(stdout, "[AM_GC] Asset '%.16s' is static, skipping.\n", asset.key);
-			return;
+			b = pk_bkt_arr_iter_increment(&asset_mstr.bc, &iter_asset);
+			continue;
 		}
 		switch (asset.state) {
 			case PKE_ASSET_LOADING_STATE_LOADING:
 				fprintf(stdout, "[AM_GC] Asset '%.16s' is still loading.\n", asset.key);
-				break;
+				b = pk_bkt_arr_iter_increment(&asset_mstr.bc, &iter_asset);
+				continue;
 			default:
 				void(0);
 		}
 		if (asset.referenceCount > 0) {
 			fprintf(stdout, "[AM_GC] Asset '%.16s' still in use, count: %i\n", asset.key, asset.referenceCount);
-			return;
+			b = pk_bkt_arr_iter_increment(&asset_mstr.bc, &iter_asset);
+			continue;
 		}
 		if (asset.ptr != nullptr && asset.ptr != CAFE_BABE(void)) {
 			pk_delete_base(asset.ptr, asset.size);
@@ -265,8 +272,8 @@ void AM_GC() {
 		asset.ptr = CAFE_BABE(void);
 		new (&asset.future) std::future<void>{};
 		asset.state = PKE_ASSET_LOADING_STATE_UNLOADED;
-	};
-	pk_bkt_arr_iterate(&asset_mstr.bc, asset_iter_fn, NULL);
+		b = pk_bkt_arr_iter_increment(&asset_mstr.bc, &iter_asset);
+	}
 }
 
 void AM_Teardown() {
diff --git a/src/camera.cpp b/src/camera.cpp
index 134e9f7..8635211 100644
--- a/src/camera.cpp
+++ b/src/camera.cpp
@@ -142,18 +142,20 @@ void PkeCamera_UntargetInstance(CameraHandle cameraHandle) {
 }
 
 void PkeCamera_SetPrimary(CameraHandle cameraHandle) {
+	bool b;
+	pk_iter_t<PkeCamera> iter_cam{};
 	assert(cameraHandle != CameraHandle_MAX);
-	auto check_stale = [](void *user_data, void *cam_ptr) {
-		CameraHandle handle = *reinterpret_cast<CameraHandle*>(user_data);
-		auto &cam = *reinterpret_cast<PkeCamera*>(cam_ptr);
+
+	b = pk_bkt_arr_iter_begin(&cam_mstr.bktc_cameras, &iter_cam);
+	while (b == true) {
 		// TODO 2025-05-28 JCB
 		// There was some speculative scene filtering happening here.
 		// I removed it because it was comparing entity parents and I don't
 		//  think that is accurate.
 		// Instead, should be a per-viewport or per-world check?
-		cam.isPrimary = (cam.camHandle == handle);
-	};
-	pk_bkt_arr_iterate(&cam_mstr.bktc_cameras, check_stale, &cameraHandle);
+		iter_cam->isPrimary = iter_cam->camHandle == cameraHandle;
+		b = pk_bkt_arr_iter_increment(&cam_mstr.bktc_cameras, &iter_cam);
+	}
 }
 
 void PkeCamera_Destroy(CameraHandle cameraHandle) {
@@ -217,25 +219,22 @@ void PkeCamera_Tick(double delta) {
 	 *  See the camera serializer for more.
 	 */
 	(void)delta;
-	auto check_stale = [](void *user_data, void *cam_ptr) {
-		(void)user_data;
-		auto &cam = *reinterpret_cast<PkeCamera*>(cam_ptr);
-		/* 2025-05-28 JCB - if you see me, delete me, i wasn't needed
-		if (cam.handle == EntityHandle_MAX || cam.phys.instHandle == InstanceHandle_MAX) {
-			return;
-		}
-		*/
-		CompInstance *inst = ECS_GetInstance(cam.phys.instHandle);
+	bool b;
+	pk_iter_t<PkeCamera> iter_cam{};
+	b = pk_bkt_arr_iter_begin(&cam_mstr.bktc_cameras, &iter_cam);
+	while (b == true) {
+		CompInstance *inst = ECS_GetInstance(iter_cam->phys.instHandle);
 		assert(inst != nullptr);
 		if (inst->isNeedingUpdated == true) {
-			cam.stale = cam.stale | PKE_CAMERA_STALE_POSROT;
+			iter_cam->stale = iter_cam->stale | PKE_CAMERA_STALE_POSROT;
 			inst->isNeedingUpdated = false;
 		}
-		if (cam.phys.target_inst_uuid == pk_uuid_zed) {
-			return;
+		if (iter_cam->phys.target_inst_uuid == pk_uuid_zed) {
+			b = pk_bkt_arr_iter_increment(&cam_mstr.bktc_cameras, &iter_cam);
+			continue;
 		}
-		cam.stale = cam.stale | PKE_CAMERA_STALE_POSROT;
+		iter_cam->stale = iter_cam->stale | PKE_CAMERA_STALE_POSROT;
+		b = pk_bkt_arr_iter_increment(&cam_mstr.bktc_cameras, &iter_cam);
 	};
-	pk_bkt_arr_iterate(&cam_mstr.bktc_cameras, check_stale, NULL);
 }
 
diff --git a/src/ecs.cpp b/src/ecs.cpp
index 839c68e..cdf125b 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -129,6 +129,8 @@ pk_bkt_arr *ECS_GetEntities() {
 void ECS_Tick_Early(double delta) {
 	// these reserves might happen 1 tick early, but that's fine
 	(void)delta;
+	bool b;
+	pk_iter_t<Entity_Base> iter_ent{};
 	pk_arr_clear(&EntitiesToBeRemoved);
 	bool shouldRun = entitiesMarkedForRemoval.next > 0 || EntitiesToBeRemoved.next > 0 || entitiesYetToBeRemoved.next > 0;
 	pk_arr_reserve(&entitiesYetToBeRemoved, entitiesMarkedForRemoval.reserved);
@@ -151,26 +153,25 @@ void ECS_Tick_Early(double delta) {
 	//  That may or may not have implications about this logic.
 	//  Might need to do several passes?
 
-	type_bkt_arr_entities::FN_Iter iter_tmpln;
-	iter_tmpln.func = [](Entity_Base **ent_ptr) {
-		Entity_Base *ent = *ent_ptr;
+	b = pk_bkt_arr_iter_begin(&ecs.bc.entityPtrs, &iter_ent);
+	while (b == true) {
 		Entity_Base *parentEnt = nullptr;
-		if (ent->parentHandle != EntityHandle_MAX) {
-			parentEnt = ecs.bc.entityPtrs[ent->parentHandle];
+		if (iter_ent->parentHandle != EntityHandle_MAX) {
+			parentEnt = ecs.bc.entityPtrs[iter_ent->parentHandle];
 		}
-		if (ent->isMarkedForRemoval) {
-			pk_arr_append_t(&entitiesYetToBeRemoved, ent);
-			ent->handle = EntityHandle_MAX;
-			ent->parentHandle = EntityHandle_MAX;
-			ent->isMarkedForRemoval = false;
-		} else if (pk_arr_find_first_index(&EntitiesToBeRemoved, ent, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
-			ent->isMarkedForRemoval = true;
+		if (iter_ent->isMarkedForRemoval) {
+			pk_arr_append_t<Entity_Base*>(&entitiesYetToBeRemoved, iter_ent);
+			iter_ent->handle = EntityHandle_MAX;
+			iter_ent->parentHandle = EntityHandle_MAX;
+			iter_ent->isMarkedForRemoval = false;
+		} else if (pk_arr_find_first_index(&EntitiesToBeRemoved, iter_ent, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
+			iter_ent->isMarkedForRemoval = true;
 		} else if (parentEnt != nullptr && pk_arr_find_first_index(&EntitiesToBeRemoved, parentEnt, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
-			ent->isMarkedForRemoval = true;
-			pk_arr_append_t(&EntitiesToBeRemoved, ent);
+			iter_ent->isMarkedForRemoval = true;
+			pk_arr_append_t<Entity_Base*>(&EntitiesToBeRemoved, iter_ent);
 		}
-	};
-	pk_bkt_arr_iterate(&ecs.bc.entityPtrs, type_bkt_arr_entities::FN_Iter::invoke, &iter_tmpln);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.entityPtrs, &iter_ent);
+	}
 }
 
 struct updateGrBindsAfter {
@@ -185,6 +186,10 @@ bool ecs_pk_arr_find_by_gr_binds_handle(void *search_val, void *list_val) {
 	return search_handle == list_ref.grBindsHandle;
 }
 void ECS_Tick(double delta) {
+	bool b;
+	pk_iter_t<CompInstance> iter_inst{};
+	pk_iter_t<CompGrBinds> iter_grbinds{};
+	pk_iter_t<pke_component_event> iter_comp_ev{};
 	int32_t physicsTickCount = Physics_Tick(delta);
 
 	uint32_t entityRemovalCount = entitiesYetToBeRemoved.next;
@@ -200,8 +205,9 @@ void ECS_Tick(double delta) {
 	pk_arr_t<updateGrBindsAfter> updateGrBinds;
 	updateGrBinds.bkt = pkeSettings.mem_bkt.game_transient;
 
-	inst_iter_cb.func = [entityRemovalCount, &updateGrBinds](CompInstance *arr_obj_data) {
-		CompInstance &inst = *arr_obj_data;
+	b = pk_bkt_arr_iter_begin(&ecs.bc.instances, &iter_inst);
+	while (b == true) {
+		CompInstance &inst = *iter_inst;
 		auto activationState = inst.bt.rigidBody->getActivationState();
 		if (activationState == ISLAND_SLEEPING || activationState == DISABLE_SIMULATION || activationState == WANTS_DEACTIVATION) {
 			// no-op
@@ -235,7 +241,8 @@ void ECS_Tick(double delta) {
 			pk_delete<btRigidBody>(inst.bt.rigidBody, MemBkt_Bullet);
 			inst.bt.rigidBody = CAFE_BABE(btRigidBody);
 			inst.bt.motionState = CAFE_BABE(btDefaultMotionState);
-			return;
+			b = pk_bkt_arr_iter_increment(&ecs.bc.instances, &iter_inst);
+			continue;
 		}
 		if (updateGrBinds.next > 0 && inst.instanceHandle != InstanceHandle_MAX) {
 			uint32_t afterIndex = pk_arr_find_first_index(&updateGrBinds, &inst.grBindsHandle, ecs_pk_arr_find_by_gr_binds_handle);
@@ -245,11 +252,12 @@ void ECS_Tick(double delta) {
 				inst.isNeedingUpdated = true;
 			}
 		}
-	};
-	pk_bkt_arr_iterate(&ecs.bc.instances, &InstIterFn::invoke, &inst_iter_cb);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.instances, &iter_inst);
+	}
 
-	grbinds_iter_cb.func = [&updateGrBinds](CompGrBinds *arr_obj_data) {
-		CompGrBinds &grBinds = *arr_obj_data;
+	b = pk_bkt_arr_iter_begin(&ecs.bc.grBinds, &iter_grbinds);
+	while ((entityRemovalCount > 0 || updateGrBinds.next > 0) && b == true) {
+		CompGrBinds &grBinds = *iter_grbinds;
 		uint32_t afterIndex = pk_arr_find_first_index(&updateGrBinds, &grBinds.grBindsHandle, ecs_pk_arr_find_by_gr_binds_handle);
 		Entity_Base *ent = ecs.bc.entityPtrs[grBinds.entHandle];
 		if (pk_arr_find_first_index(&entitiesYetToBeRemoved, ent, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
@@ -268,22 +276,18 @@ void ECS_Tick(double delta) {
 			auto &after = updateGrBinds[afterIndex];
 			grBinds.instanceCounter -= after.count;
 		}
-	};
-	if (entityRemovalCount > 0 || updateGrBinds.next > 0) {
-		pk_bkt_arr_iterate(&ecs.bc.grBinds, &GrBindsIterFn::invoke, &grbinds_iter_cb);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.grBinds, &iter_grbinds);
 	}
 
-	comp_ev_mgr_iter_cb.func = [](pke_component_event *arr_obj_data) {
-		Entity_Base *ent = ecs.bc.entityPtrs[arr_obj_data->entity_handle];
+	b = pk_bkt_arr_iter_begin(&ecs.bc.ev_mgrs, &iter_comp_ev);
+	while (entityRemovalCount > 0 && b == true) {
+		Entity_Base *ent = ecs.bc.entityPtrs[iter_comp_ev->entity_handle];
 		if (pk_arr_find_first_index(&entitiesYetToBeRemoved, ent, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
-			pk_ev_destroy_mgr(arr_obj_data->ev_mgr_id);
-			pk_bkt_arr_free_handle(&ecs.bc.ev_mgrs, arr_obj_data->pke_event_handle);
+			pk_ev_destroy_mgr(iter_comp_ev->ev_mgr_id);
+			pk_bkt_arr_free_handle(&ecs.bc.ev_mgrs, iter_comp_ev->pke_event_handle);
 		}
-	};
-	if (entityRemovalCount > 0) {
-		pk_bkt_arr_iterate(&ecs.bc.ev_mgrs, &CompEvMgrIterFn::invoke, &comp_ev_mgr_iter_cb);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.ev_mgrs, &iter_comp_ev);
 	}
-
 }
 
 struct InstanceBufferCopyChunk {
@@ -298,6 +302,8 @@ struct InstanceBufferCopy {
 	pk_arr_t<InstanceBufferCopyChunk> chunks;
 };
 void ECS_Tick_Late(double delta) {
+	bool b;
+	pk_iter_t<CompInstance> iter_inst{};
 	// using a pointer here avoids calling the destructor when the object goes out of scope
 	(void)delta;
 	PKVK_TmpBufferDetails tmpBufferDetails{};
@@ -307,14 +313,21 @@ void ECS_Tick_Late(double delta) {
 	using InstIterFn = pk_tmpln_1<void, CompInstance*, void*>;
 	InstIterFn inst_iter_cb{};
 
-	inst_iter_cb.func = [&bufferUpdates](CompInstance *arr_obj_data) {
-		CompInstance &inst = *arr_obj_data;
-		if (inst.isNeedingUpdated == false)
-			return;
-		if (inst.entHandle == EntityHandle_MAX)
-			return;
-		if (inst.grBindsHandle == GrBindsHandle_MAX)
-			return;
+	b = pk_bkt_arr_iter_begin(&ecs.bc.instances, &iter_inst);
+	while (b == true) {
+		CompInstance &inst = *iter_inst;
+		if (inst.isNeedingUpdated == false) {
+			b = pk_bkt_arr_iter_increment(&ecs.bc.instances, &iter_inst);
+			continue;
+		}
+		if (inst.entHandle == EntityHandle_MAX) {
+			b = pk_bkt_arr_iter_increment(&ecs.bc.instances, &iter_inst);
+			continue;
+		}
+		if (inst.grBindsHandle == GrBindsHandle_MAX) {
+			b = pk_bkt_arr_iter_increment(&ecs.bc.instances, &iter_inst);
+			continue;
+		}
 
 		auto &grBinds = ecs.bc.grBinds[inst.grBindsHandle];
 
@@ -365,8 +378,8 @@ void ECS_Tick_Late(double delta) {
 		pk_arr_append_t(&chunk->mats, glm::scale(glmMat_posRot, scale));
 		bfrUpdate->runningSize += sizeof(glm::mat4);
 		inst.isNeedingUpdated = false;
-	};
-	pk_bkt_arr_iterate(&ecs.bc.instances, &InstIterFn::invoke, &inst_iter_cb);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.instances, &iter_inst);
+	}
 
 	while (bufferUpdates.next > 0) {
 		InstanceBufferCopy &ibc = bufferUpdates[bufferUpdates.next - 1];
@@ -469,21 +482,21 @@ CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
 }
 
 void ECS_GetGrBinds(Entity_Base *entity, pk_arr_t<CompGrBinds *> &arr) {
+	bool b;
+	pk_iter_t<CompGrBinds> iter_grbinds{};
 	if (entity == nullptr) return;
 
 	// 2025-05-29 JCB PERF
 	//  There's gotta be a better way to do this than looping ALL GrBinds...
 	//  Let's leave it until it shows up in performance tests.
 
-	using GrBindsIterFn = pk_tmpln_1<void, CompGrBinds *, void *>;
-	GrBindsIterFn gr_binds_iter_cb{};
-
-	gr_binds_iter_cb.func = [&entity, &arr](CompGrBinds *arr_obj_data) {
-		if (arr_obj_data->entHandle == entity->handle) {
-			pk_arr_append(&arr, &arr_obj_data);
+	b = pk_bkt_arr_iter_begin(&ecs.bc.grBinds, &iter_grbinds);
+	while (b == true) {
+		if (iter_grbinds->entHandle == entity->handle) {
+			pk_arr_append_t<CompGrBinds*>(&arr, iter_grbinds);
 		}
-	};
-	pk_bkt_arr_iterate(&ecs.bc.grBinds, &GrBindsIterFn::invoke, &gr_binds_iter_cb);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.grBinds, &iter_grbinds);
+	}
 }
 
 pk_bkt_arr *ECS_GetGrBinds() {
@@ -545,21 +558,21 @@ CompInstance *ECS_GetInstance(InstanceHandle instanceHandle ) {
 }
 
 void ECS_GetInstances(Entity_Base *entity, pk_arr_t<CompInstance *> &arr) {
+	bool b;
+	pk_iter_t<CompInstance> iter_inst{};
 	if (entity == nullptr) return;
 
 	// 2025-05-29 JCB PERF
 	//  There's gotta be a better way to do this than looping ALL GrBinds...
 	//  Let's leave it until it shows up in performance tests.
 
-	using InstIterFn = pk_tmpln_1<void, CompInstance *, void *>;
-	InstIterFn inst_iter_cb{};
-
-	inst_iter_cb.func = [&entity, &arr](CompInstance *arr_obj_data) {
-		if (arr_obj_data->entHandle == entity->handle) {
-			pk_arr_append(&arr, &arr_obj_data);
+	b = pk_bkt_arr_iter_begin(&ecs.bc.instances, &iter_inst);
+	while (b == true) {
+		if (iter_inst->entHandle == entity->handle) {
+			pk_arr_append_t<CompInstance*>(&arr, iter_inst);
 		}
-	};
-	pk_bkt_arr_iterate(&ecs.bc.instances, &InstIterFn::invoke, &inst_iter_cb);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.instances, &iter_inst);
+	}
 }
 
 void ECS_UpdateInstance(CompInstance *instance, const InstPos &instPos, bool overridePhysics) {
@@ -609,21 +622,21 @@ pke_component_event *ECS_GetEv(PkeEventHandle handle) {
 }
 
 void ECS_GetEvs(Entity_Base *entity, pk_arr_t<pke_component_event *> &arr) {
+	bool b;
+	pk_iter_t<pke_component_event> iter_comp_ev{};
 	if (entity == nullptr) return;
 
 	// 2025-05-29 JCB PERF
 	//  There's gotta be a better way to do this than looping
 	//  Let's leave it until it shows up in performance tests.
 
-	using CompEvMgrIterFn = pk_tmpln_1<void, pke_component_event *, void *>;
-	CompEvMgrIterFn inst_iter_cb{};
-
-	inst_iter_cb.func = [&entity, &arr](pke_component_event *arr_obj_data) {
-		if (arr_obj_data->entity_handle == entity->handle) {
-			pk_arr_append_t<pke_component_event*>(&arr, arr_obj_data);
+	b = pk_bkt_arr_iter_begin(&ecs.bc.ev_mgrs, &iter_comp_ev);
+	while(b == true) {
+		if (iter_comp_ev->entity_handle == entity->handle) {
+			pk_arr_append_t<pke_component_event*>(&arr, iter_comp_ev);
 		}
-	};
-	pk_bkt_arr_iterate(&ecs.bc.ev_mgrs, &CompEvMgrIterFn::invoke, &inst_iter_cb);
+		b = pk_bkt_arr_iter_increment(&ecs.bc.ev_mgrs, &iter_comp_ev);
+	}
 }
 
 pk_bkt_arr *ECS_GetEvs() {
diff --git a/src/entities.cpp b/src/entities.cpp
index 8b37cbc..8b39cea 100644
--- a/src/entities.cpp
+++ b/src/entities.cpp
@@ -1412,18 +1412,21 @@ pk_bkt_arr *EntityType_GetEntityTypes() {
 }
 
 void EntityType_Teardown() {
-	auto et_iter_cb = [](void *user_data, void *arr_obj_data) {
-		(void)user_data;
-		EntityType &et = *reinterpret_cast<EntityType *>(arr_obj_data);
-		if (et.modelAssetKey[0] == '\0') return;
+	bool b;
+	pk_iter_t<EntityType> iter_ent_type{};
+	b = pk_bkt_arr_iter_end(&et_mstr.bc, &iter_ent_type);
+	while (b == true) {
+		if (iter_ent_type->modelAssetKey[0] == '\0') {
+			b = pk_bkt_arr_iter_decrement(&et_mstr.bc, &iter_ent_type);
+			continue;
+		}
 		CompGrBinds *grBindsArr[EntityTypeDetails_MAX] = {nullptr};
-		for (long k = 0; k < et.detailsCount; ++k) {
-			const EntityTypeDetails &etd = et.details[k];
-			grBindsArr[k] = etd.grBinds;
+		for (long k = 0; k < iter_ent_type->detailsCount; ++k) {
+			grBindsArr[k] = iter_ent_type->details[k].grBinds;
 		}
-		EntityType_Unload(et, grBindsArr);
-	};
-	pk_bkt_arr_iterate(&et_mstr.bc, et_iter_cb, NULL);
+		EntityType_Unload(*iter_ent_type, grBindsArr);
+		b = pk_bkt_arr_iter_decrement(&et_mstr.bc, &iter_ent_type);
+	}
 	pk_bkt_arr_teardown(&et_mstr.bc);
 	pk_arr_reset(&EntityTypesToTeardown);
 	pk_mem_bucket_destroy(et_mstr.bkt);
diff --git a/src/project.cpp b/src/project.cpp
index 00c4c1f..463c2c9 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -393,6 +393,11 @@ void PkeProject_Load(const char *filePath) {
 
 void PkeProject_Save(const char *filePath) {
 	bool failed = false;
+	bool b;
+	pk_iter_t<Asset> iter_asset{};
+	pk_iter_t<EntityType> iter_ent_type{};
+	pk_bkt_arr *bkt_arr_assets;
+	pk_bkt_arr *bkt_arr_ent_types;
 	const char *saveFilePath = filePath == nullptr ? PKE_PROJ_DEFAULT_FILENAME : filePath;
 	std::ostringstream stream{};
 
@@ -408,38 +413,44 @@ void PkeProject_Save(const char *filePath) {
 		f << PKE_PROJ_FILE_OBJ_END << std::endl;
 		*/
 
-		using AssetLoopFn = pk_tmpln_1<void, Asset *, void *>;
-		using ETLoopFn = pk_tmpln_1<void, EntityType *, void *>;
-		AssetLoopFn asset_loop_cb{};
-		ETLoopFn et_loop_cb{};
-
-		asset_loop_cb.func = [&stream](Asset *arr_obj_data) {
-			if (PK_HAS_FLAG(arr_obj_data->flags, PKE_ASSET_FLAGS_MEM_STATIC)) return;
+		bkt_arr_assets = AM_GetAssets();
+		b = pk_bkt_arr_iter_begin(bkt_arr_assets, &iter_asset);
+		while (b == true) {
+			if (PK_HAS_FLAG(iter_asset->flags, PKE_ASSET_FLAGS_MEM_STATIC)) {
+				b = pk_bkt_arr_iter_increment(bkt_arr_assets, &iter_asset);
+				continue;
+			}
 			// TODO 2025-05-30 JCB
 			// This should be a flag
 			bool isGlobalAsset = false;
 			for (long k = 0; k < embedded_shader_index_count; ++k) {
-				if (strncmp(embedded_shaders[k].name, arr_obj_data->key, AssetKeyLength) == 0) {
+				if (strncmp(embedded_shaders[k].name, iter_asset->key, AssetKeyLength) == 0) {
 					isGlobalAsset = true;
 					break;
 				}
 			}
-			if (isGlobalAsset) return;
+			if (isGlobalAsset) {
+				b = pk_bkt_arr_iter_increment(bkt_arr_assets, &iter_asset);
+				continue;
+			}
 			stream << PKE_PROJ_FILE_OBJ_ASSET << std::endl;
-			Proj_SerializeAsset(stream, *arr_obj_data);
+			Proj_SerializeAsset(stream, *iter_asset);
 			stream << PKE_PROJ_FILE_OBJ_END << std::endl;
-		};
-		pk_bkt_arr_iterate(AM_GetAssets(), &AssetLoopFn::invoke, &asset_loop_cb);
+			b = pk_bkt_arr_iter_increment(bkt_arr_assets, &iter_asset);
+		}
 
-		et_loop_cb.func = [&stream](EntityType *arr_obj_data) {
-			if (arr_obj_data->modelAssetKey[0] == '\0') {
-				return;
+		bkt_arr_ent_types = EntityType_GetEntityTypes();
+		b = pk_bkt_arr_iter_begin(bkt_arr_ent_types, &iter_ent_type);
+		while (b == true) {
+			if (iter_ent_type->modelAssetKey[0] == '\0') {
+				b = pk_bkt_arr_iter_increment(bkt_arr_ent_types, &iter_ent_type);
+				continue;
 			}
 			stream << PKE_PROJ_FILE_OBJ_ENTITY_TYPE << std::endl;
-			Proj_SerializeEntityType(stream, *arr_obj_data);
+			Proj_SerializeEntityType(stream, *iter_ent_type);
 			stream << PKE_PROJ_FILE_OBJ_END << std::endl;
-		};
-		pk_bkt_arr_iterate(EntityType_GetEntityTypes(), &ETLoopFn::invoke, &et_loop_cb);
+			b = pk_bkt_arr_iter_increment(bkt_arr_ent_types, &iter_ent_type);
+		}
 
 		FontTypeIndex font_count;
 		FontType *fonts = FontType_GetFonts(font_count);
diff --git a/src/serialization.cpp b/src/serialization.cpp
index 0d8f2e1..96dd5b5 100644
--- a/src/serialization.cpp
+++ b/src/serialization.cpp
@@ -66,10 +66,10 @@ void pke_deserialize_project_from_stream(std::istream &i, srlztn_deserialize_hel
 }
 
 void pke_serialize_scene(srlztn_serialize_helper *h) {
-	using CamIterFn = pk_tmpln_1<void, PkeCamera*, void*>;
-	using InstIterFn = pk_tmpln_1<void, CompInstance*, void*>;
-	CamIterFn cam_iter_cb{};
-	InstIterFn inst_iter_cb{};
+	bool b;
+	pk_bkt_arr *bkt_arr_instance;
+	pk_iter_t<CompInstance> iter_instance{};
+	pk_iter_t<PkeCamera> iter_cam{};
 
 	pk_arr_t<pke_input_set> &sets = pke_input_get_input_sets();
 	for (uint32_t i = 0; i < sets.next; ++i) {
@@ -97,22 +97,27 @@ void pke_serialize_scene(srlztn_serialize_helper *h) {
 		pke_serialize_ui_box(h, ui_boxes[i]);
 	}
 
-	inst_iter_cb.func = [&h](CompInstance *instance_ptr) {
-		const auto &instance = *instance_ptr;
-		if (PK_HAS_FLAG(instance.comp_instance_flags, COMPONENT_INSTANCE_FLAG_DO_NOT_SERIALIZE)) {
-			return;
+	bkt_arr_instance = ECS_GetInstances();
+	b = pk_bkt_arr_iter_begin(bkt_arr_instance, &iter_instance);
+	while (b == true) {
+		if (PK_HAS_FLAG(iter_instance->comp_instance_flags, COMPONENT_INSTANCE_FLAG_DO_NOT_SERIALIZE)) {
+			b = pk_bkt_arr_iter_increment(bkt_arr_instance, &iter_instance);
+			continue;
 		}
-		pke_serialize_instance(h, &instance);
-	};
-	pk_bkt_arr_iterate(ECS_GetInstances(), &InstIterFn::invoke, &inst_iter_cb);
+		pke_serialize_instance(h, iter_instance);
+		b = pk_bkt_arr_iter_increment(bkt_arr_instance, &iter_instance);
+	}
 
-	cam_iter_cb.func = [&h](PkeCamera *cam_ptr) {
-		if (cam_ptr->camHandle == CameraHandle_MAX) {
-			return;
+	pk_bkt_arr &bkt_arr_cams = PkeCamera_GetPkBktArr();
+	b = pk_bkt_arr_iter_begin(&bkt_arr_cams, &iter_cam);
+	while (b == true) {
+		if (iter_cam->camHandle == CameraHandle_MAX) {
+			b = pk_bkt_arr_iter_increment(&bkt_arr_cams, &iter_cam);
+			continue;
 		}
-		pke_serialize_camera(h, cam_ptr);
-	};
-	pk_bkt_arr_iterate(&PkeCamera_GetPkBktArr(), &CamIterFn::invoke, &cam_iter_cb);
+		pke_serialize_camera(h, iter_cam);
+		b = pk_bkt_arr_iter_increment(&bkt_arr_cams, &iter_cam);
+	}
 }
 void pke_deserialize_scene(srlztn_deserialize_helper *h) {
 	uint32_t i;
diff --git a/src/static-ui.cpp b/src/static-ui.cpp
index d8990a3..f80c000 100644
--- a/src/static-ui.cpp
+++ b/src/static-ui.cpp
@@ -967,14 +967,15 @@ const pke_ui_graphics_bindings &pke_ui_get_graphics_bindings() {
 }
 
 void pke_ui_get_graphics_bindings_texture(pk_arr *arr) {
+	bool b;
 	pk_arr_t<pke_ui_graphics_bindings_texture> &arr_t = *static_cast<pk_arr_t<pke_ui_graphics_bindings_texture>*>(arr);
 	assert(arr_t.stride == sizeof(pke_ui_graphics_bindings_texture));
 	assert(arr_t.alignment == alignof(pke_ui_graphics_bindings_texture));
 
-	texture_binding_bkt_arr::FN_Iter iter_fn_tmpln;
-	iter_fn_tmpln.func = [&arr_t](pke_ui_graphics_bindings_texture *arr_item) {
-		pk_arr_append_t(&arr_t, *arr_item);
-	};
-
-	pk_bkt_arr_iterate(&pke_ui_master.bindings_texture, texture_binding_bkt_arr::FN_Iter::invoke, &iter_fn_tmpln);
+	pk_iter_t<pke_ui_graphics_bindings_texture> iter_gr{};
+	b = pk_bkt_arr_iter_begin(&pke_ui_master.bindings_texture, &iter_gr);
+	while (b == true) {
+		pk_arr_append_t<pke_ui_graphics_bindings_texture>(&arr_t, *iter_gr);
+		b = pk_bkt_arr_iter_increment(&pke_ui_master.bindings_texture, &iter_gr);
+	}
 }
diff --git a/src/window.cpp b/src/window.cpp
index e0184d6..6655488 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -3419,6 +3419,7 @@ void pkvk_transition_image_layout(VkCommandBuffer                command_buffer,
 
 void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 	uint32_t i, counter;
+	bool b;
 	vkResetCommandBuffer(commandBuffer, 0);
 
 	VkCommandBufferBeginInfo beginInfo;
@@ -3550,16 +3551,23 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 		vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
 		vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
 
-		using GrBindsIterFn = pk_tmpln_1<void, CompGrBinds*, void*>;
-		GrBindsIterFn gr_binds_iter_cb{};
-		gr_binds_iter_cb.func = [commandBuffer, imageIndex](CompGrBinds *binder) {
-			VkDeviceSize offsets[1] = {0U};
-			if (binder->grBindsHandle == GrBindsHandle_MAX)
-				return;
-			if (!binder->vkPipelineLayout)
-				return;
+		pk_iter_t<CompGrBinds> gr_binds_iter{};
+		pk_bkt_arr *ecs_gr_binds_bkt_arr = ECS_GetGrBinds();
+		b = pk_bkt_arr_iter_begin(ecs_gr_binds_bkt_arr, &gr_binds_iter);
+		CompGrBinds *binder = nullptr;
+		while (b == true) {
+			binder = &*gr_binds_iter;
+			if (binder->grBindsHandle == GrBindsHandle_MAX) {
+				b = pk_bkt_arr_iter_increment(ecs_gr_binds_bkt_arr, &gr_binds_iter);
+				continue;
+			}
+			if (!binder->vkPipelineLayout) {
+				b = pk_bkt_arr_iter_increment(ecs_gr_binds_bkt_arr, &gr_binds_iter);
+				continue;
+			}
 			if (binder->instanceBD.bindingCount < 1) {
-				return;
+				b = pk_bkt_arr_iter_increment(ecs_gr_binds_bkt_arr, &gr_binds_iter);
+				continue;
 			}
 			vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, binder->graphicsPipeline);
 			vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, binder->vkPipelineLayout, 0, 1, &binder->vkDescriptorSets[imageIndex], 0, {});
@@ -3584,8 +3592,8 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 
 				vkCmdDrawIndexed(commandBuffer, binder->physIndxBD.bindingCount, binder->instanceCounter, 0, 0, 0);
 			}
-		};
-		pk_bkt_arr_iterate(ECS_GetGrBinds(), &GrBindsIterFn::invoke, &gr_binds_iter_cb);
+			b = pk_bkt_arr_iter_increment(ecs_gr_binds_bkt_arr, &gr_binds_iter);
+		}
 
 		if (pkeDebugHitbox.instanceBuffer != VK_NULL_HANDLE) {
 			vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pkePipelines.pipelines.named.entity_wireframe);