shader.c

#include <kiba/renderer/vulkan/shader.h>
 
#include <kiba/platform/filesystem.h>
 
static array_of(u32) vulkan_shader_load_code(vulkan_context *context, const char *path, usize *read_bytes) {
    KB_ASSERT(context, "context must not be null");
    KB_ASSERT(path, "file path must not be null");
    file_handle file;
    usize       size = 0;
    array_of(u32) code = KB_NULL;
    if (filesystem_open(&file, path, false, FILE_MODE_READ)) {
        if (filesystem_size(&file, &size)
            && (code = array_create(u32, size / sizeof(code[0]) + 1, &context->alloc.kiba_alloc)) != KB_NULL) {
            array_resize(&code, array_capacity(code));
            if (filesystem_read_all_text(&file, array_capacity(code) * sizeof(code[0]), (char *) code, read_bytes)) {
                if (size != *read_bytes) {
                    KB_WARN("determined size of shader code ({usize}) and actually read data ({usize}) differs",
                            size,
                            read_bytes);
                }
            } else {
                array_destroy(&code);
            }
        }
        filesystem_close(&file);
    }
    return code;
}
 
b8 vulkan_shader_create(vulkan_context *context, const char *path, shader_type type) {
    usize size_in_bytes = 0;
    array_of(u32) code  = vulkan_shader_load_code(context, path, &size_in_bytes);
    if (code == KB_NULL) {
        return false;
    }
 
    VkShaderModuleCreateInfo shader_info = {
        .sType    = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
        .codeSize = size_in_bytes,
        .pCode    = (u32 *) code,
    };
 
    VkShaderModule shader_module;
    // TODO: this will leak in case its not successfull, could add cleanup option to macro
    VK_CALL_B8(
        vkCreateShaderModule(context->device.logical, &shader_info, &context->alloc.vulkan_callbacks, &shader_module));
 
    VkPipelineShaderStageCreateInfo shader_stage_info = {
        .sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
        .module = shader_module,
        .pName  = "main",
    };
    switch (type) {
        case SHADER_TYPE_VERTEX:
            shader_stage_info.stage = VK_SHADER_STAGE_VERTEX_BIT;
            break;
        case SHADER_TYPE_FRAGMENT:
            shader_stage_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
            break;
        default:
            KB_FATAL("unhandled shader type {i32}", type);
            break;
    }
    array_push(context->pipeline.shaders, shader_stage_info);
    array_destroy(&code);
    return true;
}
 
void vulkan_shader_destroy(vulkan_context *context) { UNUSED(context); }