command.c

#include <kiba/gpu/command.h>
#include <kiba/gpu/vulkan/allocator.h>
#include <kiba/gpu/vulkan/conv.h>
#include <kiba/gpu/vulkan/device.h>
#include <kiba/gpu/vulkan/instance.h>
#include <kiba/gpu/vulkan/queue.h>
#include <kiba/gpu/vulkan/util.h>
#include "vulkan/vulkan_core.h"
 
b8 gpu_backend_command_encoder_create(struct gpu_backend_command_encoder   *encoder,
                                      struct gpu_backend_device            *device,
                                      struct gpu_command_encoder_descriptor desc) {
    if (!vk_queue_get_command_encoder(device, encoder)) {
        KB_ERROR("failed to create command buffer for command encoder");
        return false;
    }
    // TODO for some reason this does not appear properly in renderdoc, perhaps a bug there?
    // the validation layers pick this name up, so it seems to be a renderdoc issue
    vk_device_set_object_name(device->logical, VK_OBJECT_TYPE_COMMAND_BUFFER, encoder->buffer, desc.label);
    return true;
}
 
void gpu_backend_command_encoder_destroy(struct gpu_backend_command_encoder *encoder,
                                         struct gpu_backend_device          *device) {
    vk_queue_return_command_encoder(device, *encoder);
    encoder->buffer = VK_NULL_HANDLE;
}
 
b8 gpu_backend_command_encoder_submit(struct gpu_backend_command_encoder *encoder, struct gpu_backend_device *device) {
    return vk_queue_submit_encoder(encoder, device);
}
 
b8 gpu_backend_cmd_begin(struct gpu_backend_command_encoder *encoder) {
    VkCommandBufferBeginInfo begin_info = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
    };
    VK_CALL_B8(vkBeginCommandBuffer(encoder->buffer, &begin_info));
    return true;
}
 
void gpu_backend_cmd_copy_buffer_to_buffer(struct gpu_backend_command_encoder *encoder,
                                           struct gpu_backend_buffer          *src,
                                           struct gpu_backend_buffer          *dst,
                                           usize                               src_offset,
                                           usize                               dst_offset,
                                           usize                               size) {
    VkBufferCopy copy_info = {
        .srcOffset = (VkDeviceSize) src_offset,
        .dstOffset = (VkDeviceSize) dst_offset,
        .size      = (VkDeviceSize) size,
    };
    vkCmdCopyBuffer(encoder->buffer, src->raw, dst->raw, 1, &copy_info);
}
 
