path: root/src/static-ui.cpp

#include "static-ui.hpp"

#include "ecs.hpp"
#include "font.hpp"
#include "game-settings.hpp"
#include "pk.h"
#include "player-input.hpp"
#include "static-plane.hpp"
#include "vendor-glm-include.hpp"
#include "window.hpp"

#include <GLFW/glfw3.h>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <vulkan/vulkan_core.h>

const char *const ui_ux_mouse_left               = "ui_ux_mouse_left";
const char *const ui_ux_mouse_right              = "ui_ux_mouse_right";
const char *const ui_ux_mouse_middle             = "ui_ux_mouse_middle";

TypeSafeInt_B(PKE_UI_BOX_TYPE);
TypeSafeInt_B(PKE_UI_BOX_FLAG);
TypeSafeInt_B(PKE_UI_BOX_STATE_FLAG);

struct pke_ui_box_instance_buffer_item {
	glm::mat4 pos_scale;
	glm::vec4 color_border;
	glm::vec4 color_background;
	glm::vec2 px_scale;
	float depth;
	float padding[1];
};

struct pke_ui_master {
	pk_membucket *bkt;
	pke_ui_box **root_boxes;
	pke_ui_box_count_T h_root_boxes;
	pke_ui_box_count_T r_root_boxes;
	pke_ui_graphics_bindings bindings;
	bool should_update_buffer = false;
	glm::vec2 px_scale;
	pk_arr_t<pke_input_event> events_this_tick;
	pke_input_action_set_handle input_action_set_handle;
	struct pke_ui_master_state {
		const pke_input_event *mouse_left = nullptr;
		const pke_input_event *mouse_right = nullptr;
		const pke_input_event *mouse_middle = nullptr;
		pke_ui_box *deepest_pressed = nullptr;
	} state;
} pke_ui_master;

// typedef void(*pke_box_search)(pke_ui_box &box);
typedef std::function<void(pke_ui_box &box)> pke_box_iterate ;


/* 2025-07-28 JCB TODO
 * Needs PERF? Consider separate searches by need (depth/breadth).
 * With a depth-first, if the parent kept track of how deep its children are, we could short-cut the search (assuming we're searching for depth-most)
 */
void pke_ui_internal_box_iterate_top_down_recursive(pke_box_iterate *iters, int n_iters, pke_ui_box **boxes, pke_ui_box_count_T box_count) {
	pke_ui_box_count_T i;
	int k;

	for (i = 0; i < box_count; ++i) {
		for (k = 0; k < n_iters; ++k) {
			iters[k](*boxes[i]);
		}
	}
	for (i = 0; i < box_count; ++i) {
		pke_ui_internal_box_iterate_top_down_recursive(iters, n_iters, boxes[i]->internal.children, boxes[i]->internal.h_children);
	}
}

void pke_ui_init() {
	pke_ui_master.bkt = pk_mem_bucket_create("pke ui", PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);
	pke_ui_master.root_boxes = pk_new_arr<pke_ui_box*>(1, pke_ui_master.bkt);
	pke_ui_master.h_root_boxes = 0;
	pke_ui_master.r_root_boxes = 1;
	pke_ui_master.bindings = {};

	pke_input_set ui_controls_set{};
	ui_controls_set.title = "debug-editor-controls";
	ui_controls_set.actionCount = 3;
	ui_controls_set.actions = pk_new_arr<pke_input_action>(ui_controls_set.actionCount);
	ui_controls_set.flags = PKE_INPUT_ACTION_SET_FLAG_DO_NOT_SERIALIZE;

	ui_controls_set.actions[0].name = ui_ux_mouse_left;
	ui_controls_set.actions[0].masks[0] = pke_input_event_mask {
		.computedHash = PKE_INPUT_HASH_ALL_MOUSE_BUTTON_EVENTS,
		.button = GLFW_MOUSE_BUTTON_LEFT,
	};
	ui_controls_set.actions[1].name = ui_ux_mouse_right;
	ui_controls_set.actions[1].masks[0] = pke_input_event_mask {
		.computedHash = PKE_INPUT_HASH_ALL_MOUSE_BUTTON_EVENTS,
		.button = GLFW_MOUSE_BUTTON_RIGHT,
	};
	ui_controls_set.actions[2].name = ui_ux_mouse_middle;
	ui_controls_set.actions[2].masks[0] = pke_input_event_mask {
		.computedHash = PKE_INPUT_HASH_ALL_MOUSE_BUTTON_EVENTS,
		.button = GLFW_MOUSE_BUTTON_MIDDLE,
	};

	pke_ui_master.input_action_set_handle = pke_input_register_set(ui_controls_set);

}

void pke_ui_force_recalc() {
	pke_ui_master.should_update_buffer = true;
}

