client/include/draw.h

@@ -6,7 +6,10 @@
 
 VkResult draw_frame(
     RenderContext* context,
-    UIContext* ui,
     double time);
 
+VkResult record_draw_commands(
+    RenderContext* context,
+    UIContext* ui_context);
+
 #endif

client/include/gpu.h

@@ -24,20 +24,20 @@
 #include <cglm/quat.h>
 #include <cglm/cam.h>
 
-typedef struct GPUQueueStruct {
+typedef struct QueueStruct {
   VkQueue handle;
   uint32_t family;
   uint32_t index;
-} GPUQueue;
+} Queue;
 
 
 VkCommandBuffer command_begin_single(VkDevice device, VkCommandPool transfer_pool);
 
-VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkCommandPool transfer_pool, GPUQueue transfer_queue);
+VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkCommandPool transfer_pool, Queue transfer_queue);
 
 void command_copy_buffer(VkCommandBuffer command_buffer, VkBuffer src, VkBuffer dst, VkDeviceSize src_offset, VkDeviceSize dst_offset, VkDeviceSize size);
 
-VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer_pool, GPUQueue transfer_queue, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, VkAccessFlags src_mask, VkAccessFlags dst_mask, VkPipelineStageFlags source, VkPipelineStageFlags dest, uint32_t source_family, uint32_t dest_family, VkImageAspectFlags aspect_flags);
+VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer_pool, Queue transfer_queue, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, VkAccessFlags src_mask, VkAccessFlags dst_mask, VkPipelineStageFlags source, VkPipelineStageFlags dest, uint32_t source_family, uint32_t dest_family, VkImageAspectFlags aspect_flags);
 
 #define VK_RESULT(x) {\
  result = x;\
