read and load custom file type

2 files changed, 144 insertions, 24 deletions

diff --git a/src/game.cpp b/src/game.cpp
index 0a7becd..184ca16 100644
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -1,63 +1,182 @@
 
 #include "game.hpp"
 
+#include <cstring>
+
 GameSettings pkeSettings{};
 
 const uint64_t consoleBufferCount = 30;
 const uint64_t consoleLineLength = 128;
+const long readLineLength = 128;
+char readLine[readLineLength];
 
 const char *levelName = "demo-level";
 
+const char *PKE_FILE_BEGIN = ":PKFB:";
+const char *PKE_FILE_END = ":PKFE:";
+const char *PKE_FILE_VERSION = ":0:";
+const char *PKE_FILE_OBJ_END = "";
+const char *PKE_FILE_OBJ_ENTITY_TYPE = "EntityType:";
+
+const char *PKE_FILE_ENTITY_TYPE_MODELS_DIR = "ModelsDir: ";
+const char *PKE_FILE_ENTITY_TYPE_MODEL_FILE = "ModelFile: ";
+const char *PKE_FILE_ENTITY_TYPE_ENTITY_TYPE_CODE = "EntityTypeCode: ";
+const char *PKE_FILE_ENTITY_TYPE_ENTITY_HANDLE = "EntityHandle: ";
+const char *PKE_FILE_ENTITY_TYPE_STARTING_INSTANCE_COUNT = "StartingInstanceCount: ";
+const char *PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_VERTEX = "Importer_GLTF::AccessorIndexVertex: ";
+const char *PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_NORMAL = "Importer_GLTF::AccessorIndexNormal: ";
+const char *PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_UV = "Importer_GLTF::AccessorIndexUV: ";
+const char *PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_INDEX = "Importer_GLTF::AccessorIndexIndex: ";
+
 char consoleBuffer[consoleBufferCount][consoleLineLength];
 long consoleBufferIndex = 0;
 
-void SerializeEntityType(void *TODO, const EntityType &et) {
+void 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' };
 	snprintf(handleStr, 19, "0x%016lX",static_cast<EntityHandle_T>(et.entityHandle));
-	// TODO
+	EntityType e{};
+	if (et.modelsDir != e.modelsDir)
+		stream << PKE_FILE_ENTITY_TYPE_MODELS_DIR << et.modelsDir << "\n";
+	if (et.modelFile != e.modelFile)
+		stream << PKE_FILE_ENTITY_TYPE_MODEL_FILE << et.modelFile << "\n";
+	if (et.entityTypeCode != e.entityTypeCode)
+		stream << PKE_FILE_ENTITY_TYPE_ENTITY_TYPE_CODE << et.entityTypeCode << "\n";
+	if (et.entityHandle != e.entityHandle)
+		stream << PKE_FILE_ENTITY_TYPE_ENTITY_HANDLE << handleStr << "\n";
+	if (et.startingInstanceCount != e.startingInstanceCount)
+		stream << PKE_FILE_ENTITY_TYPE_STARTING_INSTANCE_COUNT << et.startingInstanceCount << "\n";
+	if (et.Importer_GLTF.AccessorIndexVertex != e.Importer_GLTF.AccessorIndexVertex)
+		stream << PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_VERTEX << et.Importer_GLTF.AccessorIndexVertex << "\n";
+	if (et.Importer_GLTF.AccessorIndexNormal != e.Importer_GLTF.AccessorIndexNormal)
+		stream << PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_NORMAL << et.Importer_GLTF.AccessorIndexNormal << "\n";
+	if (et.Importer_GLTF.AccessorIndexUV != e.Importer_GLTF.AccessorIndexUV)
+		stream << PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_UV << et.Importer_GLTF.AccessorIndexUV << "\n";
+	if (et.Importer_GLTF.AccessorIndexIndex != e.Importer_GLTF.AccessorIndexIndex)
+		stream << PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_INDEX << et.Importer_GLTF.AccessorIndexIndex << "\n";
 }
 