void pke_ui_init_bindings() {
	pkvk_buffer_create_data create_data{};
	create_data.buffer_byte_length[0] = sizeof(pkeIntrinsicsPlane.vert[0]) * 4;
	create_data.buffer_byte_length[1] = sizeof(pkeIntrinsicsPlane.uv[0]) * 4;
	create_data.buffer_byte_length[2] = sizeof(pkeIntrinsicsPlane.index[0]) * 6;
	create_data.buffer_byte_length[3] = sizeof(pke_ui_box_instance_buffer_item);
	create_data.src_data[0] = &pkeIntrinsicsPlane.vert;
	create_data.src_data[1] = &pkeIntrinsicsPlane.uv;
	create_data.src_data[2] = &pkeIntrinsicsPlane.index;
	create_data.src_data[3] = nullptr;
	create_data.n_buffers = 4;
	create_data.index_index = 2;
	create_data.index_instance = 3;

	pkvk_buffer_create_data_out out{};
	pkvk_buffer_create(&create_data, &out);

	pke_ui_master.bindings.bd_vertex.buffer = out.buffers[0];
	pke_ui_master.bindings.bd_vertex.firstBinding = 0;
	pke_ui_master.bindings.bd_vertex.bindingCount = 1;
	pke_ui_master.bindings.bd_uv.buffer = out.buffers[1];
	pke_ui_master.bindings.bd_uv.firstBinding = 1;
	pke_ui_master.bindings.bd_uv.bindingCount = 1;
	pke_ui_master.bindings.bd_index.buffer = out.buffers[2];
	pke_ui_master.bindings.bd_index.firstBinding = 0;
	pke_ui_master.bindings.bd_index.bindingCount = 1;
	pke_ui_master.bindings.index_count = 6;
	pke_ui_master.bindings.bd_instance.buffer = out.buffers[3];
	pke_ui_master.bindings.bd_instance.firstBinding = 2;
	pke_ui_master.bindings.bd_instance.bindingCount = 1;
	pke_ui_master.bindings.deviceMemoryVert = out.device_memory_vertex;
	pke_ui_master.bindings.deviceMemoryInst = out.device_memory_instance;

	pke_ui_master.bindings.instance_buffer_max_count = out.memory_requirements_instance.size / sizeof(pke_ui_box_instance_buffer_item);
}

/* UI layout notes
Some restrictions:
- children cannot change the size of a parent, parents must be sized manually
	- e.g.: exact font width
	- consider writing a method to calculate text
- Children can ONLY be horizontal or vertical
	- this means that tables or similar need to consist of rows of columns
*/

