pke: serialization overhaul + embedded assets

1 files changed, 129 insertions, 165 deletions

diff --git a/src/serialization-static-ui.cpp b/src/serialization-static-ui.cpp
index 447e7d0..4c45cc1 100644
--- a/src/serialization-static-ui.cpp
+++ b/src/serialization-static-ui.cpp
@@ -1,50 +1,56 @@
 
 #include "serialization-static-ui.hpp"
 #include "ecs.hpp"
+#include "font.hpp"
 #include "pk.h"
-#include "serialization-font.hpp"
 #include "static-ui.hpp"
 
-pk_handle pke_serialize_ui_box_internal(srlztn_serialize_helper *h, pke_ui_box_type_data_text *data) {
+pk_handle pke_serialize_ui_box_internal(srlztn_serialize_helper *h, pke_ui_box_type_data::pke_ui_box_type_data_text *data) {
 	char *s;
-	pk_handle font_render_handle;
 	pke_kve kve{};
 	pke_kve_container kvec{};
 
-	font_render_handle = pke_serialize_font_render_settings(h, &data->font_render_settings);
-
 	kvec.srlztn_handle = h->handle_head;
-	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_UI_BOX);
+	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_UI_BOX_TYPE_DATA);
 	kvec.bkt = h->bkt;
 	kvec.arr.bkt = h->bkt;
 	kvec.children.bkt = h->bkt;
 	kvec.child_handles.bkt = h->bkt;
 	h->handle_head.itemIndex++;
-	if (font_render_handle != PK_HANDLE_MAX) {
-		pk_arr_append_t(&kvec.child_handles, font_render_handle);
-	}
 
-	if (data->font_render_uuid != pk_uuid_zed) {
+	{
 		kve.key = SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID;
 		s = pk_new<char>(37, h->bkt);
-		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(data->font_render_uuid));
+		FontRender *fr = FontType_GetFontRender(data->font_render_handle);
+		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(fr->uuid));
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
 
 	pk_arr_append_t(&h->kvp_containers, kvec);
+	kvec.arr.data = nullptr;
+	kvec.children.data = nullptr;
+	kvec.child_handles.data = nullptr;
 	return kvec.srlztn_handle;
 }
 
