pke: major serialization refactor, first-pass

1 files changed, 96 insertions, 52 deletions

diff --git a/src/serialization-camera.cpp b/src/serialization-camera.cpp
index 714ea2c..963853e 100644
--- a/src/serialization-camera.cpp
+++ b/src/serialization-camera.cpp
@@ -1,6 +1,8 @@
 
 #include "serialization-camera.hpp"
 
+#include "camera.hpp"
+#include "pk.h"
 #include "serialization-component.hpp"
 #include "ecs.hpp"
 #include "math-helpers.hpp"
@@ -8,53 +10,95 @@
 
 #include <BulletCollision/CollisionShapes/btCollisionShape.h>
 
+#include "serialization.hpp"
 #include "vendor-glm-include.hpp"
 
-bool pke_serialize_camera(srlztn_serialize_helper *h, const PkeCamera *cam) {
+pk_handle pke_serialize_camera(srlztn_serialize_helper *h, const PkeCamera *cam) {
 	assert(h != nullptr);
 	assert(cam != nullptr);
+	char *s;
+	pk_handle inst_pos_handle;
+	pke_kve kve{};
+	pke_kve_container kvec{};
+	InstPos baseInst{};
+	btTransform trans;
+	glm::vec3 glm_pos;
+	glm::quat quat_rot;
+	glm::vec3 glm_scale;
+
 	if (PK_HAS_FLAG(cam->entity_flags, ENTITY_FLAG_DO_NOT_SERIALIZE)) {
-		return false;
-	}
-	PkeCamera c{};
-	if (cam->uuid != pk_uuid_zed && cam->uuid != pk_uuid_max) {
-		h->o << SRLZTN_CAMERA_UUID << cam->uuid << std::endl;
-	}
-	if (cam->type != c.type) {
-		h->o << SRLZTN_CAMERA_TYPE << int(static_cast<PkeCameraType_T>(cam->type)) << std::endl;
-	}
-	if (cam->view != c.view) {
-		h->o << SRLZTN_CAMERA_ORIENTATION << int(static_cast<PkeCameraView_T>(cam->view)) << std::endl;
-	}
-	if (cam->phys.target_inst_uuid != pk_uuid_zed) {
-		h->o << SRLZTN_CAMERA_TARGET_INSTANCE_UUID << cam->phys.target_inst_uuid << std::endl;
-	}
-	if (cam->isPrimary != c.isPrimary) {
-		h->o << SRLZTN_CAMERA_IS_PRIMARY << cam->isPrimary << std::endl;
+		return PK_HANDLE_MAX;
 	}
 
 	CompInstance &comp = *ECS_GetInstance(cam->phys.instHandle);
-	InstPos baseInst{};
 	baseInst.posRot = btTransform{};
 	baseInst.posRot.setIdentity();
 	baseInst.scale = btVector3(1, 1, 1);
-	btTransform trans;
 	comp.bt.motionState->getWorldTransform(trans);
 	btVector3 scale = comp.bt.rigidBody->getCollisionShape()->getLocalScaling();
 	btVector3 pos = trans.getOrigin();
 	btQuaternion rot = trans.getRotation();
-
-	glm::vec3 glm_pos;
-	glm::quat quat_rot;
-	glm::vec3 glm_scale;
 	BulletToGlm(pos, glm_pos);
 	BulletToGlm(rot, quat_rot);
 	BulletToGlm(scale, glm_scale);
-	pke_serialize_inst_pos(h, glm_pos, quat_rot, glm_scale);
-	return true;
+	inst_pos_handle = pke_serialize_inst_pos(h, glm_pos, quat_rot, glm_scale);
+
+	kvec.srlztn_handle = h->handle_head;
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_CAMERA);
+	kvec.bkt = h->bkt;
+	kvec.arr.bkt = h->bkt;
+	kvec.children.bkt = h->bkt;
+	kvec.child_handles.bkt = h->bkt;
+	h->handle_head.itemIndex++;
+	pk_arr_append_t(&kvec.child_handles, inst_pos_handle);
+
+	if (cam->uuid != pk_uuid_zed && cam->uuid != pk_uuid_max) {
+		kve.key = SRLZTN_CAMERA_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(cam->uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	{
+		kve.key = SRLZTN_CAMERA_TYPE;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "0x%.2X", static_cast<PkeCameraType_T>(cam->type));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	{
+		kve.key = SRLZTN_CAMERA_ORIENTATION;
+		s = pk_new<char>(5, h->bkt);
+		sprintf(s, "0x%.2X", static_cast<PkeCameraView_T>(cam->view));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	if (cam->phys.target_inst_uuid != pk_uuid_zed) {
+		kve.key = SRLZTN_CAMERA_TARGET_INSTANCE_UUID;
+		s = pk_new<char>(37, h->bkt);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(cam->phys.target_inst_uuid));
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+	if (cam->isPrimary) {
+		kve.key = SRLZTN_CAMERA_IS_PRIMARY;
+		s = pk_new<char>(2, h->bkt);
+		sprintf(s, "%i", cam->isPrimary);
+		kve.val = s;
+		kve.end = SRLZTN_KVE_END;
+		pk_arr_append_t(&kvec.arr, kve);
+	}
+
+	pk_arr_append_t(&h->kvp_containers, kvec);
+	return kvec.srlztn_handle;
 }
 
-bool pke_deserialize_camera(srlztn_deserialize_helper *h) {
+void pke_deserialize_camera(srlztn_deserialize_helper *h, pke_kve_container *kvec) {
+	uint32_t i;
 	PK_STN_RES stn_res = PK_STN_RES(0);
 	PkeCamera cam{};
 	cam.type = PKE_CAMERA_TYPE_PERSPECTIVE;
@@ -67,8 +111,16 @@ bool pke_deserialize_camera(srlztn_deserialize_helper *h) {
 	instPos.mass = 1;
 	instPos.posRot.setIdentity();
 	instPos.scale = btVector3(1, 1, 1);
-	while (h->i->getline(h->read_line, h->read_line_len)) {
-		if (strcmp(h->read_line, SRLZTN_OBJ_END) == 0) {
+
+	for (i = 0; i < kvec->children.next; ++i) {
+		pke_kve_container *child_kvec = kvec->children[i];
+		if (strncmp(child_kvec->type_code.val, SRLZTN_OBJ_INSTANCE_POSITION, strlen(SRLZTN_OBJ_INSTANCE_POSITION)) == 0) {
+			pke_deserialize_inst_pos(h, child_kvec, pos, quat_rot, scale);
+		}
+	}
+
+	for (i = 0; i < kvec->arr.next; ++i) {
+		if (strcmp(kvec->arr[i].key, SRLZTN_OBJ_END) == 0) {
 
 			uint32_t targetInstanceIndex = -1;
 			if (target_uuid != pk_uuid_zed) {
@@ -97,49 +149,41 @@ bool pke_deserialize_camera(srlztn_deserialize_helper *h) {
 			if (rCam.isPrimary == true) {
 				ActiveCamera = &rCam;
 			}
-			return true;
-		}
-		if (pke_deserialize_inst_pos(h, pos, quat_rot, scale)) {
-			continue;
+			return;
 		}
-		if (strncmp(h->read_line, SRLZTN_CAMERA_UUID, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_UUID);
-			(h->read_line + prefixLen) >> cam.uuid;
+		if (strncmp(kvec->arr[i].key, SRLZTN_CAMERA_UUID, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
+			kvec->arr[i].val >> cam.uuid;
 			continue;
 		}
-		if (strncmp(h->read_line, SRLZTN_CAMERA_TYPE, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_TYPE);
+		if (strncmp(kvec->arr[i].key, SRLZTN_CAMERA_TYPE, strlen(SRLZTN_CAMERA_TYPE)) == 0) {
 			PkeCameraType_T cam_type;
-			stn_res = pk_stn(&cam_type, h->read_line + prefixLen, nullptr);
+			stn_res = pk_stn(&cam_type, kvec->arr[i].val, nullptr);
 			cam.type = PkeCameraType(cam_type);
 			if (stn_res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[%s] Err '%u' parsing camera type from: '%s'\n", __FILE__, stn_res, h->read_line);
+				fprintf(stderr, "[%s] Err '%u' parsing camera type from: '%s'\n", __FILE__, stn_res, kvec->arr[i].val);
 			}
 			continue;
 		}
-		if (strncmp(h->read_line, SRLZTN_CAMERA_ORIENTATION, strlen(SRLZTN_CAMERA_ORIENTATION)) == 0) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_ORIENTATION);
+		if (strncmp(kvec->arr[i].key, SRLZTN_CAMERA_ORIENTATION, strlen(SRLZTN_CAMERA_ORIENTATION)) == 0) {
 			PkeCameraView_T cam_view;
-			stn_res = pk_stn(&cam_view, h->read_line + prefixLen, nullptr);
+			stn_res = pk_stn(&cam_view, kvec->arr[i].val, nullptr);
 			cam.view = PkeCameraView(cam_view);
 			if (stn_res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[%s] Err '%u' parsing camera view from: '%s'\n", __FILE__, stn_res, h->read_line);
+				fprintf(stderr, "[%s] Err '%u' parsing camera view from: '%s'\n", __FILE__, stn_res, kvec->arr[i].val);
 			}
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_CAMERA_TARGET_INSTANCE_UUID)) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_TARGET_INSTANCE_UUID);
-			(h->read_line + prefixLen) >> target_uuid;
+		if (strstr(kvec->arr[i].key, SRLZTN_CAMERA_TARGET_INSTANCE_UUID)) {
+			kvec->arr[i].val >> target_uuid;
 			continue;
 		}
-		if (strstr(h->read_line, SRLZTN_CAMERA_IS_PRIMARY)) {
-			uint64_t prefixLen = strlen(SRLZTN_CAMERA_IS_PRIMARY);
-			stn_res = pk_stn(&cam.isPrimary, h->read_line + prefixLen, nullptr);
+		if (strstr(kvec->arr[i].key, SRLZTN_CAMERA_IS_PRIMARY)) {
+			stn_res = pk_stn(&cam.isPrimary, kvec->arr[i].val, nullptr);
 			if (stn_res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[%s] Err '%u' parsing camera primary from: '%s'\n", __FILE__, stn_res, h->read_line);
+				fprintf(stderr, "[%s] Err '%u' parsing camera primary from: '%s'\n", __FILE__, stn_res, kvec->arr[i].val);
 			}
 			continue;
 		}
 	}
-	return false;
+	return;
 }