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, 45 insertions, 46 deletions

diff --git a/src/window.cpp b/src/window.cpp
index db817e6..c7963eb 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -12,7 +12,6 @@
 #include "event.hpp"
 #include "game-settings.hpp"
 #include "helpers.hpp"
-#include "memory.hpp"
 #include "plugins.hpp"
 #include "static/cube.hpp"
 #include "window-types.hpp"
@@ -23,7 +22,7 @@
 #include <cstdint>
 #include <fstream>
 
-MemBucket *MemBkt_Vulkan = nullptr;
+struct pk_membucket *MemBkt_Vulkan = nullptr;
 struct pke_vkAllocData {
 	void *data;
 	std::size_t size;
@@ -218,7 +217,7 @@ unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, short hasPresentSuppo
 
 	unsigned int queueFamilyPropertyCount = 0U;
 	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, nullptr);
-	auto *queueFamilyProperties = Pke_New<VkQueueFamilyProperties>(queueFamilyPropertyCount);
+	auto *queueFamilyProperties = pk_new<VkQueueFamilyProperties>(queueFamilyPropertyCount);
 	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, queueFamilyProperties);
 
 	for (unsigned int i = 0; i < queueFamilyPropertyCount; i++) {
@@ -236,11 +235,11 @@ unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, short hasPresentSuppo
 				continue;
 			}
 		}
-		Pke_Delete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
+		pk_delete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
 		return i;
 	}
 
-	Pke_Delete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
+	pk_delete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
 	return 0xFFFFFFFF;
 }
 
