poc.c

 
#include <kiba/renderer/poc.h>
 
#include <kiba/core/log.h>
#include <kiba/renderer/vulkan/command_buffer.h>
#include <kiba/renderer/vulkan/context.h>
#include <kiba/renderer/vulkan/depth.h>
#include <kiba/renderer/vulkan/device.h>
#include <kiba/renderer/vulkan/framebuffers.h>
#include <kiba/renderer/vulkan/image.h>
#include <kiba/renderer/vulkan/index_buffer.h>
#include <kiba/renderer/vulkan/instance.h>
#include <kiba/renderer/vulkan/logging.h>
#include <kiba/renderer/vulkan/pipeline.h>
#include <kiba/renderer/vulkan/renderpass.h>
#include <kiba/renderer/vulkan/surface.h>
#include <kiba/renderer/vulkan/swap_chain.h>
#include <kiba/renderer/vulkan/sync.h>
#include <kiba/renderer/vulkan/texture.h>
#include <kiba/renderer/vulkan/uniform.h>
#include <kiba/renderer/vulkan/vertex_buffer.h>
 
vulkan_context context;
 
b8 vulkan_init(platform_window *window) {
    if (!vulkan_default_context_create(&context, window)) {
        return false;
    }
 
    if (!vulkan_instance_create(&context)) {
        return false;
    }
 
#ifdef KB_DEBUG_BUILD
    if (!vulkan_debug_messenger_create(&context)) {
        return false;
    }
#endif
 
    if (!vulkan_surface_create(&context)) {
        return false;
    }
 
    if (!vulkan_device_create(&context)) {
        return false;
    }
 
    if (!vulkan_renderpass_create(&context)) {
        return false;
    }
 
    if (!vulkan_swap_chain_create(&context)) {
        return false;
    }
 
    if (!vulkan_descriptor_set_layout_create(&context)) {
        return false;
    }
 
    if (!vulkan_pipeline_create(&context)) {
        return false;
    }
 
    if (!vulkan_depth_create(&context)) {
        return false;
    }
 
    if (!vulkan_framebuffers_create(&context)) {
        return false;
    }
 
    if (!vulkan_texture_create(&context)) {
        return false;
    }
 
    if (!vulkan_vertex_buffer_create(&context)) {
        return false;
    }
 
    if (!vulkan_index_buffer_create(&context)) {
        return false;
    }
 
    if (!vulkan_uniform_buffers_create(&context)) {
        return false;
    }
 
    if (!vulkan_descriptor_pool_create(&context)) {
        return false;
    }
 
    if (!vulkan_descriptor_sets_create(&context)) {
        return false;
    }
 
    if (!vulkan_sync_create(&context)) {
        return false;
    }
 
    return true;
}
 
void vulkan_shutdown(void) {
    // wait until async stuff done
    vkDeviceWaitIdle(context.device.logical);
 
    vulkan_framebuffers_destroy(&context);
 
    vulkan_depth_destroy(&context);
 
    vulkan_swap_chain_destroy(&context);
 
    vulkan_texture_destroy(&context);
 
    vulkan_pipeline_destroy(&context);
 
    vulkan_renderpass_destroy(&context);
 
    vulkan_uniform_buffers_destroy(&context);
 
    vulkan_descriptor_pool_destroy(&context);
 
    vulkan_descriptor_set_layout_destroy(&context);
 
    vulkan_index_buffer_destroy(&context);
 
    vulkan_vertex_buffer_destroy(&context);
 
    vulkan_sync_destroy(&context);
 
    vulkan_device_destroy(&context);
 
    vulkan_surface_destroy(&context);
 
#ifdef KB_DEBUG_BUILD
    vulkan_debug_messenger_destroy(&context);
#endif
 
    vulkan_instance_destroy(&context);
 
    vulkan_context_destroy(&context);
}
 
void vulkan_draw_frame(void) {
    VK_CALL_ASSERT(vkWaitForFences(context.device.logical, 1, &context.sync.fc_in_flight, VK_TRUE, UINT64_MAX));
    u32 image_index = 0;
 
    VkResult res = vkAcquireNextImageKHR(context.device.logical,
                                         context.swap_chain.swap_chain,
                                         UINT64_MAX,
                                         context.sync.sp_image_available,
                                         VK_NULL_HANDLE,
                                         &image_index);
    if (res == VK_ERROR_OUT_OF_DATE_KHR) {
        vulkan_swap_chain_recreate(&context);
        return;
    }  // TODO handle not VK_SUCCESS or VK_SUBOPTIMAL_KHR
 
    // only reset fence when not returning early -> avoids deadlock
    VK_CALL_ASSERT(vkResetFences(context.device.logical, 1, &context.sync.fc_in_flight));
 
    static u32 init_counter = 0;
    if (init_counter < 3) {
        if (!vulkan_image_transition_layout_tmp(&context,
                                                context.swap_chain.images[image_index],
                                                VK_FORMAT_R8G8B8A8_SRGB,
                                                VK_IMAGE_LAYOUT_UNDEFINED,
                                                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)) {
            KB_ERROR("failed to transition vulkan_image layout before rendering");
        }
        init_counter += (init_counter == image_index);
    } else {
        if (!vulkan_image_transition_layout_tmp(&context,
                                                context.swap_chain.images[image_index],
                                                VK_FORMAT_R8G8B8A8_SRGB,
                                                VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
                                                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)) {
            KB_ERROR("failed to transition vulkan_image layout before rendering");
        }
    }
 
    VK_CALL_ASSERT(vkResetCommandBuffer(context.device.graphics_queue.command_buffer, 0));
    vulkan_command_buffer_record(&context, context.device.graphics_queue.command_buffer, image_index);
 
    VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
 
    // handle uniforms
    vulkan_uniform_buffers_update(&context, image_index);
 
    VkSubmitInfo submit_info = {
        .sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .waitSemaphoreCount   = 1,
        .pWaitSemaphores      = &context.sync.sp_image_available,
        .pWaitDstStageMask    = wait_stages,
        .commandBufferCount   = 1,
        .pCommandBuffers      = &context.device.graphics_queue.command_buffer,
        .signalSemaphoreCount = 1,
        .pSignalSemaphores    = &context.sync.sp_render_finished,
    };
    VK_CALL_ASSERT(vkQueueSubmit(context.device.graphics_queue.queue, 1, &submit_info, context.sync.fc_in_flight));
 
    if (!vulkan_image_transition_layout_tmp(&context,
                                            context.swap_chain.images[image_index],
                                            VK_FORMAT_R8G8B8A8_SRGB,
                                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                                            VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
        KB_ERROR("failed to transition vulkan_image layout after rendering");
    }
 
    VkPresentInfoKHR present_info = {
        .sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
        .waitSemaphoreCount = 1,
        .pWaitSemaphores    = &context.sync.sp_render_finished,
        .swapchainCount     = 1,
        .pSwapchains        = &context.swap_chain.swap_chain,
        .pImageIndices      = &image_index,
        .pResults           = NULL,
    };
    res = vkQueuePresentKHR(context.device.present_queue.queue, &present_info);
    if (res == VK_ERROR_OUT_OF_DATE_KHR || res == VK_SUBOPTIMAL_KHR || context.swap_chain.recreate) {
        context.swap_chain.recreate = false;
        vulkan_swap_chain_recreate(&context);
    }  // TODO handle not VK_SUCCESS
}