-void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_container *kvec, pke_ui_box_type_data_text *data) {
-	assert(kvec->children.next == 1);
-
-	pke_deserialize_font_render_settings(h, kvec, &data->font_render_settings);
+void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_container *kvec, pke_ui_box_type_data::pke_ui_box_type_data_text *data) {
+	(void)h;
+	assert(kvec != nullptr);
+	assert(data != nullptr);
+	assert(kvec->arr.next == 1);
+	pk_uuid font_render_uuid = pk_uuid_zed;
 
 	if (strstr(SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID, kvec->arr[0].key)) {
-		kvec->arr[0].val >> data->font_render_uuid;
+		kvec->arr[0].val >> font_render_uuid;
 	}
+
+	assert(font_render_uuid != pk_uuid_zed);
+
+	FontRender *fr = static_cast<FontRender *>(ECS_GetEntityByUUID(font_render_uuid));
+
+	data->font_render_handle = fr->fr_handle;
 }
 
 pk_handle pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box) {
@@ -55,8 +61,7 @@ pk_handle pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box) {
 	pke_kve_container kvec{};
 
 	if (box->type == PKE_UI_BOX_TYPE_TEXT) {
-		pke_ui_box_type_data_text *d = reinterpret_cast<pke_ui_box_type_data_text *>(box->type_data);
-		internal_type_handle = pke_serialize_ui_box_internal(h, d);
+		internal_type_handle = pke_serialize_ui_box_internal(h, &box->type_data->text);
 	}
 
 	kvec.srlztn_handle = h->handle_head;
@@ -95,61 +100,34 @@ pk_handle pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box) {
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
-	if (box->pos_top_left_x != 0.0) {
-		kve.key = SRLZTN_UI_BOX_POS_TOP_LEFT_X;
-		len = snprintf(NULL, 0, "%f", box->pos_top_left_x);
-		s = pk_new<char>(len+1, h->bkt);
-		sprintf(s, "%f", box->pos_top_left_x);
-		kve.val = s;
-		kve.end = SRLZTN_KVE_END;
-		pk_arr_append_t(&kvec.arr, kve);
-	}
-	if (box->pos_top_left_y != 0.0) {
-		kve.key = SRLZTN_UI_BOX_POS_TOP_LEFT_Y;
-		len = snprintf(NULL, 0, "%f", box->pos_top_left_y);
+	{
+		kve.key = SRLZTN_UI_BOX_POS_TOP_LEFT;
+		len = snprintf(NULL, 0, "%f;%f", box->pos_top_left.x, box->pos_top_left.y);
 		s = pk_new<char>(len+1, h->bkt);
-		sprintf(s, "%f", box->pos_top_left_y);
+		sprintf(s, "%f;%f", box->pos_top_left.x, box->pos_top_left.y);
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
-	if (box->min_width != 0.0) {
-		kve.key = SRLZTN_UI_BOX_MIN_WIDTH;
-		len = snprintf(NULL, 0, "%f", box->min_width);
+	if (box->min_size != glm::vec2(0,0)) {
+		kve.key = SRLZTN_UI_BOX_MIN_SIZE;
+		len = snprintf(NULL, 0, "%f;%f", box->min_size.x, box->min_size.y);
 		s = pk_new<char>(len+1, h->bkt);
-		sprintf(s, "%f", box->min_width);
+		sprintf(s, "%f%f", box->min_size.x, box->min_size.y);
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
-	if (box->min_height != 0.0) {
-		kve.key = SRLZTN_UI_BOX_MIN_HEIGHT;
-		len = snprintf(NULL, 0, "%f", box->min_height);
+	if (box->max_size != glm::vec2(0,0)) {
+		kve.key = SRLZTN_UI_BOX_MAX_SIZE;
+		len = snprintf(NULL, 0, "%f;%f", box->max_size[0], box->max_size[1]);
 		s = pk_new<char>(len+1, h->bkt);
-		sprintf(s, "%f", box->min_height);
+		sprintf(s, "%f;%f", box->max_size[0], box->max_size[1]);
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
-	if (box->max_width != 0.0) {
-		kve.key = SRLZTN_UI_BOX_MAX_WIDTH;
-		len = snprintf(NULL, 0, "%f", box->max_width);
-		s = pk_new<char>(len+1, h->bkt);
-		sprintf(s, "%f", box->max_width);
-		kve.val = s;
-		kve.end = SRLZTN_KVE_END;
-		pk_arr_append_t(&kvec.arr, kve);
-	}
-	if (box->max_height != 0.0) {
-		kve.key = SRLZTN_UI_BOX_MAX_HEIGHT;
-		len = snprintf(NULL, 0, "%f", box->max_height);
-		s = pk_new<char>(len+1, h->bkt);
-		sprintf(s, "%f", box->max_height);
-		kve.val = s;
-		kve.end = SRLZTN_KVE_END;
-		pk_arr_append_t(&kvec.arr, kve);
-	}
-	if (box->flex_weight != 0.0) {
+	if (box->flex_weight != 0.f) {
 		kve.key = SRLZTN_UI_BOX_FLEX_WEIGHT;
 		len = snprintf(NULL, 0, "%f", box->flex_weight);
 		s = pk_new<char>(len+1, h->bkt);
@@ -157,33 +135,35 @@ pk_handle pke_serialize_ui_box(srlztn_serialize_helper *h, pke_ui_box *box) {
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
-	}
-	if (box->type != PKE_UI_BOX_TYPE_STANDARD) {
-		kve.key = SRLZTN_UI_BOX_FLAGS;
+		// only serialize if we're using flex
+		kve.key = SRLZTN_UI_BOX_FLEX_DIRECTION;
 		s = pk_new<char>(5, h->bkt);
-		sprintf(s, "0x%.2X", static_cast<PKE_UI_BOX_TYPE_T>(box->type));
+		sprintf(s, "0x%.2X", box->flex_direction);
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
-	if (box->flex_direction != 0) {
-		kve.key = SRLZTN_UI_BOX_FLEX_DIRECTION;
+	{
+		kve.key = SRLZTN_UI_BOX_TYPE;
 		s = pk_new<char>(5, h->bkt);
-		sprintf(s, "%u", box->flex_direction);
+		sprintf(s, "0x%.2X", static_cast<PKE_UI_BOX_TYPE_T>(box->type));
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
-	if (box->layer != 0) {
+	{
 		kve.key = SRLZTN_UI_BOX_LAYER;
 		s = pk_new<char>(5, h->bkt);
-		sprintf(s, "%u", box->layer);
+		sprintf(s, "0x%.2X", box->layer);
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
 		pk_arr_append_t(&kvec.arr, kve);
 	}
 
 	pk_arr_append_t(&h->kvp_containers, kvec);
+	kvec.arr.data = nullptr;
+	kvec.children.data = nullptr;
+	kvec.child_handles.data = nullptr;
 	return kvec.srlztn_handle;
 }
 
@@ -200,35 +180,34 @@ void pke_deserialize_ui_box(srlztn_deserialize_helper *h, pke_kve_container *kve
 	 *
 	 */
 
-	uint32_t i;
-	uint64_t prefix_len;
+	uint32_t i, index;
 	PK_STN_RES res;
+	const char *starting_char;
 	char *stn_end;
+	pke_kve *kve;
 	pke_ui_box bx{};
 	pke_ui_box *parent_box = nullptr;
 	bx.type_data = nullptr;
 
 	for (i = 0; i < kvec->arr.next; ++i) {
-		if (strstr(SRLZTN_UI_BOX_UUID, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_UUID);
-			(kvec->arr[i].val + prefix_len) >> bx.uuid;
+		kve = &kvec->arr[i];
+		if (strstr(SRLZTN_UI_BOX_UUID, kve->key)) {
+			kve->val >> bx.uuid;
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_PARENT_UUID, kvec->arr[i].key)) {
+		if (strstr(SRLZTN_UI_BOX_PARENT_UUID, kve->key)) {
 			uint32_t target_instance_index = -1;
 			pk_uuid id;
-			prefix_len = strlen(SRLZTN_UI_BOX_PARENT_UUID);
-			(kvec->arr[i].val + prefix_len) >> id;
+			kve->val >> id;
 			target_instance_index = pk_arr_find_first_index(&h->mapping, &id, srlztn_mapping_find_first_handle_by_uuid);
 			if (target_instance_index != uint32_t(-1)) {
 				parent_box = static_cast<pke_ui_box*>(h->mapping[target_instance_index].created_entity);
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_FLAGS, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_FLAGS);
+		if (strstr(SRLZTN_UI_BOX_FLAGS, kve->key)) {
 			PKE_UI_BOX_FLAG_T flags;
-			res = pk_stn(&flags, kvec->arr[i].val + prefix_len, &stn_end);
+			res = pk_stn(&flags, kve->val, &stn_end, 16);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_FLAGS, res);
 				continue;
@@ -236,125 +215,110 @@ void pke_deserialize_ui_box(srlztn_deserialize_helper *h, pke_kve_container *kve
 			bx.flags = PKE_UI_BOX_FLAG(flags);
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_POS_TOP_LEFT_X, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_POS_TOP_LEFT_X);
-			res = pk_stn(&bx.pos_top_left_x, kvec->arr[i].val + prefix_len, &stn_end);
-			if (res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_POS_TOP_LEFT_X, res);
-				continue;
-			}
-			continue;
-		}
-		if (strstr(SRLZTN_UI_BOX_POS_TOP_LEFT_Y, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_POS_TOP_LEFT_Y);
-			res = pk_stn(&bx.pos_top_left_y, kvec->arr[i].val + prefix_len, &stn_end);
-			if (res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_POS_TOP_LEFT_Y, res);
-				continue;
-			}
-			continue;
-		}
-		if (strstr(SRLZTN_UI_BOX_MIN_WIDTH, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_MIN_WIDTH);
-			res = pk_stn(&bx.min_width, kvec->arr[i].val + prefix_len, &stn_end);
-			if (res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_MIN_WIDTH, res);
-				continue;
-			}
-			continue;
-		}
-		if (strstr(SRLZTN_UI_BOX_MIN_HEIGHT, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_MIN_HEIGHT);
-			res = pk_stn(&bx.min_width, kvec->arr[i].val + prefix_len, &stn_end);
+		if (strstr(SRLZTN_UI_BOX_POS_TOP_LEFT, kve->key)) {
+			starting_char = kve->val;
+			index = 0;
+			do {
+				assert(index < 2);
+				res = pk_stn(&bx.pos_top_left[index], starting_char, &stn_end);
+				if (res != PK_STN_RES_SUCCESS) break;
+				starting_char = stn_end + 1;
+				++index;
+			} while (*stn_end != '\0');
 			if (res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_MIN_HEIGHT, res);
-				continue;
+				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_POS_TOP_LEFT, res);
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_MAX_WIDTH, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_MAX_WIDTH);
-			res = pk_stn(&bx.max_width, kvec->arr[i].val + prefix_len, &stn_end);
+		if (strstr(SRLZTN_UI_BOX_MIN_SIZE, kve->key)) {
+			starting_char = kve->val;
+			index = 0;
+			do {
+				assert(index < 2);
+				res = pk_stn(&bx.min_size[index], starting_char, &stn_end);
+				if (res != PK_STN_RES_SUCCESS) break;
+				starting_char = stn_end + 1;
+				++index;
+			} while (*stn_end != '\0');
 			if (res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_MAX_WIDTH, res);
-				continue;
+				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_MIN_SIZE, res);
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_MAX_HEIGHT, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_MAX_HEIGHT);
-			res = pk_stn(&bx.max_width, kvec->arr[i].val + prefix_len, &stn_end);
+		if (strstr(SRLZTN_UI_BOX_MAX_SIZE, kve->key)) {
+			starting_char = kve->val;
+			index = 0;
+			do {
+				assert(index < 2);
+				res = pk_stn(&bx.max_size[index], starting_char, &stn_end);
+				if (res != PK_STN_RES_SUCCESS) break;
+				starting_char = stn_end + 1;
+				++index;
+			} while (*stn_end != '\0');
 			if (res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_MAX_HEIGHT, res);
-				continue;
+				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_MAX_SIZE, res);
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_FLEX_WEIGHT, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_FLEX_WEIGHT);
-			res = pk_stn(&bx.flex_weight, kvec->arr[i].val + prefix_len, &stn_end);
+		if (strstr(SRLZTN_UI_BOX_FLEX_WEIGHT, kve->key)) {
+			res = pk_stn(&bx.flex_weight, kve->val, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_FLEX_WEIGHT, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_FLEX_DIRECTION, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_FLEX_DIRECTION);
-			res = pk_stn(&bx.flex_direction, kvec->arr[i].val + prefix_len, &stn_end);
+		if (strstr(SRLZTN_UI_BOX_FLEX_DIRECTION, kve->key)) {
+			res = pk_stn(&bx.flex_direction, kve->val, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_FLEX_DIRECTION, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_LAYER, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_LAYER);
-			res = pk_stn(&bx.layer, kvec->arr[i].val + prefix_len, &stn_end);
+		if (strstr(SRLZTN_UI_BOX_LAYER, kve->key)) {
+			res = pk_stn(&bx.layer, kve->val, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
 				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_LAYER, res);
 				continue;
 			}
 			continue;
 		}
-		if (strstr(SRLZTN_UI_BOX_TYPE, kvec->arr[i].key)) {
-			prefix_len = strlen(SRLZTN_UI_BOX_TYPE);
-			res = pk_stn(&bx.type, kvec->arr[i].val + prefix_len, &stn_end);
+		if (strstr(SRLZTN_UI_BOX_TYPE, kve->key)) {
+			uint8_t v;
+			res = pk_stn<uint8_t>(&v, kve->val, &stn_end);
 			if (res != PK_STN_RES_SUCCESS) {
-				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse value for: '%s', err: %i\n", SRLZTN_UI_BOX_TYPE, res);
+				fprintf(stderr, "[pke_deserialize_ui_box] Failed to parse '%s' from '%s', err: %i\n", SRLZTN_UI_BOX_TYPE, kve->val, res);
 				continue;
 			}
-			// TODO specific bucket?
+			// log warning for unknown
+			bx.type = PKE_UI_BOX_TYPE{v};
 			switch (bx.type) {
+				case PKE_UI_BOX_TYPE_STANDARD:
 				case PKE_UI_BOX_TYPE_TEXT:
+				case PKE_UI_BOX_TYPE_INPUT_TEXT:
 					break;
 				default:
-					fprintf(stderr, "[pke_deserialize_ui_box] Parsed unknown ui box data type from: '%s'\n", kvec->arr[i].val);
+					fprintf(stderr, "[pke_deserialize_ui_box] Parsed unknown ui box data type from: '%s'\n", kve->val);
 					continue;
 			}
 			continue;
 		}
 	}
 
-	// get ready to deserialize children
+	// deserialize data
+	// TODO specific bucket?
 	if (bx.type != PKE_UI_BOX_TYPE_STANDARD) {
+		bx.type_data = pk_new<pke_ui_box_type_data>();
 		switch (bx.type) {
 			case PKE_UI_BOX_TYPE_TEXT:
-				bx.type_data = pk_new<pke_ui_box_type_data_text>();
+				pke_deserialize_ui_box_internal(h, kvec->children[0], &bx.type_data->text);
 				break;
 			default:
 				break;
 		}
 	}
 
-	// deserialize children
-	for (i = 0; i < kvec->children.next; ++i) {
-		pke_kve_container *child_kvec = kvec->children[i];
-		if (strcmp(child_kvec->type_code.val, SRLZTN_OBJ_UI_BOX_TYPE_DATA) == 0) {
-			pke_deserialize_ui_box_internal(h, child_kvec, static_cast<pke_ui_box_type_data_text*>(bx.type_data));
-		}
-	}
-
 	pke_ui_box *box;
 	if (parent_box == nullptr) {
 		box = pke_ui_box_new_root(bx.type, bx.uuid);
@@ -362,31 +326,31 @@ void pke_deserialize_ui_box(srlztn_deserialize_helper *h, pke_kve_container *kve
 		box = pke_ui_box_new_child(parent_box, bx.type, bx.uuid);
 	}
 	box->flags = bx.flags;
-	box->pos_top_left_x = bx.pos_top_left_x;
-	box->pos_top_left_y = bx.pos_top_left_y;
-	box->min_width = bx.min_width;
-	box->min_height = bx.min_height;
-	box->max_width = bx.max_width;
-	box->max_height = bx.max_height;
+	box->pos_top_left = bx.pos_top_left;
+	box->min_size = bx.min_size;
+	box->max_size = bx.max_size;
 	box->flex_weight = bx.flex_weight;
 	box->type = bx.type;
 	box->flex_direction = bx.flex_direction;
 	box->layer = bx.layer;
 
-	// TODO clone functions?
-	// might not be necessary if we refactor deserialization into their own ctors
-	if (bx.type != PKE_UI_BOX_TYPE_STANDARD) {
-		switch (bx.type) {
-			case PKE_UI_BOX_TYPE_TEXT:
-				reinterpret_cast<pke_ui_box_type_data_text*>(box->type_data  )->font_render_uuid
-					= reinterpret_cast<pke_ui_box_type_data_text*>(bx.type_data)->font_render_uuid;
-				reinterpret_cast<pke_ui_box_type_data_text*>(box->type_data  )->font_render_handle
-					= reinterpret_cast<pke_ui_box_type_data_text*>(bx.type_data)->font_render_handle;
-				reinterpret_cast<pke_ui_box_type_data_text*>(box->type_data  )->font_render_settings
-					= reinterpret_cast<pke_ui_box_type_data_text*>(bx.type_data)->font_render_settings;
-				break;
-			default:
-				break;
+	// TODO consider type-specific clone functions
+	if (box->type_data != nullptr && bx.type_data != nullptr) {
+		*box->type_data = *box->type_data;
+		pk_delete<pke_ui_box_type_data>(bx.type_data);
+		bx.type_data = nullptr;
+	}
+
+	srlztn_ecs_mapping map{};
+	map.serialized_uuid = bx.uuid;
+	map.created_entity = box;
+	pk_arr_append_t(&h->mapping, map);
+
+	// recursively deserialize children
+	for (i = 0; i < kvec->children.next; ++i) {
+		pke_kve_container *child_kvec = kvec->children[i];
+		if (strcmp(child_kvec->type_code.val, SRLZTN_OBJ_UI_BOX) == 0) {
+			pke_deserialize_ui_box(h, child_kvec);
 		}
 	}