void pke_ui_update_state(pke_ui_box &box) {
	double mouse_x, mouse_y;

	// update state
	PKE_UI_BOX_STATE_FLAG old_state = box.state_flags;
	PKE_UI_BOX_STATE_FLAG flgs;
	box.state_flags = PKE_UI_BOX_STATE_FLAG_NONE;

	if (pke_ui_master.state.mouse_left == nullptr || (pke_ui_master.state.mouse_left->data.mouse_button.isPressed == false && pke_ui_master.state.mouse_left->data.mouse_button.thisTick == false)) {
		flgs = PKE_UI_BOX_STATE_FLAG_ON_BTN_PRIMARY_RELEASE | PKE_UI_BOX_STATE_FLAG_ON_BTN_PRIMARY_PRESS | PKE_UI_BOX_STATE_FLAG_ON_BTN_PRIMARY_PRESSED;
		box.state_flags_mem &= ~flgs;
	}

	if (pke_ui_master.state.mouse_right == nullptr || (pke_ui_master.state.mouse_right->data.mouse_button.isPressed == false && pke_ui_master.state.mouse_right->data.mouse_button.thisTick == false)) {
		flgs = PKE_UI_BOX_STATE_FLAG_ON_BTN_SECONDARY_RELEASE | PKE_UI_BOX_STATE_FLAG_ON_BTN_SECONDARY_PRESS | PKE_UI_BOX_STATE_FLAG_ON_BTN_SECONDARY_PRESSED;
		box.state_flags_mem &= ~flgs;
	}

	if (pke_ui_master.state.mouse_middle == nullptr || (pke_ui_master.state.mouse_middle->data.mouse_button.isPressed == false && pke_ui_master.state.mouse_middle->data.mouse_button.thisTick == false)) {
		flgs = PKE_UI_BOX_STATE_FLAG_ON_BTN_MIDDLE_RELEASE | PKE_UI_BOX_STATE_FLAG_ON_BTN_MIDDLE_PRESS | PKE_UI_BOX_STATE_FLAG_ON_BTN_MIDDLE_PRESSED;
		box.state_flags_mem &= ~flgs;
	}

	pke_input_query_mouse_pos(mouse_x, mouse_y);
	if (mouse_x >= box.internal.px_corner.x + box.internal.px_padding_l
			&& mouse_y >= box.internal.px_corner.y + box.internal.px_padding_t
			&& mouse_x <= box.internal.px_corner.x + box.internal.px_size.x - box.internal.px_padding_r
			&& mouse_y <= box.internal.px_corner.y + box.internal.px_size.y - box.internal.px_padding_b) {
		box.state_flags |= PKE_UI_BOX_STATE_FLAG_MOUSE_HOVER;
		if (!PK_HAS_FLAG(old_state, PKE_UI_BOX_STATE_FLAG_MOUSE_HOVER)) {
			box.state_flags |= PKE_UI_BOX_STATE_FLAG_MOUSE_ENTERED;
		}

		if (pke_ui_master.state.mouse_left != nullptr && pke_ui_master.state.mouse_left->data.mouse_button.thisTick) {
			if (pke_ui_master.state.mouse_left->data.mouse_button.isPressed) {
				box.state_flags |= PKE_UI_BOX_STATE_FLAG_ON_BTN_PRIMARY_PRESS;
				box.state_flags_mem |= PKE_UI_BOX_STATE_FLAG_ON_BTN_PRIMARY_PRESS;
			} else if (PK_HAS_FLAG(box.state_flags_mem, PKE_UI_BOX_STATE_FLAG_ON_BTN_PRIMARY_PRESS)) {
				box.state_flags |= PKE_UI_BOX_STATE_FLAG_ON_BTN_PRIMARY_PRESSED;
				if (box.type == PKE_UI_BOX_TYPE_BUTTON_TEXT || box.type == PKE_UI_BOX_TYPE_BUTTON_IMAGE) {
					if (pke_ui_master.state.deepest_pressed == nullptr || pke_ui_master.state.deepest_pressed->internal.depth < box.internal.depth) {
						pke_ui_master.state.deepest_pressed = &box;
					}
				}
			}
		}

		if (pke_ui_master.state.mouse_right != nullptr && pke_ui_master.state.mouse_right->data.mouse_button.thisTick) {
			if (pke_ui_master.state.mouse_right->data.mouse_button.isPressed) {
				box.state_flags |= PKE_UI_BOX_STATE_FLAG_ON_BTN_SECONDARY_PRESS;
				box.state_flags_mem |= PKE_UI_BOX_STATE_FLAG_ON_BTN_SECONDARY_PRESS;
			} else if (PK_HAS_FLAG(box.state_flags_mem, PKE_UI_BOX_STATE_FLAG_ON_BTN_SECONDARY_PRESS)) {
				box.state_flags |= PKE_UI_BOX_STATE_FLAG_ON_BTN_SECONDARY_PRESSED;
			}
		}

		if (pke_ui_master.state.mouse_middle != nullptr && pke_ui_master.state.mouse_middle->data.mouse_button.thisTick) {
			if (pke_ui_master.state.mouse_middle->data.mouse_button.isPressed) {
				box.state_flags |= PKE_UI_BOX_STATE_FLAG_ON_BTN_MIDDLE_PRESS;
				box.state_flags_mem |= PKE_UI_BOX_STATE_FLAG_ON_BTN_MIDDLE_PRESS;
			} else if (PK_HAS_FLAG(box.state_flags_mem, PKE_UI_BOX_STATE_FLAG_ON_BTN_MIDDLE_PRESS)) {
				box.state_flags |= PKE_UI_BOX_STATE_FLAG_ON_BTN_MIDDLE_PRESSED;
			}
		}

	} else if (PK_HAS_FLAG(old_state, PKE_UI_BOX_STATE_FLAG_MOUSE_HOVER)) {
		box.state_flags |= PKE_UI_BOX_STATE_FLAG_MOUSE_EXITED;
	}
}

struct pke_ui_flex_params {
	float px_per_unit;
	float unit_total;
};