b8 gpu_backend_begin_render_pass(struct gpu_backend_command_encoder *encoder,
                                 struct gpu_backend_device          *device,
                                 struct gpu_render_pass_descriptor   desc) {
    u32                       clear_value_count                    = 0;
    VkClearValue              clear_values[KB_GPU_MAX_ATTACHMENTS] = {0};
    struct vk_renderpass_key  rp_key                               = {0};
    // TODO extent should maybe come from the render attachments
    struct vk_framebuffer_key fb_key = {
        .extent = {
            .width = (u32) desc.extent.width,
            .height = (u32) desc.extent.height,
            .depth = (u32) desc.extent.layers,
        },
    };
 
    for (usize i = 0; i < desc.color_attachment_count; ++i) {
        struct gpu_color_attachment col_at = desc.color_attachments[i];
        // TODO respect format of attachment
        // (https://github.com/gfx-rs/wgpu/blob/5b8be97a887eb198f1e58963b4c94d46cf4a84db/wgpu-hal/src/vulkan/conv.rs#L196)
        clear_values[clear_value_count++] = (VkClearValue){
            .color = {
                .float32 = {
                    (f32) col_at.ops.clear_color.r,
                    (f32) col_at.ops.clear_color.g,
                    (f32) col_at.ops.clear_color.b,
                    (f32) col_at.ops.clear_color.a,
                },
            },
        };
        rp_key.colors[rp_key.color_count++] = (struct vk_color_attachment_key){
            .base = {
                .format = vk_convert_texture_format(col_at.view->desc.format),
                .layout = vk_optimal_image_layout(GPU_TEXTURE_USE_COLOR_TARGET, col_at.view->desc.format),
                .ops    = gpu_operations_to_attachment_ops(col_at.ops),
            },
        };
        fb_key.attachments[fb_key.attachment_count++] = (struct vk_framebuffer_attachment){
            .view   = col_at.view->btv.raw,
            .usage  = GPU_TEXTURE_USE_COLOR_TARGET,  // TODO should use texture's usage I guess
            .format = col_at.view->desc.format,
        };
    }
    if (desc.depth_stencil_attachment.view) {
        // TODO
    }
 
    // TODO error handling
    VkRenderPass  renderpass;
    VkFramebuffer framebuffer;
    if (!vk_device_create_renderpass(device, rp_key, &renderpass)
        || !vk_device_create_framebuffer(device, fb_key, renderpass, &framebuffer)) {
        KB_ERROR("oof");
        return false;
    }
    vk_device_set_object_name(device->logical, VK_OBJECT_TYPE_RENDER_PASS, renderpass, desc.label);
 
    VkRect2D render_area = {
        .offset = { .x = 0, .y = 0 },
        .extent = {
            .width  = (u32) desc.extent.width,
            .height = (u32) desc.extent.height,
        },
    };
    VkViewport viewport = {
        .x        = 0.0f,
        .y        = 0.0f,
        .width    = (f32) desc.extent.width,
        .height   = (f32) desc.extent.height,
        .minDepth = 0.0f,
        .maxDepth = 1.0f,
    };
 
    VkRenderPassBeginInfo rp_begin_info = {
        .sType           = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
        .renderPass      = renderpass,
        .framebuffer     = framebuffer,
        .renderArea      = render_area,
        .clearValueCount = clear_value_count,
        .pClearValues    = clear_values,
    };
 
    vkCmdSetViewport(encoder->buffer, 0, 1, &viewport);
    vkCmdSetScissor(encoder->buffer, 0, 1, &render_area);
    vkCmdBeginRenderPass(encoder->buffer, &rp_begin_info, VK_SUBPASS_CONTENTS_INLINE);
    return true;
}
 
void gpu_cmd_bind_pipeline(gpu_command_encoder encoder, gpu_pipeline pipeline) {
    vkCmdBindPipeline(encoder->bce.buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->bp.raw);
}
 
VkDeviceSize offset = 0;
 
void gpu_cmd_bind_vertex_buffer(gpu_command_encoder encoder, usize slot, gpu_buffer buffer) {
    // TODO store offset for bindings
    offset = 0;
    vkCmdBindVertexBuffers(encoder->bce.buffer, (u32) slot, 1u, &buffer->bb.raw, &offset);
}
 
void gpu_cmd_bind_index_buffer(gpu_command_encoder encoder, gpu_buffer buffer, enum gpu_index_format format) {
    vkCmdBindIndexBuffer(encoder->bce.buffer, buffer->bb.raw, offset, vk_convert_index_format(format));
}
 
void gpu_cmd_draw(gpu_command_encoder encoder,
                  usize               vertex_count,
                  usize               instance_count,
                  usize               first_vertex,
                  usize               first_instance) {
    vkCmdDraw(encoder->bce.buffer, (u32) vertex_count, (u32) instance_count, (u32) first_vertex, (u32) first_instance);
}
 
void gpu_cmd_draw_indexed(gpu_command_encoder encoder,
                          usize               first_index,
                          usize               index_count,
                          usize               first_vertex,
                          usize               first_instance,
                          usize               instance_count) {
    vkCmdDrawIndexed(encoder->bce.buffer,
                     (u32) index_count,
                     (u32) instance_count,
                     (u32) first_index,
                     (i32) first_vertex,
                     (u32) first_instance);
}
 
b8 gpu_backend_end_render_pass(struct gpu_backend_command_encoder *encoder) {
    vkCmdEndRenderPass(encoder->buffer);
    return true;
}
 
void gpu_cmd_debug_marker_begin(gpu_command_encoder encoder, const char *label) {
#ifdef KB_DEBUG_BUILD
    VkDebugUtilsLabelEXT info = {
        .sType      = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT,
        .pLabelName = label,
        .color = {
            (f32) encoder->desc.debug_color.r,
            (f32) encoder->desc.debug_color.g,
            (f32) encoder->desc.debug_color.b,
            (f32) encoder->desc.debug_color.a,
        },
    };
    vk_instance.cmdBeginDebugUtilsLabel(encoder->bce.buffer, &info);
#else
    UNUSED(encoder);
    UNUSED(label);
#endif
}
 