@@ -258,7 +257,7 @@ void PKE_vkFreeFunction(void *pUserData, void *pMemory) {
 	}
 	if (chunk != nullptr) {
 		assert(chunk != nullptr);
-		Pke_Delete(chunk->data, chunk->size, MemBkt_Vulkan);
+		pk_delete_bkt(chunk->data, chunk->size, MemBkt_Vulkan);
 		vulkanAllocs->Remove(index);
 	} else {
 		fprintf(stderr, "%s\n", "PKE_vkFreeFunction - untracked pointer");
@@ -269,7 +268,7 @@ void *PKE_vkAllocateFunction(void *pUserData, size_t size, size_t alignment, VkS
 	if (size == 0) {
 		return nullptr;
 	}
-	void *ptr = Pke_New(size, alignment, MemBkt_Vulkan);
+	void *ptr = pk_new_bkt(size, alignment, MemBkt_Vulkan);
 	vulkanAllocs->Push({
 		.data = ptr,
 		.size = size,
@@ -303,7 +302,7 @@ void *PKE_vkReallocationFunction(void *pUserData, void *pOriginal, size_t size,
 	void *newPtr = PKE_vkAllocateFunction(pUserData, size, alignment, allocScope);
 	if (chunk != nullptr) {
 		memcpy(newPtr, chunk->data, (chunk->size < size ? chunk->size : size) - 1);
-		Pke_Delete(chunk->data, chunk->size, MemBkt_Vulkan);
+		pk_delete_bkt(chunk->data, chunk->size, MemBkt_Vulkan);
 		vulkanAllocs->Remove(index);
 	} else {
 
@@ -320,7 +319,7 @@ void PKE_vkInternalFreeNotification(void *pUserData, size_t size, VkInternalAllo
 }
 
 void InitVulkan() {
-	vkAllocator = Pke_New<VkAllocationCallbacks>(MemBkt_Vulkan);
+	vkAllocator = pk_new<VkAllocationCallbacks>(MemBkt_Vulkan);
 	vkAllocator->pUserData = nullptr;
 	vkAllocator->pfnAllocation = PKE_vkAllocateFunction;
 	vkAllocator->pfnReallocation = PKE_vkReallocationFunction;
@@ -333,14 +332,14 @@ void InitVulkan() {
 		unsigned int layerCount;
 		vkResult = vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		VkLayerProperties *availableLayerProperties = Pke_New<VkLayerProperties>(layerCount);
+		VkLayerProperties *availableLayerProperties = pk_new<VkLayerProperties>(layerCount);
 		vkResult = vkEnumerateInstanceLayerProperties(&layerCount, availableLayerProperties);
 		assert(vkResult == VK_SUCCESS);
 		printf("Available Layers:\n");
 		for (long i = 0; i < layerCount; ++i) {
 			printf("\t%s\n", availableLayerProperties[i].layerName);
 		}
-		Pke_Delete<VkLayerProperties>(availableLayerProperties, layerCount);
+		pk_delete<VkLayerProperties>(availableLayerProperties, layerCount);
 	}
 
 	VkApplicationInfo appInfo;
@@ -410,14 +409,14 @@ void InitVulkan() {
 		unsigned int extensionCount = 0;
 		vkResult = vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		auto *extensions = Pke_New<VkExtensionProperties>(extensionCount);
+		auto *extensions = pk_new<VkExtensionProperties>(extensionCount);
 		vkResult = vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions);
 		assert(vkResult == VK_SUCCESS);
 		printf("Available Extensions:\n");
 		for (long i = 0; i < extensionCount; ++i) {
 			printf("\t%s\n", extensions[i].extensionName);
 		}
-		Pke_Delete<VkExtensionProperties>(extensions, extensionCount);
+		pk_delete<VkExtensionProperties>(extensions, extensionCount);
 	}
 
 	vkResult = vkCreateInstance(&createInfo, vkAllocator, &vkInstance);
@@ -457,7 +456,7 @@ void InitVulkan() {
 	vkResult = vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, nullptr);
 	assert(vkResult == VK_SUCCESS);
 	assert(physicalDeviceCount > 0);
-	auto *physicalDevices = Pke_New<VkPhysicalDevice>(physicalDeviceCount);
+	auto *physicalDevices = pk_new<VkPhysicalDevice>(physicalDeviceCount);
 	vkResult = vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices);
 	assert(vkResult == VK_SUCCESS);
 	graphicsFamilyIndex = 0;
@@ -477,7 +476,7 @@ void InitVulkan() {
 		unsigned int extensionCount = 0;
 		vkResult = vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		auto *extensionProperties = Pke_New<VkExtensionProperties>(extensionCount);
+		auto *extensionProperties = pk_new<VkExtensionProperties>(extensionCount);
 		vkResult = vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, extensionProperties);
 		assert(vkResult == VK_SUCCESS);
 		for (long k = 0; k < extensionCount; ++k) {
@@ -491,7 +490,7 @@ void InitVulkan() {
 				}
 			}
 		}
-		Pke_Delete<VkExtensionProperties>(extensionProperties, extensionCount);
+		pk_delete<VkExtensionProperties>(extensionProperties, extensionCount);
 		if (requiredExtensions.empty() == false) {
 			continue;
 		}
@@ -520,7 +519,7 @@ void InitVulkan() {
 		break;
 	}
 	assert(vkPhysicalDevice != nullptr && "Failed to find suitable physical device");
-	Pke_Delete<VkPhysicalDevice>(physicalDevices, physicalDeviceCount);
+	pk_delete<VkPhysicalDevice>(physicalDevices, physicalDeviceCount);
 
 	// Create logical device
 	{
@@ -694,7 +693,7 @@ void CreateSwapchain() {
 		unsigned int surfaceFormatCounts;
 		vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		VkSurfaceFormatKHR *surfaceFormats = Pke_New<VkSurfaceFormatKHR>(surfaceFormatCounts);
+		VkSurfaceFormatKHR *surfaceFormats = pk_new<VkSurfaceFormatKHR>(surfaceFormatCounts);
 		vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, surfaceFormats);
 		assert(vkResult == VK_SUCCESS);
 		selectedSurfaceIndex = 0;
@@ -707,7 +706,7 @@ void CreateSwapchain() {
 			break;
 		}
 
-		Pke_Delete<VkSurfaceFormatKHR>(surfaceFormats, surfaceFormatCounts);
+		pk_delete<VkSurfaceFormatKHR>(surfaceFormats, surfaceFormatCounts);
 	}
 
 	int width, height;
@@ -725,7 +724,7 @@ void CreateSwapchain() {
 		unsigned int presentModeCount = 0;
 		vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, nullptr);
 		assert(vkResult == VK_SUCCESS);
-		VkPresentModeKHR *presentModes = Pke_New<VkPresentModeKHR>(presentModeCount);
+		VkPresentModeKHR *presentModes = pk_new<VkPresentModeKHR>(presentModeCount);
 		vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, presentModes);
 		assert(vkResult == VK_SUCCESS);
 		uint32_t immediateIndex = -1;
@@ -762,7 +761,7 @@ void CreateSwapchain() {
 		if (immediateIndex != -1) {
 			vkPresentModeKHR = VK_PRESENT_MODE_IMMEDIATE_KHR;
 		}
-		Pke_Delete<VkPresentModeKHR>(presentModes, presentModeCount);
+		pk_delete<VkPresentModeKHR>(presentModes, presentModeCount);
 	}
 
 	VkSwapchainCreateInfoKHR vkSwapchainCreateInfo;
@@ -831,10 +830,10 @@ void CreateSwapchain() {
 
 	vkResult = vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, nullptr);
 	assert(vkResult == VK_SUCCESS);
-	swapchainImages = Pke_New<VkImage>(swapchainLength);
+	swapchainImages = pk_new<VkImage>(swapchainLength);
 	vkResult = vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, swapchainImages);
 	assert(vkResult == VK_SUCCESS);
-	swapchainImageViews = Pke_New<VkImageView>(swapchainLength);
+	swapchainImageViews = pk_new<VkImageView>(swapchainLength);
 	for (long i = 0; i < swapchainLength; ++i) {
 		vkImageViewCreateInfo.image = swapchainImages[i];
 		vkResult = vkCreateImageView(vkDevice, &vkImageViewCreateInfo, vkAllocator, &swapchainImageViews[i]);
@@ -863,20 +862,20 @@ void CreateSwapchain() {
 	renderTargetImageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
 	// render images
-	renderImages = Pke_New<VkImage>(MAX_FRAMES_IN_FLIGHT);
-	renderImageViews = Pke_New<VkImageView>(MAX_FRAMES_IN_FLIGHT);
+	renderImages = pk_new<VkImage>(MAX_FRAMES_IN_FLIGHT);
+	renderImageViews = pk_new<VkImageView>(MAX_FRAMES_IN_FLIGHT);
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, renderImages, renderImageViews, &renderImagesMemory);
 
 	// color images
-	colorImages = Pke_New<VkImage>(MAX_FRAMES_IN_FLIGHT);
-	colorImageViews = Pke_New<VkImageView>(MAX_FRAMES_IN_FLIGHT);
+	colorImages = pk_new<VkImage>(MAX_FRAMES_IN_FLIGHT);
+	colorImageViews = pk_new<VkImageView>(MAX_FRAMES_IN_FLIGHT);
 	renderTargetImageCI.samples = renderSampleCount;
 	renderTargetImageCI.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 	CreateImageResources_Inner(&renderTargetImageCI, &vkImageViewCreateInfo, VkBufferUsageFlagBits(0), nullptr, colorImages, colorImageViews, &colorImagesMemory);
 
 	// depth images
-	depthImages = Pke_New<VkImage>(MAX_FRAMES_IN_FLIGHT);
-	depthImageViews = Pke_New<VkImageView>(MAX_FRAMES_IN_FLIGHT);
+	depthImages = pk_new<VkImage>(MAX_FRAMES_IN_FLIGHT);
+	depthImageViews = pk_new<VkImageView>(MAX_FRAMES_IN_FLIGHT);
 	renderTargetImageCI.format = depthFormat;
 	vkImageViewCreateInfo.format = depthFormat;
 	renderTargetImageCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
@@ -1306,8 +1305,8 @@ void CreatePresentPipeline() {
 void CreateFramebuffers() {
 	assert(swapchainFramebuffers == nullptr || swapchainFramebuffers == CAFE_BABE(VkFramebuffer));
 	assert(renderImageFramebuffers == nullptr || renderImageFramebuffers == CAFE_BABE(VkFramebuffer));
-	swapchainFramebuffers = Pke_New<VkFramebuffer>(swapchainLength);
-	renderImageFramebuffers = Pke_New<VkFramebuffer>(swapchainLength);
+	swapchainFramebuffers = pk_new<VkFramebuffer>(swapchainLength);
+	renderImageFramebuffers = pk_new<VkFramebuffer>(swapchainLength);
 
 	VkFramebufferCreateInfo framebufferInfo;
 	framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
@@ -2183,7 +2182,7 @@ void UpdateDebugGraphicsPipeline() {
 	vkDescriptorSetAllocateInfo.descriptorSetCount = MAX_FRAMES_IN_FLIGHT;
 	vkDescriptorSetAllocateInfo.pSetLayouts = descriptorSets;
 
-	pkeDebugHitbox.vkDescriptorSets = Pke_New<VkDescriptorSet>(MAX_FRAMES_IN_FLIGHT);
+	pkeDebugHitbox.vkDescriptorSets = pk_new<VkDescriptorSet>(MAX_FRAMES_IN_FLIGHT);
 	for (long i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
 		pkeDebugHitbox.vkDescriptorSets[i] = VkDescriptorSet{};
 	}
@@ -2474,14 +2473,14 @@ void DestroySwapchain() {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyFramebuffer(vkDevice, renderImageFramebuffers[i], vkAllocator);
 		}
-		Pke_Delete<VkFramebuffer>(renderImageFramebuffers, swapchainLength);
+		pk_delete<VkFramebuffer>(renderImageFramebuffers, swapchainLength);
 		renderImageFramebuffers = CAFE_BABE(VkFramebuffer);
 	}
 	if (swapchainFramebuffers != nullptr && swapchainFramebuffers != CAFE_BABE(VkFramebuffer)) {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyFramebuffer(vkDevice, swapchainFramebuffers[i], vkAllocator);
 		}
-		Pke_Delete<VkFramebuffer>(swapchainFramebuffers, swapchainLength);
+		pk_delete<VkFramebuffer>(swapchainFramebuffers, swapchainLength);
 		swapchainFramebuffers = CAFE_BABE(VkFramebuffer);
 	}
 	if (renderImageViews!= nullptr && renderImageViews != CAFE_BABE(VkImageView)) {
@@ -2495,17 +2494,17 @@ void DestroySwapchain() {
 			vkDestroyImageView(vkDevice, renderImageViews[i], vkAllocator);
 			vkDestroyImage(vkDevice, renderImages[i], vkAllocator);
 		}
-		Pke_Delete<VkImageView>(depthImageViews, swapchainLength);
+		pk_delete<VkImageView>(depthImageViews, swapchainLength);
 		depthImageViews = CAFE_BABE(VkImageView);
-		Pke_Delete<VkImage>(depthImages, swapchainLength);
+		pk_delete<VkImage>(depthImages, swapchainLength);
 		depthImages = CAFE_BABE(VkImage);
-		Pke_Delete<VkImageView>(colorImageViews, swapchainLength);
+		pk_delete<VkImageView>(colorImageViews, swapchainLength);
 		colorImageViews = CAFE_BABE(VkImageView);
-		Pke_Delete<VkImage>(colorImages, swapchainLength);
+		pk_delete<VkImage>(colorImages, swapchainLength);
 		colorImages = CAFE_BABE(VkImage);
-		Pke_Delete<VkImageView>(renderImageViews, swapchainLength);
+		pk_delete<VkImageView>(renderImageViews, swapchainLength);
 		renderImageViews = CAFE_BABE(VkImageView);
-		Pke_Delete<VkImage>(renderImages, swapchainLength);
+		pk_delete<VkImage>(renderImages, swapchainLength);
 		renderImages = CAFE_BABE(VkImage);
 		vkFreeMemory(vkDevice, depthImagesMemory, vkAllocator);
 		vkFreeMemory(vkDevice, colorImagesMemory, vkAllocator);
@@ -2515,9 +2514,9 @@ void DestroySwapchain() {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyImageView(vkDevice, swapchainImageViews[i], vkAllocator);
 		}
-		Pke_Delete<VkImageView>(swapchainImageViews, swapchainLength);
+		pk_delete<VkImageView>(swapchainImageViews, swapchainLength);
 		swapchainImageViews = CAFE_BABE(VkImageView);
-		Pke_Delete<VkImage>(swapchainImages, swapchainLength);
+		pk_delete<VkImage>(swapchainImages, swapchainLength);
 		swapchainImages = CAFE_BABE(VkImage);
 	}
 	vkDestroySwapchainKHR(vkDevice, vkSwapchainKHR, vkAllocator);
@@ -2568,8 +2567,8 @@ void FramebufferResizeCallback(GLFWwindow *window, int width, int height) {
 
 void CreateWindow(PKEWindowProperties wp) {
 	if (vkInstance != nullptr) return;
-	MemBkt_Vulkan = Pke_BeginTransientBucket();
-	vulkanAllocs = Pke_New<DynArray<pke_vkAllocData>>(MemBkt_Vulkan);
+	MemBkt_Vulkan = pk_bucket_create("vulkan", PK_DEFAULT_BUCKET_SIZE, false);
+	vulkanAllocs = pk_new<DynArray<pke_vkAllocData>>(MemBkt_Vulkan);
 	new (vulkanAllocs) DynArray<pke_vkAllocData>(MemBkt_Vulkan);
 	vulkanAllocs->Reserve(2048);
 	glfwInit();
@@ -2602,7 +2601,7 @@ void DestroyWindow() {
 	DestroySwapchain();
 
 	vkDestroyDescriptorPool(vkDevice, pkeDebugHitbox.vkDescriptorPool, vkAllocator);
-	Pke_Delete<VkDescriptorSet>(pkeDebugHitbox.vkDescriptorSets, MAX_FRAMES_IN_FLIGHT);
+	pk_delete<VkDescriptorSet>(pkeDebugHitbox.vkDescriptorSets, MAX_FRAMES_IN_FLIGHT);
 
 	vkDestroyBuffer(vkDevice, pkeDebugHitbox.indexBuffer, vkAllocator);
 	vkDestroyBuffer(vkDevice, pkeDebugHitbox.uvBuffer, vkAllocator);
@@ -2654,7 +2653,7 @@ void DestroyWindow() {
 	glfwTerminate();
 
 	vulkanAllocs->~DynArray();
-	Pke_EndTransientBucket(MemBkt_Vulkan);
+	pk_bucket_destroy(MemBkt_Vulkan);
 }
 
 VkShaderModule UploadShader(AssetHandle handle) {