void pke_ui_calc_px(pk_arr_t<pke_ui_box_instance_buffer_item> &buffer, pke_ui_flex_params *flex_params, pke_ui_box *box) {
	assert(box != nullptr);
	glm::vec2 px_size;
	glm::vec2 px_min_size;
	glm::vec2 px_max_size;
	glm::vec2 parent_size_padded;
	glm::vec2 parent_pos_and_offset;

	assert(box->pos_top_left.x >= 0.0);
	assert(box->pos_top_left.y >= 0.0);
	assert(box->max_size.x >= 0.0);
	assert(box->max_size.y >= 0.0);
	assert(box->min_size.x >= 0.0);
	assert(box->min_size.y >= 0.0);
	assert(box->min_size.x <= box->max_size.x);
	assert(box->min_size.y <= box->max_size.y);

	PKE_UI_BOX_STATE_FLAG prev_state_flags     = box->state_flags;
	PKE_UI_BOX_STATE_FLAG prev_state_flags_mem = box->state_flags_mem;

	if (box->internal.parent != nullptr) {
		parent_pos_and_offset.x = box->internal.parent->internal.px_corner.x
			+ box->internal.parent->internal.px_padding_l;
		parent_pos_and_offset.y = box->internal.parent->internal.px_corner.y
			+ box->internal.parent->internal.px_padding_t;
		parent_size_padded.x = box->internal.parent->internal.px_size.x;
		parent_size_padded.y = box->internal.parent->internal.px_size.y;
		// built-in padding
		parent_size_padded.x -= box->internal.parent->internal.px_padding_l
			+ box->internal.parent->internal.px_padding_r;
		parent_size_padded.y -= box->internal.parent->internal.px_padding_t
			+ box->internal.parent->internal.px_padding_b;
		px_size = parent_size_padded;
	} else {
		parent_pos_and_offset = glm::vec2(0);
		parent_size_padded = glm::vec2(Extent.width, Extent.height);
		px_size = glm::vec2(Extent.width, Extent.height);
	}

	px_min_size.x = box->min_size.x;
	px_min_size.y = box->min_size.y;
	px_max_size.x = box->max_size.x;
	px_max_size.y = box->max_size.y;
	box->internal.px_corner.x = 0
		+ parent_pos_and_offset.x
		+ box->pos_top_left.x;
	box->internal.px_corner.y = 0
		+ parent_pos_and_offset.y
		+ box->pos_top_left.y;

	if (PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_FLEX)) {
		assert(flex_params != nullptr);
		assert(box->internal.parent != nullptr);
		if (box->internal.parent->flex_direction == 0) {
			px_size.x = flex_params->px_per_unit * box->flex_weight;
		} else {
			px_size.y = flex_params->px_per_unit * box->flex_weight;
		}
	} else if (PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC)) {
		px_size.x -= box->pos_top_left.x;
		px_size.y -= box->pos_top_left.y;
	} else {
		assert(box->pos_top_left.x < 1.0);
		assert(box->pos_top_left.y < 1.0);
		box->internal.px_corner.x = parent_pos_and_offset.x;
		box->internal.px_corner.y = parent_pos_and_offset.y;
		float px_left = px_size.x * box->pos_top_left.x;
		float px_top = px_size.y * box->pos_top_left.y;
		box->internal.px_corner.x += px_left;
		box->internal.px_corner.y += px_top;
		px_size.x -= px_left;
		px_size.y -= px_top;
		px_min_size.x = box->min_size.x * parent_size_padded.x;
		px_min_size.y = box->min_size.y * parent_size_padded.y;
		px_max_size.x = box->max_size.x * parent_size_padded.x;
		px_max_size.y = box->max_size.y * parent_size_padded.y;
	}

	px_size = glm::clamp(px_size, px_min_size, px_max_size);

	// built-in padding
	box->internal.px_padding_l = built_in_offset;
	box->internal.px_padding_b = built_in_offset;
	box->internal.px_padding_r = built_in_offset;
	box->internal.px_padding_t = built_in_offset;

	if (PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_CENTER_HORIZONTAL)) {
		if (parent_size_padded.x > px_size.x) {
			box->internal.px_corner.x += (parent_size_padded.x - px_size.x) / 2.0;
		}
	}

	if (PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_CENTER_VERTICAL)) {
		if (parent_size_padded.y > px_size.y) {
			box->internal.px_corner.y += (parent_size_padded.y - px_size.y) / 2.0;
		}
	}

	box->internal.px_size.x = px_size.x;
	box->internal.px_size.y = px_size.y;
	if (box->internal.parent != nullptr) {
		// TODO change this based on the parent's 'direction'
		// 2025-03-13 JCB
		// optional: auto-wrapping boxes possible if we keep track of two sizes:
		// - remaining in active row/column
		// - unused space
		// box->internal.parent->internal.px_padding_l += px_size.x;
		box->internal.parent->internal.px_padding_t += px_size.y;
	}

	if (box->type_data != nullptr) {
		// type-specific changes
		if (box->type == PKE_UI_BOX_TYPE_TEXT) {
			FontRender *fr = FontType_GetFontRender(box->type_data->text.font_render_handle);
			FontRenderSettings frs = fr->settings;
			frs.surface_area_pos = box->internal.px_corner;
			frs.surface_area_size = box->internal.px_size;
			FontType_UpdateStringRender(box->type_data->text.font_render_handle, &frs);
		}
	}

	pke_ui_update_state(*box);
	if (prev_state_flags != box->state_flags || prev_state_flags_mem != box->state_flags_mem) {
		pke_ui_master.should_update_buffer = true;
	}

	if (PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE)) {
		return;
	}

	// update buffer
	glm::vec3 scale = glm::vec3(box->internal.px_size.x / (float)Extent.width, box->internal.px_size.y / (float)Extent.height, 1.0);
	glm::vec3 translate = glm::vec3(1);
	// ((val) - (width/2)) / (width/2)
	// place left line of box at edge of screen
	translate.x = (box->internal.px_size.x / 2.0);
	// box position
	translate.x += box->internal.px_corner.x;
	translate.x -= ((float)Extent.width / 2.0);
	translate.x /= ((float)Extent.width / 2.0);
	// ((val) - (height/2)) / (height/2)
	// place top line of box at edge of screen
	translate.y = (box->internal.px_size.y / 2.0);
	// box position
	translate.y += box->internal.px_corner.y;
	translate.y -= ((float)Extent.height / 2.0);
	translate.y /= ((float)Extent.height / 2.0);
	translate.z = 0;

	pke_ui_box_instance_buffer_item tmp{};
	tmp.pos_scale = glm::translate(glm::mat4(1), translate);
	tmp.pos_scale = glm::scale(tmp.pos_scale, scale);
	tmp.color_border = box->color_border;
	tmp.color_background = box->color_background;
	tmp.px_scale.x = (2.0 / (float)Extent.width);
	tmp.px_scale.y = (2.0 / (float)Extent.height);
	tmp.depth = (float)box->layer;
	pk_arr_append_t(&buffer, tmp);
}