void gpu_cmd_debug_marker_insert(gpu_command_encoder encoder, const char *label) {
#ifdef KB_DEBUG_BUILD
    VkDebugUtilsLabelEXT info = {
        .sType      = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT,
        .pLabelName = label,
        .color = {
            (f32) encoder->desc.debug_color.r,
            (f32) encoder->desc.debug_color.g,
            (f32) encoder->desc.debug_color.b,
            (f32) encoder->desc.debug_color.a,
        },
    };
    vk_instance.cmdInsertDebugUtilsLabel(encoder->bce.buffer, &info);
#else
    UNUSED(encoder);
    UNUSED(label);
#endif
}
 
void gpu_cmd_debug_marker_end(gpu_command_encoder encoder) {
#ifdef KB_DEBUG_BUILD
    vk_instance.cmdEndDebugUtilsLabel(encoder->bce.buffer);
#else
    UNUSED(encoder);
#endif
}
 
b8 gpu_backend_cmd_end(struct gpu_backend_command_encoder *encoder) {
    VK_CALL_B8(vkEndCommandBuffer(encoder->buffer));
    return true;
}
 
b8 gpu_backend_insert_texture_barriers(struct gpu_backend_command_encoder *encoder,
                                       array_of(const struct gpu_texture_barrier) barriers) {
    VkImageMemoryBarrier vk_barriers[32]  = { 0 };  // FIXME
    u32                  vk_barrier_count = 0;
    VkPipelineStageFlags src_stage        = 0;
    VkPipelineStageFlags dst_stage        = 0;
    array_for_each(const struct gpu_texture_barrier, bar, barriers) {
        VkImageSubresourceRange subresource_range = {
            .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
            .baseMipLevel   = 0,
            .levelCount     = 1,
            .baseArrayLayer = 0,
            .layerCount     = 1,
        };
        VkImageLayout src        = vk_optimal_image_layout(bar->source_use, bar->format);
        VkImageLayout dst        = vk_optimal_image_layout(bar->target_use, bar->format);
        VkAccessFlags src_access = 0;
        VkAccessFlags dst_access = 0;
        vk_map_texture_use_to_barrier_flags(bar->source_use, &src_stage, &src_access);
        vk_map_texture_use_to_barrier_flags(bar->target_use, &dst_stage, &dst_access);
        VkImageMemoryBarrier barrier = {
            .sType            = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
            .oldLayout        = src,
            .newLayout        = dst,
            .image            = bar->tex->raw,
            .subresourceRange = subresource_range,
            .srcAccessMask    = src_access,
            .dstAccessMask    = dst_access,
        };
        vk_barriers[vk_barrier_count++] = barrier;
    }
 
    vkCmdPipelineBarrier(encoder->buffer,
                         src_stage,
                         dst_stage,
                         0,
                         0,
                         KB_NULL,
                         0,
                         KB_NULL,
                         vk_barrier_count,
                         vk_barriers);
    return true;
}
 
b8 gpu_backend_insert_buffer_barriers(struct gpu_backend_command_encoder *encoder,
                                      array_of(const struct gpu_buffer_barrier) barriers) {
    VkBufferMemoryBarrier vk_barriers[32]  = { 0 };  // FIXME
    u32                   vk_barrier_count = 0;
    VkPipelineStageFlags  src_stage        = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
    VkPipelineStageFlags  dst_stage        = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
    array_for_each(const struct gpu_buffer_barrier, bar, barriers) {
        VkAccessFlags src_access = 0;
        VkAccessFlags dst_access = 0;
        vk_map_buffer_use_to_barrier_flags(bar->source_usage, &src_stage, &src_access);
        vk_map_buffer_use_to_barrier_flags(bar->target_usage, &dst_stage, &dst_access);
        VkBufferMemoryBarrier barrier = {
            .sType         = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
            .buffer        = bar->buf->raw,
            .size          = VK_WHOLE_SIZE,
            .srcAccessMask = src_access,
            .dstAccessMask = dst_access,
        };
        vk_barriers[vk_barrier_count++] = barrier;
    }
 
    vkCmdPipelineBarrier(encoder->buffer,
                         src_stage,
                         dst_stage,
                         0,
                         0,
                         KB_NULL,
                         vk_barrier_count,
                         vk_barriers,
                         0,
                         KB_NULL);
    return true;
}