MetzNet
/
roleplay
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added FrameContext struct and used VK_RESULT more

main
noah metz 2024-10-26 12:43:07 -06:00
parent d1cfff1ff7
commit 174a8808d7
4 changed files with 96 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
client/include/gpu.h
Unescape Escape View File

@ -24,6 +24,16 @@
#include <cglm/quat.h>
#include <cglm/cam.h>
#define MAX_FRAMES_IN_FLIGHT 2
#define WINDOW_MIN_WIDTH 800
#define WINDOW_MIN_HEIGHT 600
typedef struct GPUBufferStruct {
VkBuffer buffers[MAX_FRAMES_IN_FLIGHT];
VmaAllocation memory[MAX_FRAMES_IN_FLIGHT];
VkDeviceSize size;
} GPUBuffer;
typedef struct GPUQueueStruct {
VkQueue handle;
uint32_t family;
@ -46,10 +56,6 @@ VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer
}\
}
extern const uint32_t MAX_FRAMES_IN_FLIGHT;
extern const uint32_t WINDOW_MIN_WIDTH;
extern const uint32_t WINDOW_MIN_HEIGHT;
typedef struct SwapchainDetailsStruct {
VkSurfaceCapabilitiesKHR capabilities;
@ -60,11 +66,18 @@ typedef struct SwapchainDetailsStruct {
uint32_t present_modes_count;
} SwapchainDetails;
typedef struct FrameContextStruct {
VkFence ready;
VkSemaphore image;
VkSemaphore render;
VkSemaphore transfer;
VkSemaphore compute;
} FrameContext;
typedef struct RenderContextStruct {
VkInstance instance;
VkDebugUtilsMessengerEXT debug_messenger;
VkPhysicalDevice physical_device;
VkPhysicalDeviceMemoryProperties memories;
VkSurfaceKHR surface;
GPUQueue graphics_queue;
GPUQueue present_queue;
@ -96,10 +109,7 @@ typedef struct RenderContextStruct {
VkCommandBuffer* swapchain_command_buffers;
VkSemaphore* image_available_semaphores;
VkSemaphore* render_finished_semaphores;
VkFence* in_flight_fences;
FrameContext frame[MAX_FRAMES_IN_FLIGHT];
uint32_t current_frame;
vec2 window_scale;

18
client/src/draw.c
Unescape Escape View File

@ -1,7 +1,7 @@
#include "draw.h"
#include "gpu.h"
void record_ui_compute(VkCommandBuffer command_buffer, RenderContext* gpu, UIContext* ui_context, double time) {
void record_ui_compute(VkCommandBuffer command_buffer, UIContext* ui_context, double time) {
UIPushConstant push = {
.time = (float)time,
.layer = 0,
@ -85,18 +85,18 @@ VkResult draw_frame(
double time) {
VkResult result;
result = vkWaitForFences(context->device, 1, &context->in_flight_fences[context->current_frame], VK_TRUE, UINT64_MAX);
result = vkWaitForFences(context->device, 1, &context->frame[context->current_frame].ready, VK_TRUE, UINT64_MAX);
if(result != VK_SUCCESS) {
return result;
}
result = vkResetFences(context->device, 1, &context->in_flight_fences[context->current_frame]);
result = vkResetFences(context->device, 1, &context->frame[context->current_frame].ready);
if(result != VK_SUCCESS) {
return result;
}
uint32_t image_index;
result = vkAcquireNextImageKHR(context->device, context->swapchain, UINT64_MAX, context->image_available_semaphores[context->current_frame], VK_NULL_HANDLE, &image_index);
result = vkAcquireNextImageKHR(context->device, context->swapchain, UINT64_MAX, context->frame[context->current_frame].image, VK_NULL_HANDLE, &image_index);
if(result != VK_SUCCESS) {
return result;
}
@ -134,7 +134,7 @@ VkResult draw_frame(
.pClearValues = clear_values,
};
record_ui_compute(command_buffer, context, ui, time);
record_ui_compute(command_buffer, ui, time);
vkCmdBeginRenderPass(command_buffer, &render_pass_begin, VK_SUBPASS_CONTENTS_INLINE);
// Render World
@ -149,15 +149,15 @@ VkResult draw_frame(
VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &context->image_available_semaphores[context->current_frame],
.pWaitSemaphores = &context->frame[context->current_frame].image,
.pWaitDstStageMask = wait_stages,
.commandBufferCount = 1,
.pCommandBuffers = &context->swapchain_command_buffers[image_index],
.signalSemaphoreCount = 1,
.pSignalSemaphores = &context->render_finished_semaphores[context->current_frame],
.pSignalSemaphores = &context->frame[context->current_frame].render,
};
result = vkQueueSubmit(context->graphics_queue.handle, 1, &submit_info, context->in_flight_fences[context->current_frame]);
result = vkQueueSubmit(context->graphics_queue.handle, 1, &submit_info, context->frame[context->current_frame].ready);
if(result != VK_SUCCESS) {
return result;
}
@ -165,7 +165,7 @@ VkResult draw_frame(
VkPresentInfoKHR present_info = {
.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &context->render_finished_semaphores[context->current_frame],
.pWaitSemaphores = &context->frame[context->current_frame].render,
.swapchainCount = 1,
.pSwapchains = &context->swapchain,
.pImageIndices = &image_index,

230
client/src/gpu.c
Unescape Escape View File

@ -5,10 +5,6 @@
#include "vk_mem_alloc.h"
#include "vulkan/vulkan_core.h"
const uint32_t MAX_FRAMES_IN_FLIGHT = 2;
const uint32_t WINDOW_MIN_WIDTH = 800;
const uint32_t WINDOW_MIN_HEIGHT = 600;
const char * validation_layers[] = {
"VK_LAYER_KHRONOS_validation",
//"VK_LAYER_LUNARG_api_dump",
@ -135,10 +131,8 @@ VkResult create_instance(VkInstance* instance) {
.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR,
};
VkResult result = vkCreateInstance(&instance_info, 0, instance);
if(result != VK_SUCCESS) {
return result;
}
VkResult result;
VK_RESULT(vkCreateInstance(&instance_info, 0, instance));
free(requested_extensions);
return VK_SUCCESS;
@ -171,10 +165,7 @@ VkResult create_debug_messenger(VkInstance instance, VkDebugUtilsMessengerEXT* d
PFN_vkCreateDebugUtilsMessengerEXT func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
VkResult result;
result = func(instance, &messenger_info, 0, debug_messenger);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(func(instance, &messenger_info, 0, debug_messenger));
return VK_SUCCESS;
}
@ -182,10 +173,7 @@ VkResult create_debug_messenger(VkInstance instance, VkDebugUtilsMessengerEXT* d
VkResult get_best_physical_device(VkInstance instance, VkPhysicalDevice* device) {
uint32_t device_count = 0;
VkResult result;
result = vkEnumeratePhysicalDevices(instance, &device_count, 0);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkEnumeratePhysicalDevices(instance, &device_count, 0));
VkPhysicalDevice* devices = malloc(sizeof(VkPhysicalDevice)*device_count);
result = vkEnumeratePhysicalDevices(instance, &device_count, devices);
@ -375,10 +363,8 @@ VkResult create_logical_device(VkPhysicalDevice physical_device, VkSurfaceKHR su
.pNext = &features_12,
};
VkResult result = vkCreateDevice(physical_device, &device_create_info, 0, device);
if(result != VK_SUCCESS) {
return result;
}
VkResult result;
VK_RESULT(vkCreateDevice(physical_device, &device_create_info, 0, device));
vkGetDeviceQueue(*device, graphics_queue->family, graphics_queue->index, &graphics_queue->handle);
vkGetDeviceQueue(*device, present_queue->family, present_queue->index, &present_queue->handle);
@ -396,10 +382,8 @@ VkResult create_memory_allocator(VkInstance instance, VkPhysicalDevice physical_
.flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
};
VkResult result = vmaCreateAllocator(&allocator_create_info, allocator);
if(result != VK_SUCCESS) {
return result;
}
VkResult result;
VK_RESULT(vmaCreateAllocator(&allocator_create_info, allocator));
return VK_SUCCESS;
}
@ -410,16 +394,12 @@ VkResult get_swapchain_details(VkPhysicalDevice physical_device, VkSurfaceKHR su
VkResult result;
result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &details->capabilities);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &details->capabilities));
VK_RESULT(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &details->formats_count, 0));
result = vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &details->formats_count, 0);
if(result != VK_SUCCESS) {
return result;
}
details->formats = malloc(sizeof(VkSurfaceFormatKHR)*details->formats_count);
result = vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &details->formats_count, details->formats);
if(result != VK_SUCCESS) {
free(details->formats);
@ -502,20 +482,14 @@ VkResult create_swapchain(VkDevice device, VkSurfaceFormatKHR format, VkPresentM
VkResult result;
result = vkCreateSwapchainKHR(device, &swapchain_info, 0, swapchain);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkCreateSwapchainKHR(device, &swapchain_info, 0, swapchain));
return VK_SUCCESS;
}
VkResult get_swapchain_images(VkDevice device, VkSwapchainKHR swapchain, VkImage** images, uint32_t* image_count) {
VkResult result;
result = vkGetSwapchainImagesKHR(device, swapchain, image_count, 0);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkGetSwapchainImagesKHR(device, swapchain, image_count, 0));
*images = malloc(sizeof(VkImage)*(*image_count));
if(*images == 0) {
@ -581,7 +555,7 @@ VkResult find_depth_format(VkPhysicalDevice physical_device, VkImageTiling tilin
return VK_SUCCESS;
}
}
return VK_ERROR_UNKNOWN;
return VK_ERROR_VALIDATION_FAILED_EXT;
}
VkResult create_render_pass(VkDevice device, VkSurfaceFormatKHR format, VkFormat depth_format, VkRenderPass* render_pass) {
@ -673,10 +647,8 @@ VkResult create_render_pass(VkDevice device, VkSurfaceFormatKHR format, VkFormat
.pDependencies = dependencies,
};
VkResult result = vkCreateRenderPass(device, &render_info, 0, render_pass);
if(result != VK_SUCCESS) {
return result;
}
VkResult result;
VK_RESULT(vkCreateRenderPass(device, &render_info, 0, render_pass));
return VK_SUCCESS;
}
@ -715,46 +687,44 @@ VkResult create_swapchain_framebuffers(VkDevice device, uint32_t image_count, Vk
return VK_SUCCESS;
}
VkSemaphore* create_semaphores(VkDevice device, VkSemaphoreCreateFlags flags, uint32_t count) {
VkSemaphore* semaphores = malloc(sizeof(VkSemaphore)*count);
if(semaphores == 0) {
return 0;
}
VkSemaphore create_semaphore(VkDevice device, VkSemaphoreCreateFlags flags) {
VkSemaphoreCreateInfo semaphore_info = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
.flags = flags,
};
for(uint32_t i = 0; i < count; i++) {
VkResult result = vkCreateSemaphore(device, &semaphore_info, 0, &semaphores[i]);
VkSemaphore semaphore;
VkResult result = vkCreateSemaphore(device, &semaphore_info, 0, &semaphore);
if(result != VK_SUCCESS) {
free(semaphores);
return 0;
}
}
return semaphores;
}
VkFence* create_fences(VkDevice device, VkFenceCreateFlags flags, uint32_t count) {
VkFence* fences = malloc(sizeof(VkFence)*count);
if(fences == 0) {
return 0;
}
return semaphore;
}
VkFence create_fence(VkDevice device, VkFenceCreateFlags flags) {
VkFenceCreateInfo fence_info = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.flags = flags,
};
for(uint32_t i = 0; i < count; i++) {
VkResult result = vkCreateFence(device, &fence_info, 0, &fences[i]);
VkFence fence;
VkResult result = vkCreateFence(device, &fence_info, 0, &fence);
if(result != VK_SUCCESS) {
free(fences);
return 0;
}
return VK_NULL_HANDLE;
}
return fences;
return fence;
}
VkResult create_frame_context(VkDevice device, FrameContext* frame) {
frame->ready = create_fence(device, VK_FENCE_CREATE_SIGNALED_BIT);
frame->image = create_semaphore(device, 0);
frame->render = create_semaphore(device, 0);
frame->transfer = create_semaphore(device, 0);
frame->compute = create_semaphore(device, 0);
return VK_SUCCESS;
}
VkCommandBuffer* create_command_buffers(VkDevice device, VkCommandPool command_pool, uint32_t image_count) {
@ -805,10 +775,8 @@ VkResult create_depth_image(VkDevice device, VkFormat depth_format, VkExtent2D s
.usage = VMA_MEMORY_USAGE_AUTO,
};
VkResult result = vmaCreateImage(allocator, &depth_image_info, &allocation_info, depth_image, depth_image_memory, NULL);
if(result != VK_SUCCESS) {
return result;
}
VkResult result;
VK_RESULT(vmaCreateImage(allocator, &depth_image_info, &allocation_info, depth_image, depth_image_memory, NULL));
VkImageViewCreateInfo depth_view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@ -830,15 +798,9 @@ VkResult create_depth_image(VkDevice device, VkFormat depth_format, VkExtent2D s
},
};
result = vkCreateImageView(device, &depth_view_info, 0, depth_image_view);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkCreateImageView(device, &depth_view_info, 0, depth_image_view));
result = command_transition_image_layout(device, extra_graphics_pool, graphics_queue, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, *depth_image, 0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, VK_IMAGE_ASPECT_DEPTH_BIT);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(command_transition_image_layout(device, extra_graphics_pool, graphics_queue, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, *depth_image, 0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, VK_IMAGE_ASPECT_DEPTH_BIT));
return VK_SUCCESS;
}
@ -853,131 +815,67 @@ VkResult init_vulkan(GLFWwindow* window, RenderContext* context) {
GLFWmonitor** monitors = glfwGetMonitors(&monitor_count);
glfwGetMonitorContentScale(monitors[0], &context->window_scale[0], &context->window_scale[1]);
result = create_instance(&context->instance);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_instance(&context->instance));
result = create_debug_messenger(context->instance, &context->debug_messenger);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_debug_messenger(context->instance, &context->debug_messenger));
result = get_best_physical_device(context->instance, &context->physical_device);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(get_best_physical_device(context->instance, &context->physical_device));
vkGetPhysicalDeviceMemoryProperties(context->physical_device, &context->memories);
VK_RESULT(glfwCreateWindowSurface(context->instance, window, 0, &context->surface));
result = glfwCreateWindowSurface(context->instance, window, 0, &context->surface);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_logical_device(context->physical_device, context->surface, &context->graphics_queue, &context->present_queue, &context->transfer_queue, &context->device));
result = create_logical_device(context->physical_device, context->surface, &context->graphics_queue, &context->present_queue, &context->transfer_queue, &context->device);
if(result != VK_SUCCESS) {
return result;
}
result = create_memory_allocator(context->instance, context->physical_device, context->device, &context->allocator);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_memory_allocator(context->instance, context->physical_device, context->device, &context->allocator));
VkCommandPoolCreateInfo extra_pool_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.queueFamilyIndex = context->graphics_queue.family,
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
};
result = vkCreateCommandPool(context->device, &extra_pool_info, 0, &context->extra_graphics_pool);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkCreateCommandPool(context->device, &extra_pool_info, 0, &context->extra_graphics_pool));
VkCommandPoolCreateInfo graphics_pool_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
.queueFamilyIndex = context->graphics_queue.family,
};
result = vkCreateCommandPool(context->device, &graphics_pool_info, 0, &context->graphics_pool);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkCreateCommandPool(context->device, &graphics_pool_info, 0, &context->graphics_pool));
VkCommandPoolCreateInfo transfer_pool_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
.queueFamilyIndex = context->transfer_queue.family,
};
result = vkCreateCommandPool(context->device, &transfer_pool_info, 0, &context->transfer_pool);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(vkCreateCommandPool(context->device, &transfer_pool_info, 0, &context->transfer_pool));
context->image_available_semaphores = create_semaphores(context->device, 0, MAX_FRAMES_IN_FLIGHT);
if(context->image_available_semaphores == NULL) {
return VK_ERROR_UNKNOWN;
for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
VK_RESULT(create_frame_context(context->device, &context->frame[i]));
}
context->render_finished_semaphores = create_semaphores(context->device, 0, MAX_FRAMES_IN_FLIGHT);
if(context->render_finished_semaphores == NULL) {
return VK_ERROR_UNKNOWN;
}
context->in_flight_fences = create_fences(context->device, VK_FENCE_CREATE_SIGNALED_BIT, MAX_FRAMES_IN_FLIGHT);
if(context->in_flight_fences == NULL) {
return VK_ERROR_UNKNOWN;
}
result = get_swapchain_details(context->physical_device, context->surface, &context->swapchain_details);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(get_swapchain_details(context->physical_device, context->surface, &context->swapchain_details));
context->swapchain_format = choose_swapchain_format(context->swapchain_details);
context->swapchain_present_mode = choose_present_mode(context->swapchain_details);
context->swapchain_extent = choose_swapchain_extent(context->swapchain_details);
context->swapchain = VK_NULL_HANDLE;
result = create_swapchain(context->device, context->swapchain_format, context->swapchain_present_mode, context->swapchain_extent, context->surface, context->swapchain_details.capabilities, context->graphics_queue.family, context->present_queue.family, &context->swapchain);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_swapchain(context->device, context->swapchain_format, context->swapchain_present_mode, context->swapchain_extent, context->surface, context->swapchain_details.capabilities, context->graphics_queue.family, context->present_queue.family, &context->swapchain));
result = get_swapchain_images(context->device, context->swapchain, &context->swapchain_images, &context->swapchain_image_count);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(get_swapchain_images(context->device, context->swapchain, &context->swapchain_images, &context->swapchain_image_count));
context->swapchain_command_buffers = create_command_buffers(context->device, context->graphics_pool, context->swapchain_image_count);
if(context->swapchain_command_buffers == NULL) {
return VK_ERROR_UNKNOWN;
return VK_ERROR_VALIDATION_FAILED_EXT;
}
result = create_image_views(context->device, context->swapchain_image_count, context->swapchain_images, context->swapchain_format, &context->swapchain_image_views);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_image_views(context->device, context->swapchain_image_count, context->swapchain_images, context->swapchain_format, &context->swapchain_image_views));
result = find_depth_format(context->physical_device, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, &context->depth_format);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(find_depth_format(context->physical_device, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, &context->depth_format));
result = create_render_pass(context->device, context->swapchain_format, context->depth_format, &context->render_pass);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_render_pass(context->device, context->swapchain_format, context->depth_format, &context->render_pass));
result = create_depth_image(context->device, context->depth_format, context->swapchain_extent, context->allocator, context->extra_graphics_pool, context->graphics_queue, &context->depth_image, &context->depth_image_memory, &context->depth_image_view);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_depth_image(context->device, context->depth_format, context->swapchain_extent, context->allocator, context->extra_graphics_pool, context->graphics_queue, &context->depth_image, &context->depth_image_memory, &context->depth_image_view));
result = create_swapchain_framebuffers(context->device, context->swapchain_image_count, context->swapchain_image_views, context->depth_image_view, context->render_pass, context->swapchain_extent, &context->swapchain_framebuffers);
if(result != VK_SUCCESS) {
return result;
}
VK_RESULT(create_swapchain_framebuffers(context->device, context->swapchain_image_count, context->swapchain_image_views, context->depth_image_view, context->render_pass, context->swapchain_extent, &context->swapchain_framebuffers));
context->current_frame = 0;
return VK_SUCCESS;
@ -999,10 +897,8 @@ VkResult create_transfer_buffer(
.usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
};
VkResult result = vmaCreateBuffer(allocator, &buffer_info, &memory_info, buffer, memory, NULL);
if(result != VK_SUCCESS) {
return result;
}
VkResult result;
VK_RESULT(vmaCreateBuffer(allocator, &buffer_info, &memory_info, buffer, memory, NULL));
result = vmaMapMemory(allocator, *memory, mapped);
if(result != VK_SUCCESS) {

5
client/src/main.c
Unescape Escape View File

@ -200,10 +200,9 @@ int main_thread(void* data) {
int x = 0;
while(glfwWindowShouldClose(context->window) == 0) {
glfwPollEvents();
if(x == 1000) {
if(x == 0 && glfwGetTime() > 2.0) {
x = 1;
test_ui(&context->render, &context->ui);
} else {
x += 1;
}
}