void pke_ui_recalc_sizes_recursive(pk_arr_t<pke_ui_box_instance_buffer_item> &arr, pke_ui_box *box) {
	PKE_UI_BOX_FLAG_T flags_masked;
	uint8_t flex_count = 0;
	pke_ui_flex_params flex_params{};

	flags_masked = PKE_UI_BOX_FLAG_T(box->flags & PKE_UI_BOX_FLAG_POSITION_TYPE_ALL);
	if (flags_masked == 0b000 || flags_masked == 0b011 || flags_masked == 0b101 || flags_masked == 0b110 || flags_masked == 0b111) {
		fprintf(stderr, "[%s] ui box invalid flags: position type", __FILE__);
		return;
	}

	for (pke_ui_box_count_T i = 0; i < box->internal.h_children; ++i) {
		if (PK_HAS_FLAG(box->internal.children[i]->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_FLEX)) {
			flex_count += 1;
			flex_params.unit_total += box->internal.children[i]->flex_weight;
		}
	}

	if (flex_count != 0 && flex_count != box->internal.h_children) {
		fprintf(stderr, "[%s] ui box invalid flags: if one child is type FLEX, then all children must be type FLEX", __FILE__);
		return;
	}
	if (flex_count != 0) {
		flex_params.px_per_unit =
			box->flex_direction == 0
			? box->internal.px_size.x / flex_params.unit_total
			: box->internal.px_size.y / flex_params.unit_total;
	}

	for (pke_ui_box_count_T i = 0; i < box->internal.h_children; ++i) {
		pke_ui_calc_px(arr, &flex_params, box->internal.children[i]);
		pke_ui_recalc_sizes_recursive(arr, box->internal.children[i]);
	}
}

void pke_ui_update_instance_buffer(pk_arr_t<pke_ui_box_instance_buffer_item> &arr) {
	VkResult vkResult;
	if (arr.next > pke_ui_master.bindings.instance_buffer_max_count) {
		VkBuffer newBuffer;
		VkBufferCreateInfo bufferCI;
		bufferCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
		bufferCI.pNext = nullptr;
		bufferCI.flags = {};
		bufferCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
		bufferCI.queueFamilyIndexCount = 1;
		bufferCI.pQueueFamilyIndices = &graphicsFamilyIndex;
		bufferCI.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
		bufferCI.size = sizeof(pke_ui_box_instance_buffer_item) * arr.next;
		vkResult = vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &newBuffer);
		assert(vkResult == VK_SUCCESS);
		VkMemoryRequirements vkMemReqs;
		vkGetBufferMemoryRequirements(vkDevice, newBuffer, &vkMemReqs);
		assert(sizeof(pke_ui_box_instance_buffer_item) % vkMemReqs.alignment == 0);

		vkDestroyBuffer(vkDevice, newBuffer, vkAllocator);
		newBuffer = VK_NULL_HANDLE;

		bufferCI.size = vkMemReqs.size + (vkMemReqs.alignment - (vkMemReqs.size & vkMemReqs.alignment));
		vkResult = vkCreateBuffer(vkDevice, &bufferCI, vkAllocator, &newBuffer);
		assert(vkResult == VK_SUCCESS);

		VkDeviceMemory new_memory;
		VkMemoryAllocateInfo vkMemoryAllocateInfo;
		vkMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
		vkMemoryAllocateInfo.pNext = nullptr;
		vkMemoryAllocateInfo.allocationSize = bufferCI.size;
		vkMemoryAllocateInfo.memoryTypeIndex = FindMemoryTypeIndex(vkMemReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);

		vkResult = vkAllocateMemory(vkDevice, &vkMemoryAllocateInfo, vkAllocator, &new_memory);
		assert(vkResult == VK_SUCCESS);

		vkResult = vkBindBufferMemory(vkDevice, newBuffer, new_memory, 0);
		assert(vkResult == VK_SUCCESS);
		if (pke_ui_master.bindings.bd_instance.buffer != VK_NULL_HANDLE) {
			vkDestroyBuffer(vkDevice, pke_ui_master.bindings.bd_instance.buffer, vkAllocator);
		}
		if (pke_ui_master.bindings.deviceMemoryInst != VK_NULL_HANDLE) {
			vkFreeMemory(vkDevice, pke_ui_master.bindings.deviceMemoryInst, vkAllocator);
		}
		pke_ui_master.bindings.bd_instance.buffer = newBuffer;
		pke_ui_master.bindings.deviceMemoryInst = new_memory;
		pke_ui_master.bindings.instance_buffer_max_count = arr.next;
	}
	PKVK_TmpBufferDetails tmpBufferDetails{};
	PKVK_BeginBuffer(graphicsFamilyIndex, sizeof(pke_ui_box_instance_buffer_item) * arr.next, tmpBufferDetails);
	{
		VkCommandBufferBeginInfo vkCommandBufferBeginInfo;
		vkCommandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
		vkCommandBufferBeginInfo.pNext = nullptr;
		// TODO consider single-use?
		vkCommandBufferBeginInfo.flags = 0;
		vkCommandBufferBeginInfo.pInheritanceInfo = nullptr;
		vkResult = vkBeginCommandBuffer(tmpBufferDetails.cmdBuffer, &vkCommandBufferBeginInfo);
		assert(vkResult == VK_SUCCESS);

		memcpy(tmpBufferDetails.deviceData, arr.data, sizeof(pke_ui_box_instance_buffer_item) * arr.next);

		VkBufferCopy vk_buffer_copy{};
		vk_buffer_copy.srcOffset = 0;
		vk_buffer_copy.dstOffset = 0;
		vk_buffer_copy.size = sizeof(pke_ui_box_instance_buffer_item) * arr.next;
		vkCmdCopyBuffer(tmpBufferDetails.cmdBuffer, tmpBufferDetails.buffer, pke_ui_master.bindings.bd_instance.buffer, 1, &vk_buffer_copy);

		vkResult = vkEndCommandBuffer(tmpBufferDetails.cmdBuffer);
		assert(vkResult == VK_SUCCESS);

		VkSubmitInfo submitInfo;
		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
		submitInfo.pNext = nullptr;
		submitInfo.waitSemaphoreCount = 0;
		submitInfo.pWaitSemaphores = nullptr;
		submitInfo.pWaitDstStageMask = nullptr;
		submitInfo.commandBufferCount = 1;
		submitInfo.pCommandBuffers = &tmpBufferDetails.cmdBuffer;
		submitInfo.signalSemaphoreCount = 0;
		submitInfo.pSignalSemaphores = nullptr;
		vkResult = vkQueueSubmit(tmpBufferDetails.queue, 1, &submitInfo, nullptr);
		assert(vkResult == VK_SUCCESS);
		vkResult = vkQueueWaitIdle(tmpBufferDetails.queue);
		assert(vkResult == VK_SUCCESS);
	}
	PKVK_EndBuffer(tmpBufferDetails);
	pke_ui_master.bindings.instance_counter = arr.next;
}

