assets are global and stored in the project file

7 files changed, 211 insertions, 79 deletions

diff --git a/editor/editor.cpp b/editor/editor.cpp
index bb19b70..e66f14c 100644
--- a/editor/editor.cpp
+++ b/editor/editor.cpp
@@ -721,12 +721,12 @@ bool RecordImGui_CallbackSelectModal(long &selectedIndex) {
 
 void RecordImGuiModalCreateEntityType() {
 	if (ImGui::BeginPopupModal("CreateEntityType", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
-		static char modelsDir[64];
-		static char modelFile[64];
+		static char modelKey[AssetKeyLength + 1];
+		static char textureKey[AssetKeyLength + 1];
 		static char entityTypeCode[32];
 
-		ImGui::InputText("Models Dir", modelsDir, 63);
-		ImGui::InputText("Model File", modelFile, 63);
+		ImGui::InputText("Model Key", modelKey, AssetKeyLength);
+		ImGui::InputText("Texture Key", textureKey, AssetKeyLength);
 		ImGui::InputText("Entity Type Code", entityTypeCode, 31);
 		ImGui::InputScalar("Starting Instance Count", ImGuiDataType_U32, &entityTypeToCreate.startingInstanceCount);
 		ImGui::InputScalar("GLTF Import Index - Vertex", ImGuiDataType_S16, &entityTypeToCreate.Importer_GLTF.AccessorIndexVertex);
@@ -741,19 +741,15 @@ void RecordImGuiModalCreateEntityType() {
 
 		if (ImGui::Button("Create")) {
 			// TODO some type of validation
-			memset(modelsDir, '\0', 64);
-			memset(modelFile, '\0', 64);
-			memset(entityTypeCode, '\0', 32);
-			// assert(entityTypeToCreate == nullptr || entityTypeToCreate == CAFE_BABE(EntityType));
-			// entityTypeToCreate = Pke_New<EntityType>();
-
-			char *sModelsDir = Pke_New<char>(strlen(modelsDir) + 1);
-			strncpy(sModelsDir, modelsDir, 63);
-			entityTypeToCreate.modelsDir = sModelsDir;
-
-			char *sModelFile = Pke_New<char>(strlen(modelFile) + 1);
-			strncpy(sModelFile, modelFile, 63);
-			entityTypeToCreate.modelFile = sModelFile;
+			modelKey[0] = '\0';
+			textureKey[0] = '\0';
+			entityTypeCode[0] = '\0';
+			modelKey[AssetKeyLength] = '\0';
+			textureKey[AssetKeyLength] = '\0';
+			entityTypeCode[31] = '\0';
+
+			strncpy(entityTypeToCreate.modelAssetKey, modelKey, AssetKeyLength);
+			strncpy(entityTypeToCreate.textureAssetKey, textureKey, AssetKeyLength);
 
 			char *sEntityTypeCode = Pke_New<char>(strlen(entityTypeCode) + 1);
 			strncpy(sEntityTypeCode, entityTypeCode, 31);
diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp
index 9fda1c1..b93a568 100644
--- a/src/asset-manager.cpp
+++ b/src/asset-manager.cpp
@@ -37,17 +37,37 @@ void AM_Load_Task(Asset &asset) {
 	asset.state = PKE_ASSET_LOADING_STATE_LOADED;
 }
 
-AssetHandle AM_Register(const void *data, int64_t size, std::size_t alignment, const char *key) {
+inline Asset *AM_Get_Inner(AssetKey key) {
+	for (long b = 0; b <= Asset_BucketContainer.pkeHandle.bucketIndex; ++b) {
+		uint64_t count = 0;
+		if (b == Asset_BucketContainer.pkeHandle.bucketIndex) {
+			count = Asset_BucketContainer.pkeHandle.itemIndex;
+		} else {
+			count = maxAssetItemsPerBucket;
+		}
+		for (long i = 0; i < count; ++i) {
+			if (strncmp(key, Asset_BucketContainer.buckets[b].assets[i].key, 16) == 0) {
+				return &Asset_BucketContainer.buckets[b].assets[i];
+			}
+		}
+	}
+	return nullptr;
+}
+
+AssetHandle AM_Register(AssetKey key, const void *data, int64_t size, std::size_t alignment) {
 	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");
+	Asset *searchedAsset = AM_Get_Inner(key);
+	if (searchedAsset != nullptr) {
+		return searchedAsset->handle;
+	}
 	bool moved;
 	AssetHandle assetHandle{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
 	Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
 	new (&asset) Asset{};
-	int64_t keyLen = strlen(key);
-	int64_t keyOffset = (keyLen > 16 ? keyLen - 16 : 0);
-	strncpy(asset.key, key + keyOffset, 16);
+	asset.handle = assetHandle;
+	strncpy(asset.key, key, AssetKeyLength);
 	asset.basePath = nullptr;
 	asset.size = size;
 	asset.ptr = Pke_New(size, alignment);
@@ -56,14 +76,49 @@ AssetHandle AM_Register(const void *data, int64_t size, std::size_t alignment, c
 	return assetHandle;
 }
 
-AssetHandle AM_Register(const char *path) {
+AssetHandle AM_Register(AssetKey key, const char *path) {
+	Asset *searchedAsset = AM_Get_Inner(key);
+	if (searchedAsset != nullptr) {
+		return searchedAsset->handle;
+	}
 	bool moved = false;
 	AssetHandle assetHandle{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
 	Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
 	new (&asset) Asset{};
+	asset.handle = assetHandle;
+	strncpy(asset.key, key, AssetKeyLength);
+	int64_t pathLen = strlen(path);
+	auto *copiedPath = Pke_New<char>(pathLen + 1);
+	copiedPath[pathLen] = '\0';
+	strncpy(copiedPath, path, pathLen);
+	asset.basePath = copiedPath;
+	asset.state = PKE_ASSET_LOADING_STATE_LOADING;
+	std::packaged_task<void()> *task = Pke_New<std::packaged_task<void()>>();
+	new (task) std::packaged_task<void()>( [&asset] {
+		AM_Load_Task(asset);
+	});
+	asset.future = task->get_future();
+	PkeThreads_Enqueue(assetThreadPool, task);
+	return assetHandle;
+}
+
+AssetHandle AM_Register(const char *path) {
+	NULL_CHAR_ARR(assetKey, AssetKeyLength);
 	int64_t pathLen = strlen(path);
-	int64_t pathOffset = (pathLen > 16 ? pathLen - 16 : 0);
-	strncpy(asset.key, path + pathOffset, 16);
+	int64_t pathOffset = (pathLen > AssetKeyLength ? pathLen - AssetKeyLength : 0);
+	strncpy(assetKey, path + pathOffset, AssetKeyLength);
+
+	Asset *searchedAsset = AM_Get_Inner(assetKey);
+	if (searchedAsset != nullptr) {
+		return searchedAsset->handle;
+	}
+
+	bool moved = false;
+	AssetHandle assetHandle{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
+	Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
+	new (&asset) Asset{};
+	asset.handle = assetHandle;
+	strncpy(asset.key, assetKey, AssetKeyLength);
 	auto *copiedPath = Pke_New<char>(pathLen + 1);
 	copiedPath[pathLen] = '\0';
 	strncpy(copiedPath, path, pathLen);
@@ -120,6 +175,27 @@ const Asset *AM_Get(AssetHandle assetHandle) {
 	return &asset;
 }
 
+const AssetHandle AM_GetHandle(AssetKey key) {
+	Asset *searchedAsset = AM_Get_Inner(key);
+	if (searchedAsset != nullptr) {
+		return searchedAsset->handle;
+	}
+	return AssetHandle_MAX;
+}
+
+uint64_t AM_GetBucketCount() {
+	return Asset_BucketContainer.pkeHandle.bucketIndex + 1;
+}
+
+Asset *AM_GetAssets(uint64_t bucketIndex, uint64_t &itemCount) {
+	if (bucketIndex == Asset_BucketContainer.pkeHandle.bucketIndex) {
+		itemCount = Asset_BucketContainer.pkeHandle.itemIndex;
+	} else {
+		itemCount = maxAssetItemsPerBucket;
+	}
+	return Asset_BucketContainer.buckets[bucketIndex].assets;
+}
+
 void AM_DebugPrint() {
 	printf("Asset Manager printout:\n");
 	for (uint64_t b = 0; b <= Asset_BucketContainer.pkeHandle.bucketIndex; ++b) {
diff --git a/src/asset-manager.hpp b/src/asset-manager.hpp
index 36516b5..71e95f5 100644
--- a/src/asset-manager.hpp
+++ b/src/asset-manager.hpp
@@ -13,13 +13,17 @@ constexpr AssetHandle AssetHandle_MAX = AssetHandle{};
 
 TypeSafeInt_Const_Expr(AssetLoadingState, uint8_t, 0xFF);
 
+const int64_t AssetKeyLength = 16;
+using AssetKey = char[AssetKeyLength];
+
 const AssetLoadingState PKE_ASSET_LOADING_STATE_UNLOADED = AssetLoadingState {0};
 const AssetLoadingState PKE_ASSET_LOADING_STATE_LOADING = AssetLoadingState  {1};
 const AssetLoadingState PKE_ASSET_LOADING_STATE_LOADED = AssetLoadingState   {2};
 const AssetLoadingState PKE_ASSET_LOADING_STATE_FAILED = AssetLoadingState   {3};
 
 struct Asset{
-	char key[16] = {'\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'};
+	AssetHandle handle{};
+	AssetKey key = {'\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'};
 	const char *basePath = nullptr;
 	int64_t size = 0;
 	void *ptr = nullptr;
@@ -31,8 +35,12 @@ struct Asset{
 void AM_Init();
 AssetHandle AM_Register(const void *data, int64_t size, std::size_t alignment, const char *key);
 AssetHandle AM_Register(const char *path);
+AssetHandle AM_Register(AssetKey key, const char *path);
 void AM_Release(AssetHandle assetHandle);
 const Asset *AM_Get(AssetHandle assetHandle);
+const AssetHandle AM_GetHandle(AssetKey key);
+uint64_t AM_GetBucketCount();
+Asset *AM_GetAssets(uint64_t bucketIndex, uint64_t &itemCount);
 void AM_Teardown();
 void AM_DebugPrint();
 
diff --git a/src/entities.cpp b/src/entities.cpp
index 24cdd29..8d4fdb7 100644
--- a/src/entities.cpp
+++ b/src/entities.cpp
@@ -7,6 +7,7 @@
 
 #include <BulletCollision/CollisionShapes/btConvexHullShape.h>
 #include <BulletCollision/CollisionShapes/btConvexPolyhedron.h>
+#include <filesystem>
 #include <vulkan/vulkan_core.h>
 
 DynArray<EntityType> GlobalEntityTypes{16};
@@ -71,12 +72,9 @@ void CalculateCombinedMemReqs(uint64_t memReqsCount, VkMemoryRequirements *memRe
 
 void EntityType_Load(EntityType &et) {
 	assert(et.startingInstanceCount > 0);
-	if (et.modelFile != nullptr && et.modelFile != CAFE_BABE(char)) {
-
-		char modelPath[128];
-		memset(modelPath, '\0', 128);
-		snprintf(modelPath, 128, "%s/%s", et.modelsDir, et.modelFile);
-		AssetHandle assetHandle{AM_Register(modelPath)};
+	AssetHandle assetHandle{AM_GetHandle(et.modelAssetKey)};
+	AssetHandle textureAssetHandle{AM_GetHandle(et.textureAssetKey)};
+	if (assetHandle != AssetHandle_MAX) {
 		const Asset *asset = AM_Get(assetHandle);
 
 		CompGrBinds &grBinds = ECS_CreateGrBinds(et.entityHandle);
@@ -94,19 +92,20 @@ void EntityType_Load(EntityType &et) {
 		cgltf_data *gltfData = nullptr;
 		cgltf_result result = cgltf_parse(&options, asset->ptr, asset->size, &gltfData);
 		assert(result == cgltf_result_success);
-		result = cgltf_load_buffers(&options, gltfData, modelPath);
-		assert(result == cgltf_result_success);
+		// result = cgltf_load_buffers(&options, gltfData, modelPath);
+		// assert(result == cgltf_result_success);
 		result = cgltf_validate(gltfData);
 		assert(result == cgltf_result_success);
-		assert(gltfData->images_count < 2);
+		assert(gltfData->buffers_count == 1);
 
-		if (gltfData->images_count == 1) {
-			char imagePath[128];
-			memset(imagePath, '\0', 128);
-			snprintf(imagePath, 128, "%s/%s", et.modelsDir, gltfData->images[0].uri);
+		std::filesystem::path gltfPath{asset->basePath};
+		gltfPath.replace_filename(gltfData->buffers[0].uri);
+		AssetHandle modelBinHandle = AM_Register(gltfPath.c_str());
 
+		if (textureAssetHandle != AssetHandle_MAX) {
+			const Asset *textureAsset = AM_Get(textureAssetHandle);
 			int pixelWidth, pixelHeight, pixelChannels;
-			auto *pixels = stbi_load(imagePath, &pixelWidth, &pixelHeight, &pixelChannels, STBI_rgb_alpha);
+			auto *pixels = stbi_load_from_memory(static_cast<stbi_uc *>(textureAsset->ptr), textureAsset->size, &pixelWidth, &pixelHeight, &pixelChannels, STBI_rgb_alpha);
 			assert(pixels != nullptr && "sbti_load failed to load image.");
 
 			uint32_t imageSizeBytes = pixelWidth * pixelHeight * pixelChannels;
@@ -309,7 +308,9 @@ void EntityType_Load(EntityType &et) {
 				vkQueueWaitIdle(graphicsQueue);
 			}
 
-			stbi_image_free(pixels);
+			// TODO double-check this?
+			// stbi_image_free(pixels);
+			AM_Release(textureAssetHandle);
 
 			// descriptor pool & sets
 
@@ -532,6 +533,7 @@ void EntityType_Load(EntityType &et) {
 		runningOffset += sizeIndex;
 
 		assert(runningOffset == combinedMemReqs.size);
+		const Asset *modelBinAsset = AM_Get(modelBinHandle);
 
 		// create transfer items && transfer
 		{
@@ -545,19 +547,19 @@ void EntityType_Load(EntityType &et) {
 			char *srcPtr = nullptr;
 
 			dstPtr = static_cast<char *>(data) + offsetVert;
-			srcPtr = static_cast<char *>(gltfData->buffers[0].data) + accVert.buffer_view->offset;
+			srcPtr = static_cast<char *>(modelBinAsset->ptr) + accVert.buffer_view->offset;
 			memcpy(dstPtr, srcPtr, accVert.buffer_view->size);
 
 			dstPtr = static_cast<char *>(data) + offsetNorm;
-			srcPtr = static_cast<char *>(gltfData->buffers[0].data) + accNorm.buffer_view->offset;
+			srcPtr = static_cast<char *>(modelBinAsset->ptr) + accNorm.buffer_view->offset;
 			memcpy(dstPtr, srcPtr, accNorm.buffer_view->size);
 
 			dstPtr = static_cast<char *>(data) + offsetUV;
-			srcPtr = static_cast<char *>(gltfData->buffers[0].data) + accUV.buffer_view->offset;
+			srcPtr = static_cast<char *>(modelBinAsset->ptr) + accUV.buffer_view->offset;
 			memcpy(dstPtr, srcPtr, accUV.buffer_view->size);
 
 			dstPtr = static_cast<char *>(data) + offsetIndex;
-			srcPtr = static_cast<char *>(gltfData->buffers[0].data) + accIndex.buffer_view->offset;
+			srcPtr = static_cast<char *>(modelBinAsset->ptr) + accIndex.buffer_view->offset;
 			memcpy(dstPtr, srcPtr, accIndex.buffer_view->size);
 
 			VkCommandBufferBeginInfo vkCommandBufferBeginInfo;
@@ -627,7 +629,7 @@ void EntityType_Load(EntityType &et) {
 		btConvexHullShape *shape;
 		{
 			shape = Pke_New<btConvexHullShape>(MemBkt_Bullet);
-			btScalar *vertDataPointer = reinterpret_cast<btScalar *>(accVert.buffer_view->buffer->data);
+			btScalar *vertDataPointer = reinterpret_cast<btScalar *>(modelBinAsset->ptr);
 			vertDataPointer += accVert.buffer_view->offset;
 			new (shape) btConvexHullShape(vertDataPointer, accVert.count, accVert.stride);
 			shape->optimizeConvexHull();
@@ -636,6 +638,9 @@ void EntityType_Load(EntityType &et) {
 		}
 		assert(shape != nullptr);
 
+		modelBinAsset = CAFE_BABE(Asset);
+		AM_Release(modelBinHandle);
+
 		// set up convex hull debug
 		{
 			const btConvexPolyhedron *pol = shape->getConvexPolyhedron();
@@ -846,7 +851,7 @@ void EntityType_Load(EntityType &et) {
 		}
 
 		// cleanup
-		cgltf_free(gltfData);
+		// cgltf_free(gltfData);
 		AM_Release(assetHandle);
 	}
 }
@@ -960,7 +965,7 @@ void EntityType_RolloverInstances(EntityType &et, CompGrBinds &grBinds) {
 void EntityType_Teardown() {
 	long entityTypeCount = GlobalEntityTypes.Count();
 	for (long i = 0; i < entityTypeCount; ++i) {
-		if (GlobalEntityTypes[i].modelFile == nullptr) continue;
+		if (GlobalEntityTypes[i].modelAssetKey[0] == '\0') continue;
 		auto *et = &GlobalEntityTypes[i];
 		auto *grBinds = ECS_GetGrBinds(GlobalEntityTypes[i].entityHandle);
 		if (grBinds->vkDescriptorSets != nullptr && et->vkDescriptorPool != VK_NULL_HANDLE) {
@@ -1003,10 +1008,6 @@ void EntityType_Teardown() {
 			vkFreeMemory(vkDevice, et->deviceMemoryPhysVert, vkAllocator);
 		if (et->deviceMemoryTexture != VK_NULL_HANDLE)
 			vkFreeMemory(vkDevice, et->deviceMemoryTexture, vkAllocator);
-		if (et->modelsDir)
-			Pke_Delete<char>(et->modelsDir, strlen(et->modelsDir));
-		if (et->modelFile)
-			Pke_Delete<char>(et->modelFile, strlen(et->modelFile));
 		if (et->entityTypeCode)
 			Pke_Delete<char>(et->entityTypeCode, strlen(et->entityTypeCode));
 	}
diff --git a/src/entities.hpp b/src/entities.hpp
index 8429d7f..bdcb3eb 100644
--- a/src/entities.hpp
+++ b/src/entities.hpp
@@ -13,8 +13,8 @@
 #include <vulkan/vulkan_core.h>
 
 struct EntityType {
-	const char *modelsDir = nullptr;
-	const char *modelFile = nullptr;
+	AssetKey modelAssetKey;
+	AssetKey textureAssetKey;
 	const char *entityTypeCode = nullptr;
 	EntityHandle entityHandle;
 	GrBindsHandle grBindsHandle = GrBindsHandle_MAX;
diff --git a/src/project.cpp b/src/project.cpp
index 08c7c2a..143f5ab 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -17,14 +17,15 @@ const char* const PKE_PROJ_FILE_VERSION = ":0:";
 const char* const PKE_PROJ_FILE_OBJ_END = "";
 const char* const PKE_PROJ_FILE_OBJ_PROJECT_SETTINGS = "ProjectSettings:";
 const char* const PKE_PROJ_FILE_OBJ_ENTITY_TYPE = "EntityType:";
+const char* const PKE_PROJ_FILE_OBJ_ASSET = "Asset:";
 
 const char* const PKE_PROJ_FILE_PROJ_SETTINGS_DEFAULT_SCENE_NAME = "PkeSet::DefaultSceneName: ";
 const char* const PKE_PROJ_FILE_PROJ_SETTINGS_SCENE_COUNT = "PkeSet::SceneCount: ";
 const char* const PKE_PROJ_FILE_PROJ_SETTINGS_SCENES_BEGIN = "PkeSet::Scenes: [";
 const char* const PKE_PROJ_FILE_PROJ_SETTINGS_SCENES_END = "PkeSet::Scenes: ]";
 
-const char* const PKE_PROJ_FILE_ENTITY_TYPE_MODELS_DIR = "ModelsDir: ";
-const char* const PKE_PROJ_FILE_ENTITY_TYPE_MODEL_FILE = "ModelFile: ";
+const char* const PKE_PROJ_FILE_ENTITY_TYPE_MODEL_ASSET_KEY = "ModelAssetKey: ";
+const char* const PKE_PROJ_FILE_ENTITY_TYPE_TEXTURE_ASSET_KEY = "TextureAssetKey: ";
 const char* const PKE_PROJ_FILE_ENTITY_TYPE_ENTITY_TYPE_CODE = "EntityTypeCode: ";
 const char* const PKE_PROJ_FILE_ENTITY_TYPE_ENTITY_HANDLE = "EntityHandle: ";
 const char* const PKE_PROJ_FILE_ENTITY_TYPE_COLLISION_CALLBACK_SIGNATURE = "CollisionCallbackSignature: ";
@@ -37,6 +38,9 @@ const char* const PKE_PROJ_FILE_ENTITY_TYPE_PHYSICS_STARTING_MASS = "BT::Startin
 const char* const PKE_PROJ_FILE_ENTITY_TYPE_PHYSICS_STARTING_COLLISION_LAYER = "BT::StartingCollisionLayer: ";
 const char* const PKE_PROJ_FILE_ENTITY_TYPE_PHYSICS_STARTING_COLLISION_MASK = "BT::StartingCollisionMask: ";
 
+const char* const PKE_PROJ_FILE_ASSET_KEY = "Asset::Key: ";
+const char* const PKE_PROJ_FILE_ASSET_BASE_PATH = "Asset::BasePath: ";
+
 /*
 void Proj_SerializeProjectSettings(std::ofstream &stream) {
 	PkeProjectSettings ps{};
@@ -59,14 +63,18 @@ void Proj_SerializeProjectSettings(std::ofstream &stream) {
 */
 
 void Proj_SerializeEntityType(std::ofstream &stream, const EntityType &et) {
-	char handleStr[19] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
+	NULL_CHAR_ARR(handleStr, 19);
+	NULL_CHAR_ARR(modelAssetKey, AssetKeyLength + 1);
+	NULL_CHAR_ARR(textureAssetKey, AssetKeyLength + 1);
 	snprintf(handleStr, 19, "0x%016lX", et.entityHandle.hash);
+	snprintf(modelAssetKey, AssetKeyLength + 1, "%s", et.modelAssetKey);
+	snprintf(textureAssetKey, AssetKeyLength + 1, "%s", et.textureAssetKey);
 	EntityType e{};
 	CompGrBinds *grBinds = ECS_GetGrBinds(et.entityHandle);
-	if (et.modelsDir != e.modelsDir)
-		stream << PKE_PROJ_FILE_ENTITY_TYPE_MODELS_DIR << et.modelsDir << std::endl;
-	if (et.modelFile != e.modelFile)
-		stream << PKE_PROJ_FILE_ENTITY_TYPE_MODEL_FILE << et.modelFile << std::endl;
+	if (modelAssetKey[0] != '\0')
+		stream << PKE_PROJ_FILE_ENTITY_TYPE_MODEL_ASSET_KEY << modelAssetKey << std::endl;
+	if (textureAssetKey[0] != '\0')
+		stream << PKE_PROJ_FILE_ENTITY_TYPE_TEXTURE_ASSET_KEY << textureAssetKey << std::endl;
 	if (et.entityTypeCode != e.entityTypeCode)
 		stream << PKE_PROJ_FILE_ENTITY_TYPE_ENTITY_TYPE_CODE << et.entityTypeCode << std::endl;
 	if (et.entityHandle != e.entityHandle)
@@ -94,6 +102,18 @@ void Proj_SerializeEntityType(std::ofstream &stream, const EntityType &et) {
 		stream << PKE_PROJ_FILE_ENTITY_TYPE_PHYSICS_STARTING_COLLISION_MASK << static_cast<PhysicsCollision_T>(et.bt.startingCollisionMask) << std::endl;
 }
 
+void Proj_SerializeAsset(std::ofstream &stream, const Asset &asset) {
+	NULL_CHAR_ARR(keyStr, AssetKeyLength + 1);
+	snprintf(keyStr, AssetKeyLength + 1, "%s", asset.key);
+	Asset a{};
+	if (keyStr[0] != '\0') {
+		stream << PKE_PROJ_FILE_ASSET_KEY << keyStr << std::endl;
+	}
+	if (asset.basePath != nullptr) {
+		stream << PKE_PROJ_FILE_ASSET_BASE_PATH << asset.basePath << std::endl;
+	}
+}
+
 /*
 void Proj_ParseProjectSettings(std::ifstream &stream) {
 	while (stream.getline(projReadLine, projReadLineLength)) {
@@ -143,7 +163,6 @@ void Proj_ParseEntityType(std::ifstream &stream) {
 				continue;
 			}
 			et.entityHandle = ECS_CreateEntity();
-			EntityType_Load(et);
 			GlobalEntityTypes.Push(et);
 			CompGrBinds *grBinds = ECS_GetGrBinds(et.entityHandle);
 			if (grBinds) {
@@ -152,22 +171,14 @@ void Proj_ParseEntityType(std::ifstream &stream) {
 			}
 			return;
 		}
-		if (strstr(projReadLine, PKE_PROJ_FILE_ENTITY_TYPE_MODELS_DIR)) {
-			uint64_t prefixLen = strlen(PKE_PROJ_FILE_ENTITY_TYPE_MODELS_DIR);
-			uint64_t len = strlen(projReadLine + prefixLen) + 1;
-			char *val = Pke_New<char>(len);
-			memset(reinterpret_cast<void *>(val), '\0', len);
-			memcpy(val, projReadLine + prefixLen, len);
-			et.modelsDir = val;
+		if (strstr(projReadLine, PKE_PROJ_FILE_ENTITY_TYPE_MODEL_ASSET_KEY)) {
+			uint64_t prefixLen = strlen(PKE_PROJ_FILE_ENTITY_TYPE_MODEL_ASSET_KEY);
+			strncpy(et.modelAssetKey, projReadLine + prefixLen, AssetKeyLength);
 			continue;
 		}
-		if (strstr(projReadLine, PKE_PROJ_FILE_ENTITY_TYPE_MODEL_FILE)) {
-			uint64_t prefixLen = strlen(PKE_PROJ_FILE_ENTITY_TYPE_MODEL_FILE);
-			uint64_t len = strlen(projReadLine + prefixLen) + 1;
-			char *val = Pke_New<char>(len);
-			memset(reinterpret_cast<void *>(val), '\0', len);
-			memcpy(val, projReadLine + prefixLen, len);
-			et.modelFile = val;
+		if (strstr(projReadLine, PKE_PROJ_FILE_ENTITY_TYPE_TEXTURE_ASSET_KEY)) {
+			uint64_t prefixLen = strlen(PKE_PROJ_FILE_ENTITY_TYPE_TEXTURE_ASSET_KEY);
+			strncpy(et.textureAssetKey, projReadLine + prefixLen, AssetKeyLength);
 			continue;
 		}
 		if (strstr(projReadLine, PKE_PROJ_FILE_ENTITY_TYPE_ENTITY_TYPE_CODE)) {
@@ -245,6 +256,31 @@ void Proj_ParseEntityType(std::ifstream &stream) {
 	}
 }
 
+void Proj_ParseAssset(std::ifstream &stream) {
+	char keyStr[AssetKeyLength + 1];
+	keyStr[AssetKeyLength] = '\0';
+	char basePath[256];
+	basePath[0] = '\0';
+	basePath[255] = '\0';
+	while (stream.getline(projReadLine, projReadLineLength)) {
+		if (strcmp(projReadLine, PKE_PROJ_FILE_OBJ_END) == 0) {
+			AM_Register(keyStr, basePath);
+			return;
+		}
+		if (strstr(projReadLine, PKE_PROJ_FILE_ASSET_KEY) != nullptr) {
+			uint64_t prefixLen = strlen(PKE_PROJ_FILE_ASSET_KEY);
+			strncpy(keyStr, projReadLine + prefixLen, AssetKeyLength);
+			continue;
+		}
+		if (strstr(projReadLine, PKE_PROJ_FILE_ASSET_BASE_PATH) != nullptr) {
+			uint64_t prefixLen = strlen(PKE_PROJ_FILE_ASSET_BASE_PATH);
+			uint64_t strLen = strlen(projReadLine) - prefixLen;
+			strncpy(basePath, projReadLine + prefixLen, strLen + 1);
+			continue;
+		}
+	}
+}
+
 void PkeProject_Load(const char *filePath) {
 	const char *safeFilePath = filePath == nullptr ? PKE_PROJ_DEFAULT_FILENAME : filePath;
 	std::ifstream f(safeFilePath);
@@ -261,6 +297,10 @@ void PkeProject_Load(const char *filePath) {
 			continue;
 		}
 		*/
+		if (strcmp(PKE_PROJ_FILE_OBJ_ASSET, projReadLine) == 0) {
+			Proj_ParseAssset(f);
+			continue;
+		}
 		if (strcmp(PKE_PROJ_FILE_OBJ_ENTITY_TYPE, projReadLine) == 0) {
 			Proj_ParseEntityType(f);
 			continue;
@@ -288,6 +328,17 @@ void PkeProject_Save(const char *filePath) {
 	f << PKE_PROJ_FILE_OBJ_END << std::endl;
 	*/
 
+	auto assetB = AM_GetBucketCount();
+	for (long b = 0; b < assetB; ++b) {
+		uint64_t assetI = 0;
+		auto *assets = AM_GetAssets(b, assetI);
+		for (long i = 0; i < assetI; ++i) {
+			f << PKE_PROJ_FILE_OBJ_ASSET << std::endl;
+			Proj_SerializeAsset(f, assets[i]);
+			f << PKE_PROJ_FILE_OBJ_END << std::endl;
+		}
+	}
+
 	for (long i = 0; i < GlobalEntityTypes.Count(); ++i) {
 		f << PKE_PROJ_FILE_OBJ_ENTITY_TYPE << std::endl;
 		const auto &et = GlobalEntityTypes[i];
diff --git a/src/window.cpp b/src/window.cpp
index 0c881de..8aa241d 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -1048,8 +1048,8 @@ void CreateRenderPass() {
 
 void CreatePresentPipeline() {
 	// enqueue asset loading
-	AssetHandle vertShaderAsset = AM_Register("assets/shaders/present.vert.spv");
-	AssetHandle fragShaderAsset = AM_Register("assets/shaders/present.frag.spv");
+	AssetHandle vertShaderAsset{AM_GetHandle(AssetKey{"pke_prsnt_vrt\0\0"})};
+	AssetHandle fragShaderAsset{AM_GetHandle(AssetKey{"pke_prsnt_frg\0\0"})};
 
 	VkPipelineShaderStageCreateInfo shaderStages[2];
 	for (long i = 0; i < 2; ++i) {
@@ -1501,8 +1501,8 @@ void CreateGraphicsPipelines() {
 	// pipelines
 	{
 		// enqueue asset loading
-		AssetHandle vertShaderAssetHandle = AM_Register("assets/shaders/vert.vert.spv");
-		AssetHandle textureFragShaderAssetHandle = AM_Register("assets/shaders/texture.frag.spv");
+		AssetHandle vertShaderAssetHandle{AM_GetHandle(AssetKey{"pke_txtr_vrt\0\0\0"})};
+		AssetHandle textureFragShaderAssetHandle { AM_GetHandle(AssetKey{"pke_txtr_frg\0\0\0"})};
 
 		const long vertexBindingCount = 4;
 		long index = 0;