From c48dfce532debef12f0be359e1f1b81ac571d086 Mon Sep 17 00:00:00 2001 From: Noah Metz Date: Tue, 22 Oct 2024 18:22:18 -0600 Subject: [PATCH] Renamed UI structs --- client/include/draw.h | 2 +- client/include/ui.h | 120 +++++++++++++++++++-------------------- client/src/draw.c | 20 +++---- client/src/main.c | 111 +++++++++++++++++++++--------------- client/src/ui.c | 128 +++++++++++++++++++++--------------------- 5 files changed, 202 insertions(+), 179 deletions(-) diff --git a/client/include/draw.h b/client/include/draw.h index 80742d6..00f00eb 100644 --- a/client/include/draw.h +++ b/client/include/draw.h @@ -10,6 +10,6 @@ VkResult draw_frame( VkResult record_draw_commands( RenderContext* context, - UIContextStorage* ui_context); + UIContext* ui_context); #endif diff --git a/client/include/ui.h b/client/include/ui.h index c859fa3..c8a82de 100644 --- a/client/include/ui.h +++ b/client/include/ui.h @@ -38,22 +38,22 @@ typedef struct DispatchCommandStruct { uint32_t z; } DispatchCommand; -typedef struct FontStruct { +typedef struct GPUFontStruct { VkDeviceAddress symbol_list; uint32_t num_symbols; uint32_t width; uint32_t height; -} Font; +} GPUFont; -typedef struct SymbolInfoStruct { +typedef struct GPUSymbolStruct { float top; float left; float width; float height; float advance; -} SymbolInfo; +} GPUSymbol; -typedef struct FontStorageStruct { +typedef struct FontStruct { VmaAllocation symbol_memory; VmaAllocation image_memory; VkBuffer symbols; @@ -65,18 +65,18 @@ typedef struct FontStorageStruct { uint32_t index; char* family; char* style; -} FontStorage; +} Font; -typedef struct TextureStorageStruct { +typedef struct TextureStruct { VmaAllocation image_memory; VkImage image; VkImageView view; VkSampler sampler; char* path; -} TextureStorage; +} Texture; -typedef struct UIStringStruct { +typedef struct GPUStringStruct { vec2 pos; vec4 color; float size; @@ -84,9 +84,9 @@ typedef struct UIStringStruct { uint32_t length; uint32_t font; uint32_t id; -} UIString; +} GPUString; -typedef struct UIDrawableStruct { +typedef struct GPUDrawableStruct { vec2 pos; vec2 size; vec4 color; @@ -94,9 +94,9 @@ typedef struct UIDrawableStruct { uint32_t code; uint32_t index; uint32_t id; -} UIDrawable; +} GPUDrawable; -typedef struct UILayerStruct { +typedef struct GPULayerStruct { VkDeviceAddress strings; VkDeviceAddress codes; @@ -111,9 +111,9 @@ typedef struct UILayerStruct { uint32_t num_drawables; VkDeviceAddress container; -} UILayer; +} GPULayer; -typedef struct UIlayerStorageStruct { +typedef struct LayerStruct { VkBuffer strings; VkBuffer codes; VkBuffer drawables; @@ -126,41 +126,61 @@ typedef struct UIlayerStorageStruct { VkDeviceAddress address; - UIDrawable* drawables_buffer; - UIString* strings_buffer; + GPUDrawable* drawables_buffer; + GPUString* strings_buffer; uint32_t* codes_buffer; - UILayer data; -} UILayerStorage; + GPULayer data; +} Layer; + +typedef struct LayerInputStruct { + uint32_t num_strings; + uint32_t num_codes; + uint32_t num_drawables; + + GPUString* strings; + uint32_t* codes; + GPUDrawable* drawables; +} LayerInput; -typedef struct UIContainerStruct { +typedef struct GPUContainerStruct { vec2 offset; vec2 size; uint32_t anchor; -} UIContainer; +} GPUContainer; -typedef struct UIContainerStorageStruct { +typedef struct ContainerStruct { VkBuffer container; VmaAllocation container_memory; VkDeviceAddress address; - UIContainer data; + GPUContainer data; + + uint32_t id; + uint32_t layer_count; + Layer* layers; +} Container; +typedef struct ContainerInputStruct { uint32_t id; + uint32_t anchor; + vec2 offset; + vec2 size; + uint32_t layer_count; - UILayerStorage* layers; -} UIContainerStorage; + LayerInput* layers; +} ContainerInput; -typedef struct UIContextStruct { +typedef struct GPUUIContextStruct { VkDeviceAddress font_infos; vec2 screen; vec2 extent; vec2 scale; -} UIContext; +} GPUUIContext; -typedef struct UIContextStorageStruct { +typedef struct UIContext { VkDeviceAddress address; VkBuffer context; @@ -185,21 +205,21 @@ typedef struct UIContextStorageStruct { uint32_t max_fonts; uint32_t max_textures; - FontStorage* fonts; - TextureStorage* texture_slots; + Font* fonts; + Texture* texture_slots; uint32_t max_containers; - UIContainerStorage* containers; + Container* containers; - UIContext data; -} UIContextStorage; + GPUUIContext data; +} UIContext; VkResult create_ui_context( uint32_t max_fonts, uint32_t max_textures, uint32_t max_containers, RenderContext* gpu, - UIContextStorage* memory); + UIContext* context); VkResult load_font( const char* ttf_file, @@ -207,45 +227,25 @@ VkResult load_font( VkBool32 antialias, FT_Library library, RenderContext* gpu, - UIContextStorage* context, + UIContext* context, uint32_t* index); VkResult load_texture( const char* png_path, RenderContext* gpu, - UIContextStorage* context, + UIContext* context, uint32_t* index); -typedef struct UILayerInputStruct { - uint32_t num_strings; - uint32_t num_codes; - uint32_t num_drawables; - - UIString* strings; - uint32_t* codes; - UIDrawable* drawables; -} UILayerInput; - -typedef struct UIContainerInputStruct { - uint32_t id; - uint32_t anchor; - vec2 offset; - vec2 size; - - uint32_t layer_count; - UILayerInput* layers; -} UIContainerInput; - VkResult create_container( - UIContainerInput* container, + ContainerInput* container, RenderContext* gpu, - UIContextStorage* context); + UIContext* context); VkResult create_layer( uint32_t index, - UILayerInput* input, + LayerInput* input, RenderContext* gpu, - UIContainerStorage* container); + Container* container); VkResult map_string( const char * text, diff --git a/client/src/draw.c b/client/src/draw.c index dcbc629..654f9f5 100644 --- a/client/src/draw.c +++ b/client/src/draw.c @@ -8,7 +8,7 @@ * - ui_context->containers[*].layers[*].address <- device address * Basically, needs to be re-run whenever the number of layers/containers changes */ -void record_ui_compute(VkCommandBuffer command_buffer, UIContextStorage* ui_context) { +void record_ui_compute(VkCommandBuffer command_buffer, UIContext* ui_context) { VkDeviceAddress push[2] = {ui_context->address, 0}; vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, ui_context->string_pipeline.pipeline); @@ -19,28 +19,28 @@ void record_ui_compute(VkCommandBuffer command_buffer, UIContextStorage* ui_cont VkBufferMemoryBarrier draw_command_barrier_1 = { .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, .buffer = ui_context->containers[i].layers[j].layer, - .offset = offsetof(UILayer, draw), + .offset = offsetof(GPULayer, draw), .size = sizeof(DrawCommand), .srcAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, }; vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 1, &draw_command_barrier_1, 0, NULL); - command_copy_buffer(command_buffer, ui_context->containers[i].layers[j].layer, ui_context->containers[i].layers[j].layer, offsetof(UILayer, num_drawables), offsetof(UILayer, draw) + offsetof(DrawCommand, instance_count), sizeof(uint32_t)); + command_copy_buffer(command_buffer, ui_context->containers[i].layers[j].layer, ui_context->containers[i].layers[j].layer, offsetof(GPULayer, num_drawables), offsetof(GPULayer, draw) + offsetof(DrawCommand, instance_count), sizeof(uint32_t)); VkBufferMemoryBarrier draw_command_barrier_2 = { .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, .buffer = ui_context->containers[i].layers[j].layer, - .offset = offsetof(UILayer, draw), + .offset = offsetof(GPULayer, draw), .size = sizeof(DrawCommand), .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, .dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT, }; vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, NULL, 1, &draw_command_barrier_2, 0, NULL); vkCmdPushConstants(command_buffer, ui_context->string_pipeline.layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, 16, push); - vkCmdDispatchIndirect(command_buffer, ui_context->containers[i].layers[j].layer, offsetof(UILayer, dispatch_strings)); + vkCmdDispatchIndirect(command_buffer, ui_context->containers[i].layers[j].layer, offsetof(GPULayer, dispatch_strings)); VkBufferMemoryBarrier draw_command_barrier_3 = { .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, .buffer = ui_context->containers[i].layers[j].layer, - .offset = offsetof(UILayer, draw), + .offset = offsetof(GPULayer, draw), .size = sizeof(DrawCommand), .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT, .dstAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, @@ -51,7 +51,7 @@ void record_ui_compute(VkCommandBuffer command_buffer, UIContextStorage* ui_cont .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, .buffer = ui_context->containers[i].layers[j].drawables, .offset = 0, - .size = sizeof(UIDrawable)*ui_context->containers[i].layers[j].data.max_drawables, + .size = sizeof(GPUDrawable)*ui_context->containers[i].layers[j].data.max_drawables, .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT, .dstAccessMask = VK_ACCESS_SHADER_READ_BIT, }; @@ -68,7 +68,7 @@ void record_ui_compute(VkCommandBuffer command_buffer, UIContextStorage* ui_cont * - ui_context->containers[*].layers[*].address <- device address * Basically, needs to be re-run whenever the number of layers/containers changes */ -void record_ui_draw(VkCommandBuffer command_buffer, UIContextStorage* ui_context) { +void record_ui_draw(VkCommandBuffer command_buffer, UIContext* ui_context) { VkDeviceAddress push[2] = {ui_context->address, 0}; vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, ui_context->pipeline.pipeline); @@ -81,7 +81,7 @@ void record_ui_draw(VkCommandBuffer command_buffer, UIContextStorage* ui_context for(uint32_t j = 0; j < ui_context->containers[i].layer_count; j++) { push[1] = ui_context->containers[i].layers[j].address; vkCmdPushConstants(command_buffer, ui_context->pipeline.layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16, push); - vkCmdDrawIndirect(command_buffer, ui_context->containers[i].layers[j].layer, offsetof(UILayer, draw), 1, 0); + vkCmdDrawIndirect(command_buffer, ui_context->containers[i].layers[j].layer, offsetof(GPULayer, draw), 1, 0); } } } @@ -89,7 +89,7 @@ void record_ui_draw(VkCommandBuffer command_buffer, UIContextStorage* ui_context VkResult record_draw_commands( RenderContext* context, - UIContextStorage* ui_context) { + UIContext* ui_context) { VkResult result; for(uint32_t image_index = 0; image_index < context->swapchain_image_count; image_index++) { VkCommandBuffer command_buffer = context->swapchain_command_buffers[image_index]; diff --git a/client/src/main.c b/client/src/main.c index 2356a12..a0d2d55 100644 --- a/client/src/main.c +++ b/client/src/main.c @@ -10,30 +10,18 @@ #include "ft2build.h" #include FT_FREETYPE_H -VkResult render_thread(GLFWwindow* window, RenderContext* render) { - FT_Library library; - - UIContextStorage ui; - +VkResult i_dont_know_yet(GLFWwindow* window, UIContext* ui, RenderContext* render) { uint32_t font_index; uint32_t background_index; - + FT_Library library; VkResult result; - VK_RESULT(create_ui_context( - 10, - 10, - 10, - render, - &ui)); - if(FT_Init_FreeType(&library) != FT_Err_Ok) { return VK_ERROR_UNKNOWN; } + VK_RESULT(load_font("test.ttf", 16, VK_TRUE, library, render, ui, &font_index)); - VK_RESULT(load_font("test.ttf", 16, VK_TRUE, library, render, &ui, &font_index)); - - UIString context_strings[] = { + GPUString context_strings[] = { { .pos = {0, 16}, .size = 16, @@ -45,9 +33,9 @@ VkResult render_thread(GLFWwindow* window, RenderContext* render) { }; uint32_t context_codes[100]; - map_string("Example Text", context_codes, 0, ui.fonts[0].charmap, ui.fonts[0].num_symbols); + map_string("Example Text", context_codes, 0, ui->fonts[0].charmap, ui->fonts[0].num_symbols); - UILayerInput context_layers[] = { + LayerInput context_layers[] = { { .num_strings = 1, .strings = context_strings, @@ -56,17 +44,17 @@ VkResult render_thread(GLFWwindow* window, RenderContext* render) { }, }; - UIContainerInput context_info = { + ContainerInput context_info = { .id = 0x01, .anchor = ANCHOR_TOP_LEFT, .size = {WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT}, - .layer_count = sizeof(context_layers)/sizeof(UILayerInput), + .layer_count = sizeof(context_layers)/sizeof(LayerInput), .layers = context_layers, }; vec2 map_size = {250, 200}; - UIDrawable map_rects[] = { + GPUDrawable map_rects[] = { { .pos = {0.0, 0.0}, .size = {map_size[0], map_size[1]}, @@ -75,24 +63,24 @@ VkResult render_thread(GLFWwindow* window, RenderContext* render) { }, }; - UILayerInput map_layers[] = { + LayerInput map_layers[] = { { - .num_drawables = sizeof(map_rects)/sizeof(UIDrawable), + .num_drawables = sizeof(map_rects)/sizeof(GPUDrawable), .drawables = map_rects, }, }; - UIContainerInput map_info = { + ContainerInput map_info = { .id = 0x02, .anchor = ANCHOR_TOP_RIGHT, .size = {map_size[0], map_size[1]}, - .layer_count = sizeof(map_layers)/sizeof(UILayerInput), + .layer_count = sizeof(map_layers)/sizeof(LayerInput), .layers = map_layers, }; vec2 inventory_size = {map_size[0], WINDOW_MIN_HEIGHT-map_size[1]}; - UIDrawable inventory_rects[] = { + GPUDrawable inventory_rects[] = { { .pos = {0, 0}, .size = {inventory_size[0], inventory_size[1]}, @@ -101,24 +89,24 @@ VkResult render_thread(GLFWwindow* window, RenderContext* render) { }, }; - UILayerInput inventory_layers[] = { + LayerInput inventory_layers[] = { { - .num_drawables = sizeof(inventory_rects)/sizeof(UIDrawable), + .num_drawables = sizeof(inventory_rects)/sizeof(GPUDrawable), .drawables = inventory_rects, }, }; - UIContainerInput inventory_info = { + ContainerInput inventory_info = { .id = 0x03, .anchor = ANCHOR_BOTTOM_RIGHT, .size = {inventory_size[0], inventory_size[1]}, - .layer_count = sizeof(inventory_layers)/sizeof(UILayerInput), + .layer_count = sizeof(inventory_layers)/sizeof(LayerInput), .layers = inventory_layers, }; vec2 chat_size = {WINDOW_MIN_WIDTH-inventory_size[0], 200}; - UIDrawable chat_rects[] = { + GPUDrawable chat_rects[] = { { .pos = {0, 0}, .size = {chat_size[0], chat_size[1]}, @@ -127,27 +115,34 @@ VkResult render_thread(GLFWwindow* window, RenderContext* render) { }, }; - UILayerInput chat_layers[] = { + LayerInput chat_layers[] = { { - .num_drawables = sizeof(chat_rects)/sizeof(UIDrawable), + .num_drawables = sizeof(chat_rects)/sizeof(GPUDrawable), .drawables = chat_rects, }, }; - UIContainerInput chat_info = { + ContainerInput chat_info = { .id = 0x04, .anchor = ANCHOR_BOTTOM_LEFT, .size = {chat_size[0], chat_size[1]}, - .layer_count = sizeof(chat_layers)/sizeof(UILayerInput), + .layer_count = sizeof(chat_layers)/sizeof(LayerInput), .layers = chat_layers, }; - VK_RESULT(create_container(&context_info, render, &ui)); - VK_RESULT(create_container(&map_info, render, &ui)); - VK_RESULT(create_container(&inventory_info, render, &ui)); - VK_RESULT(create_container(&chat_info, render, &ui)); + VK_RESULT(create_container(&context_info, render, ui)); + VK_RESULT(create_container(&map_info, render, ui)); + VK_RESULT(create_container(&inventory_info, render, ui)); + VK_RESULT(create_container(&chat_info, render, ui)); + + VK_RESULT(record_draw_commands(render, ui)); + + return VK_SUCCESS; +} + +VkResult render_thread(GLFWwindow* window, RenderContext* render, UIContext* ui) { - VK_RESULT(record_draw_commands(render, &ui)); + VkResult result; double last_frame_time = glfwGetTime(); while(glfwWindowShouldClose(window) == 0) { @@ -165,6 +160,18 @@ VkResult render_thread(GLFWwindow* window, RenderContext* render) { return 0; } +typedef enum ClientAuthStateEnum { + AUTH_SAVED, + AUTH_CREDENTIALS, + AUTH_ATTEMPT, + AUTH_ERROR, + AUTH_SUCCESS, +} ClientAuthState; + +typedef struct ClientStateStruct { + +} ClientState; + int logic_thread() { return 0; } @@ -227,11 +234,27 @@ int main() { glfwSetCursorPosCallback(window, cursor_pos_callback); RenderContext render = {}; - if(init_vulkan(window, &render) != VK_SUCCESS) { - return 2; - } + UIContext ui = {}; + + VkResult result; + VK_RESULT(init_vulkan(window, &render)); + + VK_RESULT(create_ui_context( + 10, + 10, + 10, + &render, + &ui)); + + ////////////////////////////////// + /// Test Code + ////////////////////////////////// + + VK_RESULT(i_dont_know_yet(window, &ui, &render)); + + ////////////////////////////////// - if(render_thread(window, &render) != VK_SUCCESS) { + if(render_thread(window, &render, &ui) != VK_SUCCESS) { return 3; } diff --git a/client/src/ui.c b/client/src/ui.c index 9b68c68..589cb6f 100644 --- a/client/src/ui.c +++ b/client/src/ui.c @@ -276,9 +276,9 @@ VkResult create_ui_pipeline( } VkResult create_container( - UIContainerInput* container, + ContainerInput* container, RenderContext* gpu, - UIContextStorage* context) { + UIContext* context) { uint32_t index = 0xFFFFFFFF; for(uint32_t i = 0; i < context->max_containers; i++) { if(context->containers[i].id == 0x00000000) { @@ -292,29 +292,29 @@ VkResult create_container( VkResult result; - VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(UIContainer), &context->containers[index].container, &context->containers[index].container_memory)); + VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(GPUContainer), &context->containers[index].container, &context->containers[index].container_memory)); VkBuffer transfer; VmaAllocation transfer_memory; void* mapped; - VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(UIContainer), &transfer, &transfer_memory, &mapped)); + VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(GPUContainer), &transfer, &transfer_memory, &mapped)); context->containers[index].data.offset[0] = container->offset[0]; context->containers[index].data.offset[1] = container->offset[1]; context->containers[index].data.size[0] = container->size[0]; context->containers[index].data.size[1] = container->size[1]; context->containers[index].data.anchor = container->anchor; - memcpy(mapped, &context->containers[index].data, sizeof(UIContainer)); + memcpy(mapped, &context->containers[index].data, sizeof(GPUContainer)); VkCommandBuffer command_buffer = command_begin_single(gpu->device, gpu->transfer_pool); - command_copy_buffer(command_buffer, transfer, context->containers[index].container, 0, 0, sizeof(UIContainer)); + command_copy_buffer(command_buffer, transfer, context->containers[index].container, 0, 0, sizeof(GPUContainer)); VK_RESULT(command_end_single(gpu->device, command_buffer, gpu->transfer_pool, gpu->transfer_queue)); destroy_transfer_buffer(gpu->allocator, transfer, transfer_memory); context->containers[index].address = buffer_address(gpu->device, context->containers[index].container); context->containers[index].id = container->id; context->containers[index].layer_count = container->layer_count; - context->containers[index].layers = malloc(sizeof(UILayerStorage)*container->layer_count); + context->containers[index].layers = malloc(sizeof(Layer)*container->layer_count); for(uint32_t i = 0; i < container->layer_count; i++) { VK_RESULT(create_layer(i, &container->layers[i], gpu, &context->containers[index])); } @@ -324,19 +324,19 @@ VkResult create_container( VkResult create_layer( uint32_t index, - UILayerInput* input, + LayerInput* input, RenderContext* gpu, - UIContainerStorage* container) { + Container* container) { VkResult result; - VK_RESULT(create_storage_buffer(gpu->allocator, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, sizeof(UILayer), &container->layers[index].layer, &container->layers[index].layer_memory)); + VK_RESULT(create_storage_buffer(gpu->allocator, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, sizeof(GPULayer), &container->layers[index].layer, &container->layers[index].layer_memory)); if(input->num_strings > 0) { - VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(UIString)*input->num_strings, &container->layers[index].strings, &container->layers[index].strings_memory)); - container->layers[index].strings_buffer = malloc(sizeof(UIString)*input->num_strings); + VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(GPUString)*input->num_strings, &container->layers[index].strings, &container->layers[index].strings_memory)); + container->layers[index].strings_buffer = malloc(sizeof(GPUString)*input->num_strings); } if(input->num_codes + input->num_drawables > 0) { - VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(UIDrawable)*(input->num_drawables + input->num_codes), &container->layers[index].drawables, &container->layers[index].drawables_memory)); - container->layers[index].drawables_buffer = malloc(sizeof(UIDrawable)*input->num_drawables); + VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(GPUDrawable)*(input->num_drawables + input->num_codes), &container->layers[index].drawables, &container->layers[index].drawables_memory)); + container->layers[index].drawables_buffer = malloc(sizeof(GPUDrawable)*input->num_drawables); } if(input->num_codes > 0) { VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(uint32_t)*input->num_codes, &container->layers[index].codes, &container->layers[index].codes_memory)); @@ -346,7 +346,7 @@ VkResult create_layer( VkBuffer transfer; VmaAllocation transfer_memory; void* mapped; - VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(UILayer) + sizeof(UIString) * input->num_strings + sizeof(UIDrawable)*input->num_drawables + sizeof(uint32_t)*input->num_codes, &transfer, &transfer_memory, &mapped)); + VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(GPULayer) + sizeof(GPUString) * input->num_strings + sizeof(GPUDrawable)*input->num_drawables + sizeof(uint32_t)*input->num_codes, &transfer, &transfer_memory, &mapped)); if(input->num_strings > 0) { container->layers[index].data.strings = buffer_address(gpu->device, container->layers[index].strings); @@ -380,35 +380,35 @@ VkResult create_layer( container->layers[index].data.max_strings = input->num_strings; container->layers[index].data.num_drawables = input->num_drawables; container->layers[index].data.container = container->address; - memcpy(mapped, &container->layers[index].data, sizeof(UILayer)); + memcpy(mapped, &container->layers[index].data, sizeof(GPULayer)); VkCommandBuffer command_buffer = command_begin_single(gpu->device, gpu->transfer_pool); - command_copy_buffer(command_buffer, transfer, container->layers[index].layer, 0, 0, sizeof(UILayer)); + command_copy_buffer(command_buffer, transfer, container->layers[index].layer, 0, 0, sizeof(GPULayer)); if(input->num_strings > 0) { - UIString* strings = (UIString*)(mapped + sizeof(UILayer)); + GPUString* strings = (GPUString*)(mapped + sizeof(GPULayer)); for(uint32_t i = 0; i < input->num_strings; i++) { - memcpy(&strings[i], &input->strings[i], sizeof(UIString)); - memcpy(&container->layers[index].strings_buffer[i], &input->strings[i], sizeof(UIString)); + memcpy(&strings[i], &input->strings[i], sizeof(GPUString)); + memcpy(&container->layers[index].strings_buffer[i], &input->strings[i], sizeof(GPUString)); } - command_copy_buffer(command_buffer, transfer, container->layers[index].strings, sizeof(UILayer), 0, sizeof(UIString)*input->num_strings); + command_copy_buffer(command_buffer, transfer, container->layers[index].strings, sizeof(GPULayer), 0, sizeof(GPUString)*input->num_strings); } if(input->num_drawables > 0) { - UIDrawable* drawables = (UIDrawable*)(mapped + sizeof(UILayer) + sizeof(UIString)*input->num_strings); + GPUDrawable* drawables = (GPUDrawable*)(mapped + sizeof(GPULayer) + sizeof(GPUString)*input->num_strings); for(uint32_t i = 0; i < input->num_drawables; i++) { - memcpy(&drawables[i], &input->drawables[i], sizeof(UIDrawable)); - memcpy(&container->layers[index].drawables_buffer[i], &input->drawables[i], sizeof(UIDrawable)); + memcpy(&drawables[i], &input->drawables[i], sizeof(GPUDrawable)); + memcpy(&container->layers[index].drawables_buffer[i], &input->drawables[i], sizeof(GPUDrawable)); } - command_copy_buffer(command_buffer, transfer, container->layers[index].drawables, sizeof(UILayer) + sizeof(UIString)*input->num_strings, 0, sizeof(UIDrawable)*input->num_drawables); + command_copy_buffer(command_buffer, transfer, container->layers[index].drawables, sizeof(GPULayer) + sizeof(GPUString)*input->num_strings, 0, sizeof(GPUDrawable)*input->num_drawables); } if(input->num_codes > 0) { - uint32_t* codes = (uint32_t*)(mapped + sizeof(UILayer) + sizeof(UIString)*input->num_strings + sizeof(UIDrawable)*input->num_drawables); + uint32_t* codes = (uint32_t*)(mapped + sizeof(GPULayer) + sizeof(GPUString)*input->num_strings + sizeof(GPUDrawable)*input->num_drawables); for(uint32_t i = 0; i < input->num_codes; i++) { codes[i] = input->codes[i]; container->layers[index].codes_buffer[i] = input->codes[i]; } - command_copy_buffer(command_buffer, transfer, container->layers[index].codes, sizeof(UILayer) + sizeof(UIString)*input->num_strings + sizeof(UIDrawable)*input->num_drawables, 0, sizeof(uint32_t)*input->num_codes); + command_copy_buffer(command_buffer, transfer, container->layers[index].codes, sizeof(GPULayer) + sizeof(GPUString)*input->num_strings + sizeof(GPUDrawable)*input->num_drawables, 0, sizeof(uint32_t)*input->num_codes); } VK_RESULT(command_end_single(gpu->device, command_buffer, gpu->transfer_pool, gpu->transfer_queue)); vkQueueWaitIdle(gpu->transfer_queue.handle); @@ -422,7 +422,7 @@ VkResult create_layer( VkResult load_texture( const char* png_path, RenderContext* gpu, - UIContextStorage* context, + UIContext* context, uint32_t* index) { *index = 0xFFFFFFFF; for(uint32_t i = 0; i < context->max_textures; i++) { @@ -636,7 +636,7 @@ VkResult load_font( VkBool32 antialias, FT_Library library, RenderContext* gpu, - UIContextStorage* context, + UIContext* context, uint32_t* index){ FT_Face face; @@ -669,8 +669,8 @@ VkResult load_font( } uint32_t* tmp_charmap = malloc(sizeof(uint32_t)*face->num_glyphs); - SymbolInfo* symbols = malloc(sizeof(SymbolInfo)*face->num_glyphs); - Font info; + GPUSymbol* symbols = malloc(sizeof(GPUSymbol)*face->num_glyphs); + GPUFont info; uint32_t glyph_index; uint32_t max_height = 0; @@ -735,7 +735,7 @@ VkResult load_font( } VkResult result; - VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(SymbolInfo)*info.num_symbols, &context->fonts[*index].symbols, &context->fonts[*index].symbol_memory)); + VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(GPUSymbol)*info.num_symbols, &context->fonts[*index].symbols, &context->fonts[*index].symbol_memory)); VkImageCreateInfo image_info = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, @@ -761,20 +761,20 @@ VkResult load_font( VkBuffer transfer; VmaAllocation transfer_memory; void* mapped; - VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(Font) + image_size*info.num_symbols + sizeof(SymbolInfo)*info.num_symbols, &transfer, &transfer_memory, &mapped)); + VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(GPUFont) + image_size*info.num_symbols + sizeof(GPUSymbol)*info.num_symbols, &transfer, &transfer_memory, &mapped)); info.symbol_list = buffer_address(gpu->device, context->fonts[*index].symbols); memcpy(mapped, images, image_size*info.num_symbols); - memcpy(mapped + image_size*info.num_symbols, &info, sizeof(Font)); - memcpy(mapped + image_size*info.num_symbols + sizeof(Font), symbols, sizeof(SymbolInfo)*info.num_symbols); + memcpy(mapped + image_size*info.num_symbols, &info, sizeof(GPUFont)); + memcpy(mapped + image_size*info.num_symbols + sizeof(GPUFont), symbols, sizeof(GPUSymbol)*info.num_symbols); free(images); free(symbols); VkCommandBuffer command_buffer = command_begin_single(gpu->device, gpu->transfer_pool); - command_copy_buffer(command_buffer, transfer, context->font_infos, image_size*info.num_symbols, *index*sizeof(Font), sizeof(Font)); - command_copy_buffer(command_buffer, transfer, context->fonts[*index].symbols, image_size*info.num_symbols + sizeof(Font), 0, sizeof(SymbolInfo)*info.num_symbols); + command_copy_buffer(command_buffer, transfer, context->font_infos, image_size*info.num_symbols, *index*sizeof(GPUFont), sizeof(GPUFont)); + command_copy_buffer(command_buffer, transfer, context->fonts[*index].symbols, image_size*info.num_symbols + sizeof(GPUFont), 0, sizeof(GPUSymbol)*info.num_symbols); VkImageMemoryBarrier first_barrier = { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, @@ -1063,48 +1063,48 @@ VkResult create_ui_context( uint32_t max_textures, uint32_t max_containers, RenderContext* gpu, - UIContextStorage* memory) { + UIContext* context) { VkResult result; - VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(UIContext), &memory->context, &memory->context_memory)); - VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(Font)*max_fonts, &memory->font_infos, &memory->font_infos_memory)); + VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(GPUUIContext), &context->context, &context->context_memory)); + VK_RESULT(create_storage_buffer(gpu->allocator, 0, sizeof(GPUFont)*max_fonts, &context->font_infos, &context->font_infos_memory)); VkBuffer transfer; - VmaAllocation transfer_memory; + VmaAllocation transfer_context; UIContext* mapped; - VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(UIContext), &transfer, &transfer_memory, (void**)&mapped)); + VK_RESULT(create_transfer_buffer(gpu->allocator, sizeof(UIContext), &transfer, &transfer_context, (void**)&mapped)); - memory->data.font_infos = buffer_address(gpu->device, memory->font_infos); - memory->data.screen[0] = gpu->window_scale[0] / gpu->swapchain_extent.width; - memory->data.screen[1] = gpu->window_scale[1] / gpu->swapchain_extent.height; - memory->data.extent[0] = gpu->swapchain_extent.width / gpu->window_scale[0]; - memory->data.extent[1] = gpu->swapchain_extent.height / gpu->window_scale[1]; - memory->data.scale[0] = gpu->window_scale[0]; - memory->data.scale[1] = gpu->window_scale[1]; - memcpy(mapped, &memory->data, sizeof(UIContext)); + context->data.font_infos = buffer_address(gpu->device, context->font_infos); + context->data.screen[0] = gpu->window_scale[0] / gpu->swapchain_extent.width; + context->data.screen[1] = gpu->window_scale[1] / gpu->swapchain_extent.height; + context->data.extent[0] = gpu->swapchain_extent.width / gpu->window_scale[0]; + context->data.extent[1] = gpu->swapchain_extent.height / gpu->window_scale[1]; + context->data.scale[0] = gpu->window_scale[0]; + context->data.scale[1] = gpu->window_scale[1]; + memcpy(mapped, &context->data, sizeof(GPUUIContext)); VkCommandBuffer command_buffer = command_begin_single(gpu->device, gpu->transfer_pool); - command_copy_buffer(command_buffer, transfer, memory->context, 0, 0, sizeof(UIContext)); + command_copy_buffer(command_buffer, transfer, context->context, 0, 0, sizeof(GPUUIContext)); VK_RESULT(command_end_single(gpu->device, command_buffer, gpu->transfer_pool, gpu->transfer_queue)); - destroy_transfer_buffer(gpu->allocator, transfer, transfer_memory); - memory->address = buffer_address(gpu->device, memory->context); + destroy_transfer_buffer(gpu->allocator, transfer, transfer_context); + context->address = buffer_address(gpu->device, context->context); - VK_RESULT(create_ui_descriptor(gpu->device, max_fonts, max_textures, &memory->samplers_layout, &memory->textures_layout, &memory->samplers, &memory->textures, &memory->font_samplers, &memory->font_textures, &memory->fonts_pool, &memory->textures_pool)); + VK_RESULT(create_ui_descriptor(gpu->device, max_fonts, max_textures, &context->samplers_layout, &context->textures_layout, &context->samplers, &context->textures, &context->font_samplers, &context->font_textures, &context->fonts_pool, &context->textures_pool)); - VK_RESULT(create_ui_pipeline(gpu->device, gpu->render_pass, memory->samplers_layout, memory->textures_layout, &memory->pipeline, &memory->string_pipeline)); + VK_RESULT(create_ui_pipeline(gpu->device, gpu->render_pass, context->samplers_layout, context->textures_layout, &context->pipeline, &context->string_pipeline)); - memory->max_textures = max_textures; - memory->max_fonts = max_fonts; - memory->max_containers = max_containers; + context->max_textures = max_textures; + context->max_fonts = max_fonts; + context->max_containers = max_containers; - memory->texture_slots = malloc(max_textures*sizeof(TextureStorage)); - memset(memory->texture_slots, 0, max_textures*sizeof(TextureStorage)); - memory->fonts = malloc(max_fonts*sizeof(FontStorage)); - memset(memory->fonts, 0, max_fonts*sizeof(FontStorage)); - memory->containers = malloc(max_containers*sizeof(UIContainerStorage)); - memset(memory->containers, 0, max_containers*sizeof(UIContainerStorage)); + context->texture_slots = malloc(max_textures*sizeof(Texture)); + memset(context->texture_slots, 0, max_textures*sizeof(Texture)); + context->fonts = malloc(max_fonts*sizeof(Font)); + memset(context->fonts, 0, max_fonts*sizeof(Font)); + context->containers = malloc(max_containers*sizeof(Container)); + memset(context->containers, 0, max_containers*sizeof(Container)); return VK_SUCCESS; }