void pke_ui_tick(double delta) {
	(void)delta;
	pke_ui_box_count_T i;
	if (pke_ui_master.h_root_boxes == 0) return;

	pke_ui_master.state.mouse_left      = pke_input_query_by_action_name(ui_ux_mouse_left);
	pke_ui_master.state.mouse_right     = pke_input_query_by_action_name(ui_ux_mouse_right);
	pke_ui_master.state.mouse_middle    = pke_input_query_by_action_name(ui_ux_mouse_middle);
	pke_ui_master.state.deepest_pressed = nullptr;

	pk_arr_t<pke_ui_box_instance_buffer_item> arr;
	pke_ui_master.px_scale = glm::vec2(
		2.0 / (float)Extent.width,
		2.0 / (float)Extent.height
	);
	for (i = 0; i < pke_ui_master.h_root_boxes; ++i) {
		pke_ui_box *box = pke_ui_master.root_boxes[i];
		pke_ui_calc_px(arr, nullptr, box);
		pke_ui_recalc_sizes_recursive(arr, box);
	}

	if (pke_ui_master.should_update_buffer || pkeSettings.rt.was_framebuffer_resized) {
		pke_ui_master.should_update_buffer = false;
		pke_ui_update_instance_buffer(arr);
	}

	if (pke_ui_master.state.deepest_pressed != NULL) {
		// fprintf(stdout, "box: " pk_uuid_printf_format " pressed!\n", pk_uuid_printf_var(pke_ui_master.state.deepest_pressed->uuid));
		struct pke_component_event *component_event = nullptr;
		switch (pke_ui_master.state.deepest_pressed->type) {
			case PKE_UI_BOX_TYPE_BUTTON_TEXT:
				component_event = ECS_GetEv(pke_ui_master.state.deepest_pressed->type_data->button_text.pke_event_handle);
				break;
			case PKE_UI_BOX_TYPE_BUTTON_IMAGE:
				component_event = ECS_GetEv(pke_ui_master.state.deepest_pressed->type_data->button_image.pke_event_handle);
				break;
			default:
				fprintf(stderr, "[static-ui] Something was pressed but we didn't know the type and couldn't emit.");
		}
		if (component_event != nullptr) {
			pk_ev_emit(component_event->ev_mgr_id, component_event->ev_id, nullptr);
		}
	}
}