@@ -66,9 +66,9 @@ typedef struct RenderContextStruct {
   VkPhysicalDevice physical_device;
   VkPhysicalDeviceMemoryProperties memories;
   VkSurfaceKHR surface;
-  GPUQueue graphics_queue;
-  GPUQueue present_queue;
-  GPUQueue transfer_queue;
+  Queue graphics_queue;
+  Queue present_queue;
+  Queue transfer_queue;
   VkDevice device;
   VmaAllocator allocator;
 

client/include/ui.h

@@ -38,12 +38,6 @@ typedef struct DispatchCommandStruct {
   uint32_t z;
 } DispatchCommand;
 
-typedef struct UIPushConstantStruct {
-  VkDeviceAddress layer;
-  float time;
-  float pad;
-} UIPushConstant;
-
 typedef struct GPUFontStruct {
   VkDeviceAddress symbol_list;
   uint32_t num_symbols;
@@ -97,10 +91,8 @@ typedef struct GPUDrawableStruct {
   vec2     size;
   vec4     color;
   uint32_t type;
-  uint32_t var1;
-  uint32_t var2;
-  float    var3;
-  float    var4;
+  uint32_t code;
+  uint32_t index;
   uint32_t id;
 } GPUDrawable;
 
@@ -155,8 +147,6 @@ typedef struct GPUContainerStruct {
   vec2 offset;
   vec2 size;
   uint32_t anchor;
-
-  VkDeviceAddress context;
 } GPUContainer;
 
 typedef struct ContainerStruct {

client/shader_src/string.comp

@@ -3,12 +3,17 @@
 
 #include "ui_common.glsl"
 
+layout(std430, push_constant) uniform PushConstant {
+  Context context;
+  Layer   layer;
+} pc;
+
 layout(local_size_x = 1) in;
 
 void main() {
   uint gID = gl_GlobalInvocationID.x;
   String string = pc.layer.strings.s[gID];
-  Font font = pc.layer.container.context.fonts.f[string.font];
+  Font font = pc.context.fonts.f[string.font];
 
   uint buffer_pos = atomicAdd(pc.layer.draw.instance_count, string.len);
   vec2 pen = vec2(0.0, 0.0);
@@ -19,8 +24,8 @@ void main() {
     pen += string.size*symbol.advance;
     pc.layer.drawables.d[buffer_pos + i].size = vec2(string.size, string.size);
     pc.layer.drawables.d[buffer_pos + i].color = string.color;
-    pc.layer.drawables.d[buffer_pos + i].var1 = pc.layer.codes.c[string.offset + i];
-    pc.layer.drawables.d[buffer_pos + i].var2 = string.font;
+    pc.layer.drawables.d[buffer_pos + i].code = pc.layer.codes.c[string.offset + i];
+    pc.layer.drawables.d[buffer_pos + i].index = string.font;
     pc.layer.drawables.d[buffer_pos + i].type = 1;
   }
 }

client/shader_src/ui.frag

@@ -4,6 +4,11 @@
 
 #include "ui_common.glsl"
 
+layout(std430, push_constant) uniform PushConstant {
+  Context context;
+  Layer   layer;
+} pc;
+
 layout(set = 0, binding = 0) uniform sampler font_samplers[];
 layout(set = 1, binding = 0) uniform texture2DArray font_textures[];
 
@@ -20,7 +25,7 @@ layout(location = 5) flat in vec2 container_offset;
 layout(location = 0) out vec4 outColor;
 
 void main() {
-    vec2 pos = (gl_FragCoord.xy - vec2(0.5, 0.5))/pc.layer.container.context.scale;
+    vec2 pos = (gl_FragCoord.xy - vec2(0.5, 0.5))/pc.context.scale;
     vec2 min = container_offset;
     vec2 max = min + pc.layer.container.size;
     if(pos.x < min.x || pos.y < min.y

client/shader_src/ui.vert

@@ -3,10 +3,15 @@
 
 #include "ui_common.glsl"
 
+layout(std430, push_constant) uniform PushConstant {
+  Context context;
+  Layer   layer;
+} pc;
+
 layout(location = 0) out vec4 fragColor;
 layout(location = 1) out vec2 fragUV;
-layout(location = 2) out flat uint var1;
-layout(location = 3) out flat uint var2;
+layout(location = 2) out flat uint code;
+layout(location = 3) out flat uint index;
 layout(location = 4) out flat uint type;
 layout(location = 5) out flat vec2 container_offset;
 
@@ -30,23 +35,24 @@ void main() {
   
   // Top Right
   if(pc.layer.container.anchor == 1) {
-    container_offset = pc.layer.container.offset + vec2(pc.layer.container.context.extent.x - pc.layer.container.size.x, 0);
+    container_offset = pc.layer.container.offset + vec2(pc.context.extent.x - pc.layer.container.size.x, 0);
   }
 
   // Bottom Left
   if(pc.layer.container.anchor == 2) {
-    container_offset = pc.layer.container.offset + vec2(0, pc.layer.container.context.extent.y - pc.layer.container.size.y);
+    container_offset = pc.layer.container.offset + vec2(0, pc.context.extent.y - pc.layer.container.size.y);
   }
 
   // Bottom Right
   if(pc.layer.container.anchor == 3) {
-    container_offset = pc.layer.container.offset + vec2(pc.layer.container.context.extent.x - pc.layer.container.size.x, pc.layer.container.context.extent.y - pc.layer.container.size.y);
+    container_offset = pc.layer.container.offset + vec2(pc.context.extent.x - pc.layer.container.size.x, pc.context.extent.y - pc.layer.container.size.y);
   }
 
+  
   if(drawable.type == 1){
     // Glyph
-    Font font = pc.layer.container.context.fonts.f[drawable.var2];
-    Symbol symbol = font.symbols.s[drawable.var1];
+    Font font = pc.context.fonts.f[drawable.index];
+    Symbol symbol = font.symbols.s[drawable.code];
 
     fragUV = pos * vec2(symbol.width, symbol.height);
     pos = pos * vec2(symbol.width, symbol.height) + vec2(symbol.left, -symbol.top);
@@ -54,11 +60,11 @@ void main() {
     fragUV = pos;
   }
 
-  gl_Position = vec4((pos * drawable.size + drawable.pos + container_offset) * pc.layer.container.context.screen * 2, 0.0, 1.0) - vec4(1.0, 1.0, 0.0, 0.0);
+  gl_Position = vec4((pos * drawable.size + drawable.pos + container_offset) * pc.context.screen * 2, 0.0, 1.0) - vec4(1.0, 1.0, 0.0, 0.0);
   
   fragColor = drawable.color;
+  code = drawable.code;
   type = drawable.type;
-  var1 = drawable.var1;
-  var2 = drawable.var2;
+  index = drawable.index;
 }
 

client/shader_src/ui_common.glsl

@@ -61,10 +61,8 @@ struct Drawable {
   vec2 size;
   vec4 color;
   uint type;
-  uint var1;
-  uint var2;
-  float var3;
-  float var4;
+  uint code;
+  uint index;
   uint id;
 };
 
@@ -72,19 +70,10 @@ layout(std430, buffer_reference) readonly buffer DrawableList {
   Drawable d[];
 };
 
-layout(std430, buffer_reference) buffer Context {
-  FontList fonts;
-  vec2 screen;
-  vec2 extent;
-  vec2 scale;
-};
-
 layout(std430, buffer_reference) readonly buffer Container {
   vec2 offset;
   vec2 size;
   uint anchor;
-
-  Context context;
 };
 
 layout(std430, buffer_reference) readonly buffer Layer {
@@ -103,7 +92,9 @@ layout(std430, buffer_reference) readonly buffer Layer {
   Container container;
 };
 
-layout(std430, push_constant) uniform PushConstant {
-  Layer layer;
-  float time;
-} pc;
+layout(std430, buffer_reference) buffer Context {
+  FontList fonts;
+  vec2 screen;
+  vec2 extent;
+  vec2 scale;
+};

client/src/draw.c

@@ -8,17 +8,14 @@
  * - 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, UIContext* ui_context, double time) {
-  UIPushConstant push = {
-    .time = (float)time,
-    .layer = 0,
-  };
+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);
   for(uint32_t i = 0; i < ui_context->max_containers; i++) {
     if(ui_context->containers[i].id != 0x00000000) {
       for(uint32_t j = 0; j < ui_context->containers[i].layer_count; j++) {
-        push.layer = ui_context->containers[i].layers[j].address;
+        push[1] = ui_context->containers[i].layers[j].address;
         VkBufferMemoryBarrier draw_command_barrier_1 = {
           .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
           .buffer = ui_context->containers[i].layers[j].layer,
@@ -38,7 +35,7 @@ void record_ui_compute(VkCommandBuffer command_buffer, UIContext* ui_context, do
           .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);
+        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(GPULayer, dispatch_strings));
         VkBufferMemoryBarrier draw_command_barrier_3 = {
           .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
@@ -71,11 +68,8 @@ void record_ui_compute(VkCommandBuffer command_buffer, UIContext* ui_context, do
  * - 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, UIContext* ui_context, double time) {
-  UIPushConstant push = {
-    .time = (float)time,
-    .layer = 0,
-  };
+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);
   vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, ui_context->pipeline.layout, 0, 1, &ui_context->font_samplers, 0, NULL);
@@ -85,18 +79,71 @@ void record_ui_draw(VkCommandBuffer command_buffer, UIContext* ui_context, doubl
   for(uint32_t i = 0; i < ui_context->max_containers; i++) {
     if(ui_context->containers[i].id != 0x00000000) {
       for(uint32_t j = 0; j < ui_context->containers[i].layer_count; j++) {
-        push.layer = 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);
+        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(GPULayer, draw), 1, 0);
       }
     }
   }
 }
 
+VkResult record_draw_commands(
+    RenderContext* 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];
+    VK_RESULT(vkResetCommandBuffer(command_buffer, 0));
+
+    VkCommandBufferBeginInfo begin_info = {
+      .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+    }; 
+    VK_RESULT(vkBeginCommandBuffer(command_buffer, &begin_info));
+
+    VkViewport viewport = {
+      .width = context->swapchain_extent.width,
+      .height = context->swapchain_extent.height,
+      .maxDepth = 1.0f,
+      .minDepth = 0.0f,
+    };
+    vkCmdSetViewport(command_buffer, 0, 1, &viewport);
+
+    VkRect2D scissor = {
+      .extent = context->swapchain_extent,
+    };
+    vkCmdSetScissor(command_buffer, 0, 1, &scissor);
+
+    VkClearValue clear_values[2] = {{.color={{0.0f, 0.0f, 0.0f, 0.0f}}}, {.depthStencil={1.0f, 0.0f}}};
+
+    VkRenderPassBeginInfo render_pass_begin = {
+      .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+      .renderPass = context->render_pass,
+      .framebuffer = context->swapchain_framebuffers[image_index],
+      .renderArea.offset = {0, 0},
+      .renderArea.extent = context->swapchain_extent,
+      .clearValueCount = 2,
+      .pClearValues = clear_values,
+    }; 
+
+    record_ui_compute(command_buffer, ui_context);
+    vkCmdBeginRenderPass(command_buffer, &render_pass_begin, VK_SUBPASS_CONTENTS_INLINE);
+    // Render World
+    vkCmdNextSubpass(command_buffer, VK_SUBPASS_CONTENTS_INLINE);
+    // Render UI
+    record_ui_draw(command_buffer, ui_context);
+    vkCmdEndRenderPass(command_buffer);
+
+    VK_RESULT(vkEndCommandBuffer(command_buffer));
+  }
+
+
+  return VK_SUCCESS;
+}
+
 VkResult draw_frame(
     RenderContext* context,
-    UIContext* ui,
     double time) {
+  (void)time;
   VkResult result;
 
   result = vkWaitForFences(context->device, 1, &context->in_flight_fences[context->current_frame], VK_TRUE, UINT64_MAX);
@@ -115,50 +162,6 @@ VkResult draw_frame(
     return result;
   }
 
-  VkCommandBuffer command_buffer = context->swapchain_command_buffers[image_index];
-  VK_RESULT(vkResetCommandBuffer(command_buffer, 0));
-
-  VkCommandBufferBeginInfo begin_info = {
-    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-  }; 
-  VK_RESULT(vkBeginCommandBuffer(command_buffer, &begin_info));
-
-  VkViewport viewport = {
-    .width = context->swapchain_extent.width,
-    .height = context->swapchain_extent.height,
-    .maxDepth = 1.0f,
-    .minDepth = 0.0f,
-  };
-  vkCmdSetViewport(command_buffer, 0, 1, &viewport);
-
-  VkRect2D scissor = {
-    .extent = context->swapchain_extent,
-  };
-  vkCmdSetScissor(command_buffer, 0, 1, &scissor);
-
-  VkClearValue clear_values[2] = {{.color={{0.0f, 0.0f, 0.0f, 0.0f}}}, {.depthStencil={1.0f, 0.0f}}};
-
-  VkRenderPassBeginInfo render_pass_begin = {
-    .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-    .renderPass = context->render_pass,
-    .framebuffer = context->swapchain_framebuffers[image_index],
-    .renderArea.offset = {0, 0},
-    .renderArea.extent = context->swapchain_extent,
-    .clearValueCount = 2,
-    .pClearValues = clear_values,
-  }; 
-
-  record_ui_compute(command_buffer, ui, time);
-
-  vkCmdBeginRenderPass(command_buffer, &render_pass_begin, VK_SUBPASS_CONTENTS_INLINE);
-  // Render World
-  vkCmdNextSubpass(command_buffer, VK_SUBPASS_CONTENTS_INLINE);
-  // Render UI
-  record_ui_draw(command_buffer, ui, time);
-  vkCmdEndRenderPass(command_buffer);
-
-  VK_RESULT(vkEndCommandBuffer(command_buffer));
-
   VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
   VkSubmitInfo submit_info = {
     .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,

client/src/gpu.c

@@ -58,7 +58,7 @@ GLFWwindow* init_window() {
   glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
 
   // TODO: recreate the framebuffer on resize
-  glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+  glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
 
   GLFWwindow* window = glfwCreateWindow(WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT, "roleplay", 0, 0);
   glfwSetWindowSizeLimits(window, WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT, GLFW_DONT_CARE, GLFW_DONT_CARE);
@@ -232,7 +232,7 @@ VkResult get_best_physical_device(VkInstance instance, VkPhysicalDevice* device)
   return VK_SUCCESS;
 }
 
-VkResult create_logical_device(VkPhysicalDevice physical_device, VkSurfaceKHR surface, GPUQueue* graphics_queue, GPUQueue* present_queue, GPUQueue* transfer_queue, VkDevice* device) {
+VkResult create_logical_device(VkPhysicalDevice physical_device, VkSurfaceKHR surface, Queue* graphics_queue, Queue* present_queue, Queue* transfer_queue, VkDevice* device) {
   if(graphics_queue == NULL || present_queue == NULL || transfer_queue == NULL || device == NULL) {
     return VK_ERROR_VALIDATION_FAILED_EXT;
   }
@@ -778,7 +778,7 @@ VkCommandBuffer* create_command_buffers(VkDevice device, VkCommandPool command_p
   return command_buffers;
 }
 
-VkResult create_depth_image(VkDevice device, VkFormat depth_format, VkExtent2D swapchain_extent, VmaAllocator allocator, VkCommandPool extra_graphics_pool, GPUQueue graphics_queue, VkImage* depth_image, VmaAllocation* depth_image_memory, VkImageView* depth_image_view) {
+VkResult create_depth_image(VkDevice device, VkFormat depth_format, VkExtent2D swapchain_extent, VmaAllocator allocator, VkCommandPool extra_graphics_pool, Queue graphics_queue, VkImage* depth_image, VmaAllocation* depth_image_memory, VkImageView* depth_image_view) {
   
     VkExtent3D depth_extent = {
     .width = swapchain_extent.width,
@@ -1077,7 +1077,7 @@ VkCommandBuffer command_begin_single(VkDevice device, VkCommandPool transfer_poo
   return command_buffer;
 }
 
-VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkCommandPool transfer_pool, GPUQueue transfer_queue) {
+VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkCommandPool transfer_pool, Queue transfer_queue) {
   VkResult result = vkEndCommandBuffer(command_buffer);
   if(result != VK_SUCCESS) {
     vkFreeCommandBuffers(device, transfer_pool, 1, &command_buffer);
@@ -1110,7 +1110,7 @@ void command_copy_buffer(VkCommandBuffer command_buffer, VkBuffer src, VkBuffer
   vkCmdCopyBuffer(command_buffer, src, dst, 1, &copy);
 }
 
-VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer_pool, GPUQueue transfer_queue, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, VkAccessFlags src_mask, VkAccessFlags dst_mask, VkPipelineStageFlags source, VkPipelineStageFlags dest, uint32_t source_family, uint32_t dest_family, VkImageAspectFlags aspect_flags) {
+VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer_pool, Queue transfer_queue, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, VkAccessFlags src_mask, VkAccessFlags dst_mask, VkPipelineStageFlags source, VkPipelineStageFlags dest, uint32_t source_family, uint32_t dest_family, VkImageAspectFlags aspect_flags) {
   VkCommandBuffer command_buffer = command_begin_single(device, transfer_pool);
 
   VkImageMemoryBarrier barrier = {

client/src/main.c

@@ -1,4 +1,3 @@
-#include "GLFW/glfw3.h"
 #include "ui.h"
 #include "gpu.h"
 #include "draw.h"
@@ -7,14 +6,6 @@
 #include "vk_mem_alloc.h"
 #include "vulkan/vk_enum_string_helper.h"
 #include "vulkan/vulkan_core.h"
-#include "pthread.h"
-#include "stdatomic.h"
-
-typedef struct ClientContextStruct {
-  GLFWwindow* window;
-  RenderContext render;
-  UIContext ui;
-} ClientContext;
 
 VkResult test_ui(RenderContext* render, UIContext* ui) {
   VkResult result;
@@ -44,12 +35,21 @@ VkResult test_ui(RenderContext* render, UIContext* ui) {
       .length = strlen("Example Text"),
       .font = 2,
     },
+    {
+      .pos = {0, 128},
+      .size = 32,
+      .color = {1.0, 1.0, 1.0, 1.0},
+      .offset = 3*strlen("Example Text"),
+      .length = strlen("Example Text"),
+      .font = 3,
+    },
   };
 
   uint32_t context_codes[256];
   map_string("Example Text", context_codes, 0, 0, ui);
   map_string("Example Text", context_codes, strlen("Example Text"), 1, ui);
   map_string("Example Text", context_codes, 2*strlen("Example Text"), 2, ui);
+  map_string("Example Text", context_codes, 3*strlen("Example Text"), 3, ui);
 
   LayerInput context_layers[] = {
     {
@@ -151,56 +151,49 @@ VkResult test_ui(RenderContext* render, UIContext* 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;
 }
 
-// Threads:
-// 1. render
-//  - Submits the draw buffer to the GPU as soon as it can
-// 2. network
-//  - Handles packets to/from the network to/from the main thread
-// 3. main
-//  - updates the data in the GPU that's being drawn from
-//  - updates the data in the GPU from network requests
-//
-//  Data:
-//  Render thread reads Render and UI context 
-//  Main thread reads and writes UI context
-
-void* render_thread(void* data) {
-  ClientContext* context = (ClientContext*)data;
+VkResult render_thread(GLFWwindow* window, RenderContext* render) {
+
+  VkResult result;
 
   double last_frame_time = glfwGetTime();
-  while(glfwWindowShouldClose(context->window) == 0) {
+  while(glfwWindowShouldClose(window) == 0) {
+    glfwPollEvents();
+
     double frame_time = glfwGetTime();
     double delta_time = frame_time - last_frame_time;
     (void)delta_time;
-
-    VkResult result = draw_frame(&context->render, &context->ui, frame_time);
+    result = draw_frame(render, frame_time);
     if(result != VK_SUCCESS) {
       fprintf(stderr, "draw_frame error: %s\n", string_VkResult(result));
-      glfwDestroyWindow(context->window);
+      return result;
     }
     last_frame_time = frame_time;
   }
-
-  return NULL;
+  return 0;
 }
 
-void* network_thread(void* data) {
-  ClientContext* context = (ClientContext*)data;
-  (void)context;
+typedef enum ClientAuthStateEnum {
+  AUTH_SAVED,
+  AUTH_CREDENTIALS,
+  AUTH_ATTEMPT,
+  AUTH_ERROR,
+  AUTH_SUCCESS,
+} ClientAuthState;
 
-  return NULL;
-}
+typedef struct ClientStateStruct {
   
-int main_thread(void* data) {
-  ClientContext* context = (ClientContext*)data;
+} ClientState;
 
-  while(glfwWindowShouldClose(context->window) == 0) {
-    glfwPollEvents();
-  }
+int logic_thread() {
+  return 0;
+}
 
+int network_thread() {
   return 0;
 }
 
@@ -213,10 +206,7 @@ void key_callback(GLFWwindow* window, int key, int scancode, int action, int mod
 }
 
 void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
-  ClientContext* context = (ClientContext*)glfwGetWindowUserPointer(window);
-
   (void)mods;
-  (void)context;
   switch(button) {
   // Handle camera hover
   case GLFW_MOUSE_BUTTON_MIDDLE:
@@ -228,10 +218,6 @@ void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
     break;
   case GLFW_MOUSE_BUTTON_LEFT:
     if(action == GLFW_PRESS) {
-      // NOTE: this logic is the same as it would be for right-click(just with different outcomes), so dont repeat yourself
-      // 1. Search through the UI context for the first element that the contains the mouse point
-      // 2. If no UI element intersection, cast a ray through the world scene to find the "clicked entity" 
-      // 3. Based on what was clicked, start the mouse click animation at the target area
     }
     break;
   case GLFW_MOUSE_BUTTON_RIGHT:
@@ -254,61 +240,35 @@ void cursor_pos_callback(GLFWwindow* window, double xpos, double ypos) {
 }
 
 int main() {
-  ClientContext context = {};
-  context.window = init_window();
-  if(context.window == NULL) {
+  GLFWwindow* window = init_window();
+  if(window == NULL) {
     return 1;
   }
 
-  glfwSetWindowUserPointer(context.window, &context);
-  glfwSetKeyCallback(context.window, key_callback);
-  glfwSetMouseButtonCallback(context.window, mouse_button_callback);
-  glfwSetScrollCallback(context.window, scroll_callback);
-  glfwSetCursorPosCallback(context.window, cursor_pos_callback);
+  glfwSetKeyCallback(window, key_callback);
+  glfwSetMouseButtonCallback(window, mouse_button_callback);
+  glfwSetScrollCallback(window, scroll_callback);
+  glfwSetCursorPosCallback(window, cursor_pos_callback);
 
+  RenderContext render = {};
+  UIContext ui = {};
 
-  int error;
   VkResult result;
-  VK_RESULT(init_vulkan(context.window, &context.render));
+  VK_RESULT(init_vulkan(window, &render));
   
   // TODO: make # of fonts/textures/containers scaling, recreate GPU buffers as necessary
-  VK_RESULT(create_ui_context(10, 10, 10, &context.render, &context.ui));
+  VK_RESULT(create_ui_context(10, 10, 10, &render, &ui));
 
   //////////////////////////////////
-  /// Test UI Code
+  /// Test Code
   //////////////////////////////////
 
-  VK_RESULT(test_ui(&context.render, &context.ui));
+  VK_RESULT(test_ui(&render, &ui));
 
   //////////////////////////////////
 
-  // Start threads
-  pthread_t render_thread_handle;
-  pthread_t network_thread_handle;
-
-  error = pthread_create(&render_thread_handle, NULL, &render_thread, &context);
-  if(error != 0) {
-    return error;
-  }
-
-  error = pthread_create(&network_thread_handle, NULL, &network_thread, &context);
-  if(error != 0) {
-    return error;
-  }
-
-  error = main_thread(&context);
-  if(error != 0) {
-    return error;
-  }
-
-  error = pthread_join(render_thread_handle, NULL);
-  if(error != 0) {
-    return error;
-  }
-
-  error = pthread_join(network_thread_handle, NULL);
-  if(error != 0) {
-    return error;
+  if(render_thread(window, &render) != VK_SUCCESS) {
+    return 3;
   }
 
   return 0;

client/src/ui.c

@@ -304,7 +304,6 @@ VkResult create_container(
   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;
-  context->containers[index].data.context = context->address;
   memcpy(mapped, &context->containers[index].data, sizeof(GPUContainer));
   
   VkCommandBuffer command_buffer = command_begin_single(gpu->device, gpu->transfer_pool);
@@ -1112,6 +1111,7 @@ VkResult create_ui_context(
   VK_RESULT(load_font(0, "fonts/eracake.ttf", 256, VK_TRUE, gpu, context));
   VK_RESULT(load_font(1, "fonts/yumoda.ttf", 256, VK_TRUE, gpu, context));
   VK_RESULT(load_font(2, "fonts/runescape.ttf", 16, VK_FALSE, gpu, context));
+  VK_RESULT(load_font(3, "fonts/apple_2.ttf", 256, VK_FALSE, gpu, context));
 
   return VK_SUCCESS;
 }