cleanup naming conventions and header defs

14 files changed, 99 insertions, 104 deletions

diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp
index eafa34d..b980154 100644
--- a/src/asset-manager.cpp
+++ b/src/asset-manager.cpp
@@ -12,11 +12,11 @@ AssetHandle_T assetBucketCounter{0};
 AssetHandle_T assetCounter{0};
 AssetBucket *assetBuckets = nullptr;
 
-void AssetManagerInit() {
-	assetBuckets = pke::PkeNew<AssetBucket>(assetBucketIncrementer);
+void AM_Init() {
+	assetBuckets = Pke_New<AssetBucket>(assetBucketIncrementer);
 }
 
-AssetHandle RegisterAsset_Inner(const void *src, void *dst, int64_t size, const char *key) {
+AssetHandle AM_Register_Inner(const void *src, void *dst, int64_t size, const char *key) {
 
 	AssetHandle_T assetHandle_T{Buckets_NewHandle<AssetBucket>(256ULL, assetBucketIncrementer, assetBucketCounter, assetCounter, assetBuckets)};
 	AssetHandle assetHandle{assetHandle_T};
@@ -32,24 +32,24 @@ AssetHandle RegisterAsset_Inner(const void *src, void *dst, int64_t size, const
 	return assetHandle;
 }
 
-AssetHandle RegisterAsset(const void *data, int64_t size, const char *key) {
+AssetHandle AM_Register(const void *data, int64_t size, const char *key) {
 	assert(data == nullptr && "Attempt to register invalid asset data");
 	assert(data == CAFE_BABE(void) && "Attempt to register invalid asset data");
 	assert(size == 0 && "Attempt to register asset data of size 0");
-	void *target = pke::PkeNew(size);
-	return RegisterAsset_Inner(data, target, size, key);
+	void *target = Pke_New(size);
+	return AM_Register_Inner(data, target, size, key);
 }
 
-AssetHandle RegisterAsset(const char *path) {
+AssetHandle AM_Register(const char *path) {
 	std::ifstream file(path, std::ios::ate | std::ios::binary);
 	if (!file.is_open()) {
 		throw "failed to open file";
 	}
 	auto fileSize = (int64_t)file.tellg();
-	void *target = pke::PkeNew(fileSize);
+	void *target = Pke_New(fileSize);
 
 	int64_t pathLen = strlen(path);
-	auto assetHandle = RegisterAsset_Inner(nullptr, target, 0, path + (pathLen > 16 ? pathLen - 16 : 0));
+	auto assetHandle = AM_Register_Inner(nullptr, target, 0, path + (pathLen > 16 ? pathLen - 16 : 0));
 	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
 	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
 	file.seekg(0);
@@ -59,11 +59,11 @@ AssetHandle RegisterAsset(const char *path) {
 	return assetHandle;
 }
 
-void DestroyAsset(AssetHandle assetHandle) {
+void AM_Destroy(AssetHandle assetHandle) {
 	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
 	auto itemIndex = Buckets_GetItemIndex(assetHandle_T);
 	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[itemIndex];
-	pke::PkeDelete(asset->ptr, asset->size);
+	Pke_Delete(asset->ptr, asset->size);
 	for (long i = 0; i < 16; ++i) {
 		asset->key[i] = 0;
 	}
@@ -74,7 +74,7 @@ void DestroyAsset(AssetHandle assetHandle) {
 	}
 }
 
-const Asset *GetAsset(AssetHandle assetHandle) {
+const Asset *AM_Get(AssetHandle assetHandle) {
 	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
 	return &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
 }
diff --git a/src/asset-manager.hpp b/src/asset-manager.hpp
index 8064697..73d19a1 100644
--- a/src/asset-manager.hpp
+++ b/src/asset-manager.hpp
@@ -17,10 +17,10 @@ struct Asset{
 	void *ptr = nullptr;
 };
 
-void AssetManagerInit();
-AssetHandle RegisterAsset(const void *data, int64_t size, const char *key);
-AssetHandle RegisterAsset(const char *path);
-void DestroyAsset(AssetHandle assetHandle);
-const Asset *GetAsset(AssetHandle assetHandle);
+void AM_Init();
+AssetHandle AM_Register(const void *data, int64_t size, const char *key);
+AssetHandle AM_Register(const char *path);
+void AM_Destroy(AssetHandle assetHandle);
+const Asset *AM_Get(AssetHandle assetHandle);
 
 #endif /* PKE_ASSET_MANAGER_HPP */
diff --git a/src/dynamic-array.cpp b/src/dynamic-array.cpp
index 6b88fd7..44dd50b 100644
--- a/src/dynamic-array.cpp
+++ b/src/dynamic-array.cpp
@@ -4,10 +4,10 @@
 void DynArrayReserve(DynArrayBase *arr, int64_t count) {
 	assert(count != 0);
 	if (arr->reservedCount >= count) return;
-	char *a = pke::PkeNew<char>(arr->elementSize * count);
+	char *a = Pke_New<char>(arr->elementSize * count);
 	if (arr->ptr != nullptr) {
 		std::memcpy(a, arr->ptr, arr->elementSize * arr->reservedCount);
-		pke::PkeDelete<char>(arr->ptr, arr->elementSize * arr->reservedCount);
+		Pke_Delete<char>(arr->ptr, arr->elementSize * arr->reservedCount);
 	}
 	arr->reservedCount = count;
 	arr->ptr = a;
@@ -16,7 +16,7 @@ void DynArrayReserve(DynArrayBase *arr, int64_t count) {
 void DynArrayDestroy(DynArrayBase *arr) {
 	if (arr->ptr == nullptr) return;
 	if (arr->ptr == CAFE_BABE(char)) return;
-	pke::PkeDelete<char>(arr->ptr, arr->elementSize * arr->reservedCount);
+	Pke_Delete<char>(arr->ptr, arr->elementSize * arr->reservedCount);
 	arr->ptr = CAFE_BABE(char);
 }
 
diff --git a/src/dynamic-array.hpp b/src/dynamic-array.hpp
index a2d2d77..ddcc8b4 100644
--- a/src/dynamic-array.hpp
+++ b/src/dynamic-array.hpp
@@ -1,5 +1,5 @@
-#ifndef FOUR_ZED_ZED_DYNAMIC_ARRAY_HPP
-#define FOUR_ZED_ZED_DYNAMIC_ARRAY_HPP
+#ifndef PKE_DYNAMIC_ARRAY_HPP
+#define PKE_DYNAMIC_ARRAY_HPP
 
 #include "memory.hpp"
 #include "macros.hpp"
@@ -94,10 +94,10 @@ template <typename T> inline void DynArray<T>::Remove(std::size_t index) {
 	assert(this->elementCount == 0 && "Invalid DynArray<T>::Remove() - Contains no elements");
 	assert(index >= this->elementCount && "Invalid DynArray<T>::Remove() - Out of bounds");
 	uint64_t moveCount = (this->elementCount - index - 1);
-	auto *tmp = pke::PkeNew(this->elementSize * moveCount);
+	auto *tmp = Pke_New(this->elementSize * moveCount);
 	memcpy(tmp, this->ptr + (this->elementSize * (index + 1)), this->elementSize * moveCount);
 	memcpy(this->ptr + (this->elementSize * index), tmp, this->elementSize * moveCount);
-	pke::PkeDelete(tmp, moveCount * this->elementSize);
+	Pke_Delete(tmp, moveCount * this->elementSize);
 	this->elementCount -= 1;
 }
 
@@ -115,4 +115,4 @@ template <typename T> inline void DynArray<T>::Resize(int64_t count) {
 	this->elementCount = count;
 }
 
-#endif /* FOUR_ZED_ZED_DYNAMIC_ARRAY_HPP */
+#endif /* PKE_DYNAMIC_ARRAY_HPP */
diff --git a/src/ecs.cpp b/src/ecs.cpp
index 2c0a26f..aa85873 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -16,7 +16,7 @@ DynArray<EntityHandle> entitiesMarkedForRemoval{16};
 DynArray<EntityHandle> EntitiesToBeRemoved{16};
 
 void ECS_Init() {
-	entityBuckets = pke::PkeNew<EntityBucket>(entityBucketIncrementer);
+	entityBuckets = Pke_New<EntityBucket>(entityBucketIncrementer);
 }
 
 EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntityHandle) {
diff --git a/src/event.cpp b/src/event.cpp
index 4683f0e..d7c18b7 100644
--- a/src/event.cpp
+++ b/src/event.cpp
@@ -20,7 +20,7 @@ void EventBucketFind(const char *name, char *safeName, EventBucket*& bkt) {
 	}
 }
 
-void RegisterCallback(const char *name, EventHandler handler) {
+void Event_RegisterCallback(const char *name, EventHandler handler) {
 	char safeName[16];
 	EventBucket *bkt = nullptr;
 	EventBucketFind(name, safeName, bkt);
@@ -32,7 +32,7 @@ void RegisterCallback(const char *name, EventHandler handler) {
 	bkt->callbacks.Push(handler);
 }
 
-void UnregisterCallback(const char *name, EventHandler handler) {
+void Event_UnregisterCallback(const char *name, EventHandler handler) {
 	char safeName[16];
 	EventBucket *bkt = nullptr;
 	EventBucketFind(name, safeName, bkt);
@@ -45,7 +45,7 @@ void UnregisterCallback(const char *name, EventHandler handler) {
 	}
 }
 
-void DispatchCabllack(const char *name) {
+void Event_Dispatch(const char *name) {
 	char safeName[16];
 	EventBucket *bkt = nullptr;
 	EventBucketFind(name, safeName, bkt);
diff --git a/src/event.hpp b/src/event.hpp
index 505d82a..b7a5ffa 100644
--- a/src/event.hpp
+++ b/src/event.hpp
@@ -10,8 +10,8 @@
 
 typedef void (*EventHandler)();
 
-void RegisterCallback(const char *name, EventHandler handler);
-void UnregisterCallback(const char *name, EventHandler handler);
-void DispatchCabllack(const char *name);
+void Event_RegisterCallback(const char *name, EventHandler handler);
+void Event_UnregisterCallback(const char *name, EventHandler handler);
+void Event_Dispatch(const char *name);
 
 #endif /* PKE_EVENT_HPP */
diff --git a/src/game.cpp b/src/game.cpp
index a48cbfe..f870591 100644
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -10,7 +10,7 @@ const uint64_t consoleLineLength = 128;
 char consoleBuffer[consoleBufferCount][consoleLineLength];
 long consoleBufferIndex = 0;
 
-void GameTick(double delta) {
+void Game_Tick(double delta) {
 	/*
 	 * ECS_Tick() gets called first because it updates the public
 	 *  `EntitiesToBeRemoved` for all other ticks to use.
@@ -55,9 +55,9 @@ void RecordImGuiEditor() {
 	RecordImGuiConsole(&pkeSettings.isShowingEditor);
 }
 
-void GameInit() {
+void Game_Init() {
 	for (long i = 0; i < consoleBufferCount; ++i) {
 		memset(consoleBuffer[i], '\0', consoleLineLength);
 	}
-	RegisterCallback("RenderImGui", RecordImGuiEditor);
+	Event_RegisterCallback("RenderImGui", RecordImGuiEditor);
 }
diff --git a/src/game.hpp b/src/game.hpp
index 7159e0c..d8e1833 100644
--- a/src/game.hpp
+++ b/src/game.hpp
@@ -26,7 +26,7 @@ struct GameSettings {
 
 extern GameSettings pkeSettings;
 
-void GameInit();
-void GameTick(double delta);
+void Game_Init();
+void Game_Tick(double delta);
 
 #endif /* PKE_GAME_HPP */
diff --git a/src/main.cpp b/src/main.cpp
index b99aca2..9a4bfda 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -19,7 +19,7 @@ void signal_handler(int signal_num) {
 PKEWindowProperties windowProps{};
 
 void Tick(double delta) {
-	GameTick(delta);
+	Game_Tick(delta);
 }
 
 int main() { 
@@ -27,8 +27,8 @@ int main() {
 
 	printf("PKE ENTERING\n");
 	try {
-		AssetManagerInit();
-		GameInit();
+		AM_Init();
+		Game_Init();
 		ECS_Init();
 		CreateWindow(&windowProps);
 
diff --git a/src/memory.cpp b/src/memory.cpp
index 7670b2f..064cad4 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -1,7 +1,7 @@
 
 #include "memory.hpp"
 
-struct pke::MemBucket {
+struct MemBucket {
 	int64_t size;
 	int64_t head;
 	int64_t free;
@@ -10,7 +10,7 @@ struct pke::MemBucket {
 	char * ptr;
 };
 
-pke::MemBucket buckets[128];
+MemBucket buckets[128];
 int64_t bucketHead = 0;
 
 int64_t InitNewBucket(int64_t sz, bool transient = false) {
@@ -23,7 +23,7 @@ int64_t InitNewBucket(int64_t sz, bool transient = false) {
 	return bucketHead++;
 }
 
-void DestroyBucket(pke::MemBucket *bkt) {
+void DestroyBucket(MemBucket *bkt) {
 	std::free(bkt->ptr);
 	bkt->size = 0;
 	bkt->head = 0;
@@ -33,14 +33,14 @@ void DestroyBucket(pke::MemBucket *bkt) {
 	bkt->ptr = CAFE_BABE(char);
 }
 
-void *pke::PkeNew(std::size_t sz, pke::MemBucket *bkt) {
+void *Pke_New(std::size_t sz, MemBucket *bkt) {
 	void *ptr = bkt->ptr + bkt->head;
 	bkt->head += sz;
 	bkt->allocs++;
 	return ptr;
 }
 
-void *pke::PkeNew(std::size_t sz) {
+void *Pke_New(std::size_t sz) {
 	MemBucket *bkt = nullptr;
 	for (long i = 0; i < bucketHead; ++i) {
 		if (buckets[i].transient == false && buckets[i].size - buckets[i].head > sz) {
@@ -50,10 +50,10 @@ void *pke::PkeNew(std::size_t sz) {
 	if (bkt == nullptr) {
 		bkt = &buckets[InitNewBucket(DEFAULT_BUCKET_SIZE)];
 	}
-	return PkeNew(sz, bkt);
+	return Pke_New(sz, bkt);
 }
 
-void pke::PkeDelete(const void *ptr, std::size_t sz, pke::MemBucket *bkt) {
+void Pke_Delete(const void *ptr, std::size_t sz, MemBucket *bkt) {
 	assert(ptr >= bkt->ptr && ptr < bkt->ptr + bkt->size && "pointer not in bucket range");
 	bkt->allocs--;
 	bkt->free += sz;
@@ -64,8 +64,8 @@ void pke::PkeDelete(const void *ptr, std::size_t sz, pke::MemBucket *bkt) {
 	}
 }
 
-void pke::PkeDelete(const void *ptr, std::size_t sz) {
-	pke::MemBucket *bkt = nullptr;
+void Pke_Delete(const void *ptr, std::size_t sz) {
+	MemBucket *bkt = nullptr;
 	for (long i = 0; i < bucketHead; ++i) {
 		bkt = &buckets[i];
 		if (ptr >= bkt->ptr && ptr < bkt->ptr + bkt->size) break;
@@ -74,14 +74,14 @@ void pke::PkeDelete(const void *ptr, std::size_t sz) {
 		std::printf("bad pointer %llu", reinterpret_cast<unsigned long long>(ptr));
 		throw "bad pointer";
 	}
-	PkeDelete(ptr, sz, bkt);
+	Pke_Delete(ptr, sz, bkt);
 }
 
-pke::MemBucket *pke::BeginTransientBucket(int64_t sz) {
+MemBucket *BeginTransientBucket(int64_t sz) {
 	return &buckets[InitNewBucket(sz, true)];
 }
 
-void pke::EndTransientBucket(pke::MemBucket *bkt) {
+void EndTransientBucket(MemBucket *bkt) {
 	int64_t foundIndex = -1;
 	for (int64_t i = 0; i < bucketHead; ++i) {
 		if (&buckets[i] == bkt) {
@@ -95,7 +95,7 @@ void pke::EndTransientBucket(pke::MemBucket *bkt) {
 	}
 }
 
-void pke::Flush() {
+void Flush() {
 	for (long i = bucketHead - 2; i > -1; --i) {
 		if (buckets[i].head != 0) break;
 		if (buckets[i+1].head != 0) break;
@@ -116,9 +116,9 @@ uint64_t Buckets_NewHandle(std::size_t bucketBytes, uint64_t bucketItemCount, ui
 	}
 	if (bucketCounter > bucketIncrementer) {
 		int64_t newIncrement = bucketIncrementer * 1.5;
-		char * newBuckets = reinterpret_cast<char *>(pke::PkeNew(bucketBytes * newIncrement));
+		char * newBuckets = reinterpret_cast<char *>(Pke_New(bucketBytes * newIncrement));
 		std::memcpy(newBuckets, buckets, bucketBytes * bucketIncrementer);
-		pke::PkeDelete(buckets, bucketBytes * bucketIncrementer);
+		Pke_Delete(buckets, bucketBytes * bucketIncrementer);
 		buckets = newBuckets;
 		bucketIncrementer = newIncrement;
 	}
diff --git a/src/memory.hpp b/src/memory.hpp
index 74e72a3..329be51 100644
--- a/src/memory.hpp
+++ b/src/memory.hpp
@@ -11,39 +11,34 @@
 
 #define DEFAULT_BUCKET_SIZE 1UL << 27
 
-namespace pke
-{
-
 struct MemBucket;
 
-void *PkeNew(std::size_t sz);
-void *PkeNew(std::size_t sz, MemBucket *bkt);
-void PkeDelete(const void *ptr, std::size_t sz);
-void PkeDelete(const void *ptr, std::size_t sz, MemBucket *bkt);
+void *Pke_New(std::size_t sz);
+void *Pke_New(std::size_t sz, MemBucket *bkt);
+void Pke_Delete(const void *ptr, std::size_t sz);
+void Pke_Delete(const void *ptr, std::size_t sz, MemBucket *bkt);
 
-MemBucket *BeginTransientBucket(int64_t sz = DEFAULT_BUCKET_SIZE); // 256MB
-void EndTransientBucket(MemBucket *bkt);
-void Flush();
+MemBucket *Pke_BeginTransientBucket(int64_t sz = DEFAULT_BUCKET_SIZE); // 256MB
+void Pke_EndTransientBucket(MemBucket *bkt);
+void Pke_MemoryFlush();
 
 template <typename T>
-inline T *PkeNew() {
-	return reinterpret_cast<T *>(PkeNew(sizeof(T)));
+inline T *Pke_New() {
+	return reinterpret_cast<T *>(Pke_New(sizeof(T)));
 }
 template <typename T>
-inline T *PkeNew(long count) {
-	return reinterpret_cast<T *>(PkeNew(sizeof(T) * count));
+inline T *Pke_New(long count) {
+	return reinterpret_cast<T *>(Pke_New(sizeof(T) * count));
 }
 template <typename T>
-inline void PkeDelete(const void *ptr) {
-	return PkeDelete(ptr, sizeof(T));
+inline void Pke_Delete(const void *ptr) {
+	return Pke_Delete(ptr, sizeof(T));
 }
 template <typename T>
-inline void PkeDelete(const void *ptr, long count) {
-	return PkeDelete(ptr, sizeof(T) * count);
+inline void Pke_Delete(const void *ptr, long count) {
+	return Pke_Delete(ptr, sizeof(T) * count);
 }
 
-} /* pke */ 
-
 uint64_t Buckets_NewHandle(std::size_t bucketBytes, uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, void*& buckets);
 
 template <typename T> inline uint64_t Buckets_NewHandle(uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, T*& buckets) {
diff --git a/src/vendor/stb_image_include.hpp b/src/vendor/stb_image_include.hpp
index cfea99a..bd8658c 100644
--- a/src/vendor/stb_image_include.hpp
+++ b/src/vendor/stb_image_include.hpp
@@ -1,7 +1,7 @@
-#ifndef PKE_VENDOR_STB_IMAGE_INCLUDE_HPP
-#define PKE_VENDOR_STB_IMAGE_INCLUDE_HPP
+#ifndef PKE_STB_IMAGE_INCLUDE_HPP
+#define PKE_STB_IMAGE_INCLUDE_HPP
 
 #include "stb_image.h"
 #include "stb_image_write.h"
 
-#endif /* PKE_VENDOR_STB_IMAGE_INCLUDE_HPP */
+#endif /* PKE_STB_IMAGE_INCLUDE_HPP */
diff --git a/src/window.cpp b/src/window.cpp
index a4fc5a2..eb2ecff 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -106,7 +106,7 @@ unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, short hasPresentSuppo
 
 	unsigned int queueFamilyPropertyCount = 0U;
 	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, nullptr);
-	auto *queueFamilyProperties = pke::PkeNew<VkQueueFamilyProperties>(queueFamilyPropertyCount);
+	auto *queueFamilyProperties = Pke_New<VkQueueFamilyProperties>(queueFamilyPropertyCount);
 	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, queueFamilyProperties);
 
 	for (unsigned int i = 0; i < queueFamilyPropertyCount; i++) {
@@ -126,7 +126,7 @@ unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, short hasPresentSuppo
 		return i;
 	}
 
-	pke::PkeDelete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
+	Pke_Delete<VkQueueFamilyProperties>(queueFamilyProperties, queueFamilyPropertyCount);
 	return 0xFFFFFFFF;
 }
 
@@ -135,13 +135,13 @@ void InitVulkan() {
 	if (ENABLE_VALIDATION_LAYERS) {
 		unsigned int layerCount;
 		vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
-		VkLayerProperties *availableLayerProperties = pke::PkeNew<VkLayerProperties>(layerCount);
+		VkLayerProperties *availableLayerProperties = Pke_New<VkLayerProperties>(layerCount);
 		vkEnumerateInstanceLayerProperties(&layerCount, availableLayerProperties);
 		printf("Available Layers:\n");
 		for (long i = 0; i < layerCount; ++i) {
 			printf("\t%s\n", availableLayerProperties[i].layerName);
 		}
-		pke::PkeDelete<VkLayerProperties>(availableLayerProperties, layerCount);
+		Pke_Delete<VkLayerProperties>(availableLayerProperties, layerCount);
 	}
 
 	VkApplicationInfo appInfo{};
@@ -205,13 +205,13 @@ void InitVulkan() {
 	if (ENABLE_VALIDATION_LAYERS) {
 		unsigned int extensionCount = 0;
 		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
-		auto *extensions = pke::PkeNew<VkExtensionProperties>(extensionCount);
+		auto *extensions = Pke_New<VkExtensionProperties>(extensionCount);
 		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions);
 		printf("Available Extensions:\n");
 		for (long i = 0; i < extensionCount; ++i) {
 			printf("\t%s\n", extensions[i].extensionName);
 		}
-		pke::PkeDelete<VkExtensionProperties>(extensions, extensionCount);
+		Pke_Delete<VkExtensionProperties>(extensions, extensionCount);
 	}
 
 	auto result = vkCreateInstance(&createInfo, nullptr, &vkInstance); 
@@ -249,7 +249,7 @@ void InitVulkan() {
 	unsigned int physicalDeviceCount = 0;
 	vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, nullptr);
 	assert(physicalDeviceCount > 0);
-	auto *physicalDevices = pke::PkeNew<VkPhysicalDevice>(physicalDeviceCount);
+	auto *physicalDevices = Pke_New<VkPhysicalDevice>(physicalDeviceCount);
 	vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices);
 	graphicsFamilyIndex = 0;
 	presentFamilyIndex = 0;
@@ -267,7 +267,7 @@ void InitVulkan() {
 		std::vector<const char *> requiredExtensions(REQUIRED_EXTENSIONS.begin(), REQUIRED_EXTENSIONS.end());
 		unsigned int extensionCount = 0;
 		vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
-		auto *extensionProperties = pke::PkeNew<VkExtensionProperties>(extensionCount);
+		auto *extensionProperties = Pke_New<VkExtensionProperties>(extensionCount);
 		vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, extensionProperties);
 		for (long k = 0; k < extensionCount; ++k) {
 			const auto &property = extensionProperties[k];
@@ -280,7 +280,7 @@ void InitVulkan() {
 				}
 			}
 		}
-		pke::PkeDelete<VkExtensionProperties>(extensionProperties, extensionCount);
+		Pke_Delete<VkExtensionProperties>(extensionProperties, extensionCount);
 		if (requiredExtensions.empty() == false) {
 			continue;
 		}
@@ -305,7 +305,7 @@ void InitVulkan() {
 		break;
 	}
 	assert(vkPhysicalDevice != nullptr && "Failed to find suitable physical device");
-	pke::PkeDelete<VkPhysicalDevice>(physicalDevices, physicalDeviceCount);
+	Pke_Delete<VkPhysicalDevice>(physicalDevices, physicalDeviceCount);
 
 	// Create logical device
 	{
@@ -406,7 +406,7 @@ void CreateSwapchain() {
 	if (selectedSurfaceIndex == -1u) {
 		unsigned int surfaceFormatCounts;
 		vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, nullptr);
-		VkSurfaceFormatKHR *surfaceFormats = pke::PkeNew<VkSurfaceFormatKHR>(surfaceFormatCounts);
+		VkSurfaceFormatKHR *surfaceFormats = Pke_New<VkSurfaceFormatKHR>(surfaceFormatCounts);
 		vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, surfaceFormats);
 		selectedSurfaceIndex = 0;
 		for (long i = 0; i < surfaceFormatCounts; ++i) {
@@ -418,7 +418,7 @@ void CreateSwapchain() {
 			break;
 		}
 
-		pke::PkeDelete<VkSurfaceFormatKHR>(surfaceFormats, surfaceFormatCounts);
+		Pke_Delete<VkSurfaceFormatKHR>(surfaceFormats, surfaceFormatCounts);
 	}
 
 	int width, height;
@@ -434,7 +434,7 @@ void CreateSwapchain() {
 	if (selectedPresentIndex == -1u) {
 		unsigned int presentModeCount = 0;
 		vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, nullptr);
-		VkPresentModeKHR *presentModes = pke::PkeNew<VkPresentModeKHR>(presentModeCount);
+		VkPresentModeKHR *presentModes = Pke_New<VkPresentModeKHR>(presentModeCount);
 		vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, presentModes);
 		unsigned long mailboxIndex = -1;
 		unsigned long fifoRelaxedIndex = -1;
@@ -447,7 +447,7 @@ void CreateSwapchain() {
 		}
 		selectedPresentIndex = mailboxIndex != -1ul ? mailboxIndex : fifoRelaxedIndex;
 		vkPresentModeKHR = presentModes[selectedPresentIndex];
-		pke::PkeDelete<VkPresentModeKHR>(presentModes, presentModeCount);
+		Pke_Delete<VkPresentModeKHR>(presentModes, presentModeCount);
 	}
 
 	VkSwapchainCreateInfoKHR vkSwapchainCreateInfo{};
@@ -500,9 +500,9 @@ void CreateSwapchain() {
 	vkImageViewCreateInfo.subresourceRange = vkImageSubresourceRange;
 
 	vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, nullptr);
-	swapchainImages = pke::PkeNew<VkImage>(swapchainLength);
+	swapchainImages = Pke_New<VkImage>(swapchainLength);
 	vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, swapchainImages);
-	swapchainImageViews = pke::PkeNew<VkImageView>(swapchainLength);
+	swapchainImageViews = Pke_New<VkImageView>(swapchainLength);
 	for (long i = 0; i < swapchainLength; ++i) {
 		vkImageViewCreateInfo.image = swapchainImages[i];
 		vkCreateImageView(vkDevice, &vkImageViewCreateInfo, vkAllocator, &swapchainImageViews[i]);
@@ -563,8 +563,8 @@ void CreateRenderPass() {
 }
 
 void CreateGraphicsPipeline() {
-	AssetHandle vertShaderAsset = RegisterAsset("assets/shaders/present.vert.spv");
-	AssetHandle fragShaderAsset = RegisterAsset("assets/shaders/present.frag.spv");
+	AssetHandle vertShaderAsset = AM_Register("assets/shaders/present.vert.spv");
+	AssetHandle fragShaderAsset = AM_Register("assets/shaders/present.frag.spv");
 	auto vertShader = UploadShader(vertShaderAsset);
 	auto fragShader = UploadShader(fragShaderAsset);
 
@@ -788,13 +788,13 @@ void CreateGraphicsPipeline() {
 
 	vkDestroyShaderModule(vkDevice, fragShader, vkAllocator);
 	vkDestroyShaderModule(vkDevice, vertShader, vkAllocator);
-	DestroyAsset(fragShaderAsset);
-	DestroyAsset(vertShaderAsset);
+	AM_Destroy(fragShaderAsset);
+	AM_Destroy(vertShaderAsset);
 }
 
 void CreateFramebuffers() {
 	assert(swapchainFramebuffers == nullptr || swapchainFramebuffers == CAFE_BABE(VkFramebuffer));
-	swapchainFramebuffers = pke::PkeNew<VkFramebuffer>(swapchainLength);
+	swapchainFramebuffers = Pke_New<VkFramebuffer>(swapchainLength);
 
 	VkFramebufferCreateInfo framebufferInfo{};
 	framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
@@ -1009,7 +1009,7 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 		ImGui::DockSpaceOverViewport(nullptr, ImGuiDockNodeFlags_PassthruCentralNode);
 
 		ImGui::ShowDemoWindow();
-		DispatchCabllack("RenderImGui");
+		Event_Dispatch("RenderImGui");
 
 		ImGui::Render();
 		auto drawData = ImGui::GetDrawData();
@@ -1032,14 +1032,14 @@ void DestroySwapchain() {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyFramebuffer(vkDevice, swapchainFramebuffers[i], vkAllocator);
 		}
-		pke::PkeDelete<VkFramebuffer>(swapchainFramebuffers, swapchainLength);
+		Pke_Delete<VkFramebuffer>(swapchainFramebuffers, swapchainLength);
 	}
 	if (swapchainImageViews!= nullptr && swapchainImageViews != CAFE_BABE(VkImageView)) {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyImageView(vkDevice, swapchainImageViews[i], vkAllocator);
 		}
-		pke::PkeDelete<VkImageView>(swapchainImageViews, swapchainLength);
-		pke::PkeDelete<VkImage>(swapchainImages, swapchainLength);
+		Pke_Delete<VkImageView>(swapchainImageViews, swapchainLength);
+		Pke_Delete<VkImage>(swapchainImages, swapchainLength);
 	}
 	vkDestroySwapchainKHR(vkDevice, vkSwapchainKHR, vkAllocator);
 	swapchainImages = CAFE_BABE(VkImage);
@@ -1121,7 +1121,7 @@ void DestroyWindow() {
 }
 
 VkShaderModule UploadShader(AssetHandle handle) {
-	const Asset *asset = GetAsset(handle);
+	const Asset *asset = AM_Get(handle);
 
 	VkShaderModuleCreateInfo createInfo{};
 	createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;