void pke_ui_teardown_box_recursive(pke_ui_box *box) {
	for (pke_ui_box_count_T i = 0; i < box->internal.h_children; ++i) {
		pke_ui_teardown_box_recursive(box->internal.children[i]);
	}
	if (box->internal.children != nullptr) {
		pk_delete_arr<pke_ui_box *>(box->internal.children, box->internal.r_children, pke_ui_master.bkt);
	}
	pke_ui_master.should_update_buffer = true;
}

void pke_ui_teardown() {
	for (pke_ui_box_count_T i = 0; i < pke_ui_master.h_root_boxes; ++i) {
		pke_ui_teardown_box_recursive(pke_ui_master.root_boxes[i]);
	}
	pk_delete_arr<pke_ui_box *>(pke_ui_master.root_boxes, pke_ui_master.r_root_boxes, pke_ui_master.bkt);
	pk_mem_bucket_destroy(pke_ui_master.bkt);
	pke_ui_master.bkt = nullptr;
	pke_ui_master.root_boxes = nullptr;
	pke_ui_master.h_root_boxes = 0;
	pke_ui_master.r_root_boxes = 0;

	if (pke_ui_master.bindings.bd_vertex.buffer != VK_NULL_HANDLE)
		vkDestroyBuffer(vkDevice, pke_ui_master.bindings.bd_vertex.buffer, vkAllocator);
	pke_ui_master.bindings.bd_vertex.buffer = VK_NULL_HANDLE;
	pke_ui_master.bindings.bd_vertex.firstBinding = 0;
	pke_ui_master.bindings.bd_vertex.bindingCount = 0;
	pke_ui_master.bindings.bd_vertex.offsets[0] = 0;

	if (pke_ui_master.bindings.bd_uv.buffer != VK_NULL_HANDLE)
		vkDestroyBuffer(vkDevice, pke_ui_master.bindings.bd_uv.buffer, vkAllocator);
	pke_ui_master.bindings.bd_uv.buffer = VK_NULL_HANDLE;
	pke_ui_master.bindings.bd_uv.firstBinding = 0;
	pke_ui_master.bindings.bd_uv.bindingCount = 0;
	pke_ui_master.bindings.bd_uv.offsets[0] = 0;

	if (pke_ui_master.bindings.bd_index.buffer != VK_NULL_HANDLE)
		vkDestroyBuffer(vkDevice, pke_ui_master.bindings.bd_index.buffer, vkAllocator);
	pke_ui_master.bindings.bd_index.buffer = VK_NULL_HANDLE;
	pke_ui_master.bindings.bd_index.bindingCount = 0;
	pke_ui_master.bindings.bd_index.offsets[0] = 0;
	pke_ui_master.bindings.index_count = 0;

	if (pke_ui_master.bindings.bd_instance.buffer != VK_NULL_HANDLE)
		vkDestroyBuffer(vkDevice, pke_ui_master.bindings.bd_instance.buffer, vkAllocator);
	pke_ui_master.bindings.bd_instance.buffer = VK_NULL_HANDLE;
	pke_ui_master.bindings.bd_instance.firstBinding = 0;
	pke_ui_master.bindings.bd_instance.bindingCount = 0;
	pke_ui_master.bindings.instance_counter = 0;
	pke_ui_master.bindings.instance_buffer_max_count = 0;
	pke_ui_master.bindings.bd_instance.offsets[0] = 0;

	if (pke_ui_master.bindings.deviceMemoryInst != VK_NULL_HANDLE)
		vkFreeMemory(vkDevice, pke_ui_master.bindings.deviceMemoryInst, vkAllocator);
	pke_ui_master.bindings.deviceMemoryInst = VK_NULL_HANDLE;

	if (pke_ui_master.bindings.deviceMemoryVert != VK_NULL_HANDLE)
		vkFreeMemory(vkDevice, pke_ui_master.bindings.deviceMemoryVert, vkAllocator);
	pke_ui_master.bindings.deviceMemoryVert = VK_NULL_HANDLE;

	pke_input_unregister_set(pke_ui_master.input_action_set_handle);
}

pke_ui_box **pke_ui_get_root_boxes(pke_ui_box_count_T *count) {
	assert(count != nullptr);
	*count = pke_ui_master.h_root_boxes;
	return pke_ui_master.root_boxes;
}