-void ParseEntityType(void *TODO, EntityType *et) { }
+void ParseEntityType(std::ifstream &stream) {
+	EntityType et{};
+	while (stream.getline(readLine, readLineLength)) {
+		if (strcmp(PKE_FILE_OBJ_END, readLine) == 0) {
+			int64_t existingEntityTypeIndex = EntityType_FindByTypeCode(et.entityTypeCode);
+			if (existingEntityTypeIndex != -1) {
+				continue;
+			}
+			et.entityHandle = ECS_CreateEntity();
+			EntityType_Load(et);
+			GlobalEntityTypes.Push(et);
+			return;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_MODELS_DIR)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_MODELS_DIR);
+			uint64_t len = strlen(readLine + prefixLen) + 1;
+			char *val = Pke_New<char>(len);
+			memset(reinterpret_cast<void *>(val), '\0', len);
+			memcpy(val, readLine + prefixLen, len);
+			et.modelsDir = val;
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_MODEL_FILE)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_MODEL_FILE);
+			uint64_t len = strlen(readLine + prefixLen) + 1;
+			char *val = Pke_New<char>(len);
+			memset(reinterpret_cast<void *>(val), '\0', len);
+			memcpy(val, readLine + prefixLen, len);
+			et.modelFile = val;
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_ENTITY_TYPE_CODE)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_ENTITY_TYPE_CODE);
+			uint64_t len = strlen(readLine + prefixLen) + 1;
+			char *val = Pke_New<char>(len);
+			memset(reinterpret_cast<void *>(val), '\0', len);
+			memcpy(val, readLine + prefixLen, len);
+			et.entityTypeCode = val;
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_ENTITY_HANDLE)) {
+			// TODO parse from hex ?
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_ENTITY_HANDLE);
+			EntityHandle_T handle_t;
+			STR2NUM_ERROR result = str2num(handle_t, readLine + prefixLen);
+			assert(result == STR2NUM_ERROR::SUCCESS);
+			et.entityHandle = EntityHandle{handle_t};
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_STARTING_INSTANCE_COUNT)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_STARTING_INSTANCE_COUNT);
+			STR2NUM_ERROR result = str2num(et.startingInstanceCount, readLine + prefixLen);
+			assert(result == STR2NUM_ERROR::SUCCESS);
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_VERTEX)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_VERTEX);
+			STR2NUM_ERROR result = str2num(et.Importer_GLTF.AccessorIndexVertex, readLine + prefixLen);
+			assert(result == STR2NUM_ERROR::SUCCESS);
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_NORMAL)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_NORMAL);
+			STR2NUM_ERROR result = str2num(et.Importer_GLTF.AccessorIndexNormal, readLine + prefixLen);
+			assert(result == STR2NUM_ERROR::SUCCESS);
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_UV)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_UV);
+			STR2NUM_ERROR result = str2num(et.Importer_GLTF.AccessorIndexUV, readLine + prefixLen);
+			assert(result == STR2NUM_ERROR::SUCCESS);
+			continue;
+		}
+		if (strstr(readLine, PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_INDEX)) {
+			uint64_t prefixLen = strlen(PKE_FILE_ENTITY_TYPE_IMPORTER_GLTF_ACCESSOR_INDEX_INDEX);
+			STR2NUM_ERROR result = str2num(et.Importer_GLTF.AccessorIndexIndex, readLine + prefixLen);
+			assert(result == STR2NUM_ERROR::SUCCESS);
+			continue;
+		}
+	}
+}
 
 void SaveSceneFile(const char *sceneFilePath) {
-	// TODO init file
+	std::ofstream f(sceneFilePath);
+	assert(f.is_open());
+
+	f << PKE_FILE_BEGIN << "\n";
+	f << PKE_FILE_VERSION << "\n";
+	f << "" << "\n";
 
 	for (long i = 0; i < GlobalEntityTypes.Count(); ++i) {
+		f << PKE_FILE_OBJ_ENTITY_TYPE << "\n";
 		const auto &et = GlobalEntityTypes[i];
 		const CompGrBinds *grBinds = ECS_GetGrBinds(et.entityHandle);
 		// TODO ignore if no instances
 		if (grBinds == nullptr) {
 			continue;
 		}
-		SerializeEntityType(nullptr, et); // TODO
+		SerializeEntityType(f, et);
+		f << PKE_FILE_OBJ_END << "\n";
 	}
 
-	std::ofstream f(sceneFilePath, std::ios::out);
-	// TODO write to file
+	f << PKE_FILE_END << "\n";
+
 	f.flush();
 	f.close();
 }
 
 void LoadSceneFile(const char *sceneFilePath) {
-	AssetHandle sceneAH = AM_Register(sceneFilePath);
-	const Asset *sceneAsset = AM_Get(sceneAH);
+	std::ifstream f(sceneFilePath);
+	assert(f.is_open());
+	memset(readLine, '\0', readLineLength);
 
-	// EntityTypes
-	{
-		long entityTypeCount = 0; // TODO
-		for (int64_t i = 0; i < entityTypeCount; ++i) {
-			EntityType et{};
-			ParseEntityType(nullptr, &et); // TODO
-			int64_t existingEntityTypeIndex = EntityType_FindByTypeCode(et.entityTypeCode);
-			if (existingEntityTypeIndex != -1) {
-				continue;
-			}
-			et.entityHandle = ECS_CreateEntity();
-			EntityType_Load(et);
+	while (f.getline(readLine, readLineLength)) {
+		// EntityTypes
+		if (strcmp(PKE_FILE_OBJ_ENTITY_TYPE, readLine) == 0) {
+			ParseEntityType(f);
+			continue;
 		}
 	}
 
-	AM_Destroy(sceneAH);
+	f.close();
 }
 
 void Game_Tick(double delta) {
@@ -162,10 +281,10 @@ void RecordImGuiSceneEditor() {
 			return;
 		}
 		if (ImGui::Button("Save")) {
-			SaveSceneFile("test.yaml");
+			SaveSceneFile("test.pstf");
 		}
 		if (ImGui::Button("Load")) {
-			LoadSceneFile("test.yaml");
+			LoadSceneFile("test.pstf");
 		}
 		ImGui::End();
 	}
diff --git a/src/game.hpp b/src/game.hpp
index ec0ba3e..8e2cfaf 100644
--- a/src/game.hpp
+++ b/src/game.hpp
@@ -11,6 +11,7 @@
 #include "event.hpp"
 #include "helpers.hpp"
 #include "imgui.h"
+#include "memory.hpp"
 #include "window.hpp"
 
 using GameTimeDuration = std::chrono::duration<int64_t, std::nano>;