void pke_ui_internal_new_typed_box(pke_ui_box *box, const PKE_UI_BOX_TYPE type) {
	assert(box->type == type);
	pke_ui_box_type_data *tp_data = nullptr;
	pke_component_event *pressed_ev = nullptr;
	switch (type) {
		case PKE_UI_BOX_TYPE_STANDARD:
			break;
		case PKE_UI_BOX_TYPE_TEXT:
			tp_data = pk_new<pke_ui_box_type_data>(pke_ui_master.bkt);
			box->flags |= PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE;
			break;
		case PKE_UI_BOX_TYPE_INPUT_TEXT:
			break;
		case PKE_UI_BOX_TYPE_BUTTON_TEXT:
			tp_data = pk_new<pke_ui_box_type_data>(pke_ui_master.bkt);
			tp_data->button_text.font_render_handle = FontRenderHandle_MAX;
			pressed_ev = ECS_CreateEv(box, pk_uuid_max);
			tp_data->button_text.pke_event_handle = pressed_ev->pke_event_handle;
			tp_data->button_text.ev_id = pressed_ev->ev_id;
			break;
		case PKE_UI_BOX_TYPE_BUTTON_IMAGE:
			tp_data = pk_new<pke_ui_box_type_data>(pke_ui_master.bkt);
			tp_data->button_image.image_memory = VK_NULL_HANDLE;
			tp_data->button_image.image_default = VK_NULL_HANDLE;
			tp_data->button_image.image_view_default = VK_NULL_HANDLE;
			tp_data->button_image.image_hovered = VK_NULL_HANDLE;
			tp_data->button_image.image_view_hovered = VK_NULL_HANDLE;
			tp_data->button_image.image_pressed = VK_NULL_HANDLE;
			tp_data->button_image.image_view_pressed = VK_NULL_HANDLE;
			pressed_ev = ECS_CreateEv(box, pk_uuid_max);
			tp_data->button_image.pke_event_handle = pressed_ev->pke_event_handle;
			tp_data->button_image.ev_id = pressed_ev->ev_id;
			break;
		default:
			assert(true == false && "unknown pke_ui_box::type");
			break;
	}
	box->type_data = tp_data;
}

pke_ui_box *pke_ui_box_new_root(const PKE_UI_BOX_TYPE type, pk_uuid uuid) {
	if (pke_ui_master.h_root_boxes == 0) {
		pke_input_activate_set(pke_ui_master.input_action_set_handle);
	}
	if (pke_ui_master.h_root_boxes == pke_ui_master.r_root_boxes) {
		pke_ui_box_count_T prev_r_root_boxes = pke_ui_master.r_root_boxes;
		pke_ui_master.r_root_boxes *= 1.5;
		pke_ui_box **boxes = pk_new_arr<pke_ui_box*>(pke_ui_master.r_root_boxes, pke_ui_master.bkt);
		for (pke_ui_box_count_T i = 0; i < pke_ui_master.h_root_boxes; ++i) {
			boxes[i] = pke_ui_master.root_boxes[i];
		}
		if (pke_ui_master.root_boxes != nullptr) pk_delete_arr<pke_ui_box*>(pke_ui_master.root_boxes, prev_r_root_boxes, pke_ui_master.bkt);
		pke_ui_master.root_boxes = boxes;
	}
	pke_ui_box *box = pk_new<pke_ui_box>(pke_ui_master.bkt);
	*box = {};
	pke_ui_master.root_boxes[pke_ui_master.h_root_boxes] = box;
	pke_ui_master.h_root_boxes += 1;
	pke_ui_master.should_update_buffer = true;
	box->type = type;
	box->uuid = uuid;
	box->internal.depth = 0;
	ECS_CreateEntity(box, nullptr);
	pke_ui_internal_new_typed_box(box, type);
	return box;
}

pke_ui_box *pke_ui_box_new_child(pke_ui_box *parent, const PKE_UI_BOX_TYPE type, pk_uuid uuid) {
	assert(parent != nullptr);

	// validation
	if (parent->type >= PKE_UI_BOX_TYPE_TEXT) {
		// this might be too broad, alter if needed
		fprintf(stdout, "[pke_ui_box_new_child] Validation error: PKE_UI_BOX_TYPE_TEXT cannot have children.");
		return nullptr;
	}

	if (parent->internal.h_children == parent->internal.r_children) {
		pke_ui_box_count_T prev_r_children = parent->internal.r_children;
		parent->internal.r_children = PK_MAX(parent->internal.r_children * 1.5, 2);
		pke_ui_box **boxes = pk_new_arr<pke_ui_box*>(parent->internal.r_children, pke_ui_master.bkt);
		for (pke_ui_box_count_T i = 0; i < parent->internal.h_children; ++i) {
			boxes[i] = parent->internal.children[i];
		}
		if (parent->internal.children != nullptr) {
			pk_delete_arr<pke_ui_box*>(parent->internal.children, prev_r_children, pke_ui_master.bkt);
		}
		parent->internal.children = boxes;
	}
	pke_ui_box *box = pk_new<pke_ui_box>(pke_ui_master.bkt);
	*box = {};
	parent->internal.children[parent->internal.h_children] = box;
	parent->internal.h_children += 1;
	box->type = type;
	box->internal.parent = parent;
	box->internal.depth = parent->internal.depth + 1;
	box->uuid = uuid;
	ECS_CreateEntity(box, parent);
	pke_ui_internal_new_typed_box(box, type);
	pke_ui_master.should_update_buffer = true;
	return box;
}

pke_ui_graphics_bindings *pke_ui_get_graphics_bindings() {
	return &pke_ui_master.bindings;
}