command.c

#include <kiba/gpu/command.h>
 
#include <kiba/core/memory.h>
#include <kiba/gpu/device.h>
 
// TODO validate resource usage transitions against usage declared in descriptor
 
b8 gpu_command_encoder_create(gpu_command_encoder                  *encoder,
                              gpu_device                            device,
                              struct gpu_command_encoder_descriptor desc) {
    gpu_command_encoder new_encoder;
    if (!gpu_device_resource_command_encoder_create(device, &new_encoder)) {
        KB_ERROR("failed to create command encoder as device resource");
        return false;
    }
    const usize tex_tracker_size = array_size(device->textures);
    // TODO handle allocation failures
    new_encoder->texture_trackers = array_create(struct gpu_texture_tracker, tex_tracker_size, &device->alloc);
    for (usize i = 0; i < tex_tracker_size; ++i) {
        const struct gpu_texture_tracker new_tracker = {
            .texture   = device->textures[i].texture,
            .start_use = GPU_TEXTURE_USE_UNINITIALIZED,
            .cur_use   = GPU_TEXTURE_USE_UNINITIALIZED,
        };
        array_push(new_encoder->texture_trackers, new_tracker);  // safe due to capacity calc above
    }
    new_encoder->pending_barriers = array_create(struct gpu_texture_barrier, tex_tracker_size, &device->alloc);
    const usize buf_tracker_size = array_size(device->buffer_trackers);
    new_encoder->buffer_trackers  = array_create(struct gpu_buffer_tracker, buf_tracker_size, &device->alloc);
    for (usize i = 0; i < buf_tracker_size; ++i) {
        const struct gpu_buffer_tracker new_tracker = {
            .buffer    = device->buffer_trackers[i].buffer,
            .start_use = 0,
            .cur_use   = 0,
        };
        array_push(new_encoder->buffer_trackers, new_tracker);  // safe due to capacity calc above
    }
    new_encoder->pending_buffer_barriers = array_create(struct gpu_buffer_barrier, buf_tracker_size, &device->alloc);
    new_encoder->desc                    = desc;
    if (!gpu_backend_command_encoder_create(&new_encoder->bce, &device->bd, desc)) {
        memory_free(new_encoder, sizeof(struct gpu_command_encoder));
        return false;
    }
    *encoder = new_encoder;
    return true;
}
 
void gpu_command_encoder_destroy(gpu_command_encoder encoder) {
    gpu_device_resource_command_encoder_enqueue_destroy(encoder);
}
 
void gpu_command_encoder_destroy_internal(gpu_command_encoder encoder) {
    gpu_backend_command_encoder_destroy(&encoder->bce, &encoder->device->bd);
    array_destroy(&encoder->buffer_trackers);
    array_destroy(&encoder->texture_trackers);
}
 
static void gpu_command_encoder_set_texture_usage(gpu_command_encoder  encoder,
                                                  gpu_texture          texture,
                                                  enum gpu_texture_use new_use) {
    KB_ASSERT(array_size(encoder->texture_trackers) > texture->tracker_id,
              "texture must be created before command encoder was created");
    struct gpu_texture_tracker *tracker = encoder->texture_trackers + texture->tracker_id;
    if (tracker->start_use == GPU_TEXTURE_USE_UNINITIALIZED) {
        tracker->start_use = new_use;
    } else if (tracker->cur_use != GPU_TEXTURE_USE_UNINITIALIZED && tracker->cur_use != new_use) {
        struct gpu_texture_barrier barrier = {
            .tex        = &texture->bt,
            .format     = texture->desc.format,
            .source_use = tracker->cur_use,
            .target_use = new_use,
        };
        KB_ASSERT(array_push_checked(&encoder->pending_barriers, &barrier), "TODO propagate error");
    }
    tracker->cur_use = new_use;
}
 
static void gpu_command_encoder_set_buffer_usage(gpu_command_encoder   encoder,
                                                 gpu_buffer            buffer,
                                                 enum gpu_buffer_usage new_usage) {
    KB_ASSERT(array_size(encoder->buffer_trackers) > buffer->tracker_id,
              "buffer must be created before command encoder was created");
    struct gpu_buffer_tracker *tracker = encoder->buffer_trackers + buffer->tracker_id;
    if (!tracker->start_use) {
        tracker->start_use = new_usage;
    } else if (tracker->cur_use && tracker->cur_use != new_usage) {
        struct gpu_buffer_barrier barrier = {
            .buf          = &buffer->bb,
            .source_usage = tracker->cur_use,
            .target_usage = new_usage,
        };
        KB_ASSERT(array_push_checked(&encoder->pending_buffer_barriers, &barrier), "TODO propagate error");
    }
    tracker->cur_use = new_usage;
}
 
static void gpu_command_encoder_insert_pending_texture_barriers(gpu_command_encoder encoder) {
    if (array_size(encoder->pending_barriers)) {
        gpu_backend_insert_texture_barriers(&encoder->bce, encoder->pending_barriers);
        array_resize(&encoder->pending_barriers, 0);
    }
}
 
static void gpu_command_encoder_insert_pending_buffer_barriers(gpu_command_encoder encoder) {
    if (array_size(encoder->pending_buffer_barriers)) {
        gpu_backend_insert_buffer_barriers(&encoder->bce, encoder->pending_buffer_barriers);
        array_resize(&encoder->pending_buffer_barriers, 0);
    }
}
 
b8 gpu_cmd_begin(gpu_command_encoder encoder) {
    if (gpu_backend_cmd_begin(&encoder->bce)) {
        // TODO, though this is convenient to have, it is mostly a hotfix for RenderDoc not showing
        // the debug name of the command buffer even though it is set properly
        gpu_cmd_debug_marker_begin(encoder, encoder->desc.label);
        return true;
    }
    return false;
}
 
b8 gpu_cmd_copy_buffer_to_buffer(gpu_command_encoder encoder,
                                 gpu_buffer          src,
                                 gpu_buffer          dst,
                                 usize               src_offset,
                                 usize               dst_offset,
                                 usize               size) {
    // TODO proper error messages
    if (!KB_FLAGS_ANY_SET(src->desc.usage, GPU_BUFFER_USAGE_COPY_SRC)) {
        return false;
    }
    if (!KB_FLAGS_ANY_SET(dst->desc.usage, GPU_BUFFER_USAGE_COPY_DST)) {
        return false;
    }
    gpu_command_encoder_set_buffer_usage(encoder, src, GPU_BUFFER_USAGE_COPY_SRC);
    gpu_command_encoder_set_buffer_usage(encoder, dst, GPU_BUFFER_USAGE_COPY_DST);
    gpu_command_encoder_insert_pending_buffer_barriers(encoder);
    gpu_backend_cmd_copy_buffer_to_buffer(&encoder->bce, &src->bb, &dst->bb, src_offset, dst_offset, size);
    return true;
}
 
b8 gpu_begin_render_pass(gpu_command_encoder encoder, struct gpu_render_pass_descriptor desc) {
    // TODO handle depth attachments
    for (usize i = 0; i < desc.color_attachment_count; ++i) {
        gpu_command_encoder_set_texture_usage(encoder,
                                              desc.color_attachments[i].view->texture,
                                              GPU_TEXTURE_USE_COLOR_TARGET);
    }
    gpu_command_encoder_insert_pending_texture_barriers(encoder);
    return gpu_backend_begin_render_pass(&encoder->bce, &encoder->device->bd, desc);
}
 
b8 gpu_end_render_pass(gpu_command_encoder encoder) { return gpu_backend_end_render_pass(&encoder->bce); }
 
b8 gpu_cmd_end(gpu_command_encoder encoder) {
    // TODO could move encoder to set of completed encoders so this can be used to record again
    gpu_cmd_debug_marker_end(encoder);
    return true;
}
 
b8 gpu_command_encoder_submit(gpu_command_encoder encoder) {
    const usize tracker_size = array_size(encoder->texture_trackers);
    KB_ASSERT(tracker_size <= array_size(encoder->device->textures),
              "at least all command buffer textures ({usize}) must still be available in the device ({usize})",
              tracker_size,
              array_size(encoder->device->textures));
    if (tracker_size > 0) {
        array_of(struct gpu_texture_barrier) init_barriers =
            array_create(struct gpu_texture_barrier, tracker_size, &encoder->device->alloc);
        for (usize i = 0; i < tracker_size; ++i) {
            const struct gpu_texture_tracker encoder_tracker = encoder->texture_trackers[i];
            const struct gpu_texture_tracker device_tracker  = encoder->device->textures[i];
            if (device_tracker.texture && encoder_tracker.cur_use != GPU_TEXTURE_USE_UNINITIALIZED
                && encoder_tracker.start_use != device_tracker.cur_use) {
                struct gpu_texture_barrier barrier = {
                    .tex        = &device_tracker.texture->bt,
                    .format     = device_tracker.texture->desc.format,
                    .source_use = device_tracker.cur_use,
                    .target_use = encoder_tracker.start_use,
                };
                KB_ASSERT(array_push_checked(&init_barriers, &barrier), "TODO propagate error");
                encoder->device->textures[i].cur_use = encoder_tracker.cur_use;
            }
        }
        if (array_size(init_barriers) > 0) {
            struct gpu_backend_command_encoder init = { 0 };
            struct gpu_command_encoder_descriptor init_desc = {
                .label = "CE: texture init",
                .debug_color = {
                    .r = 0.3,
                    .g = 0.3,
                    .b = 0.3,
                    .a = 0.3,
                },
            };
            gpu_backend_command_encoder_create(&init, &encoder->device->bd, init_desc);
            gpu_backend_cmd_begin(&init);
            gpu_backend_insert_texture_barriers(&init, init_barriers);
            gpu_backend_cmd_end(&init);
            gpu_backend_command_encoder_submit(&init, &encoder->device->bd);
            gpu_backend_command_encoder_destroy(&init, &encoder->device->bd);
        }
        array_destroy(&init_barriers);
 
        for (usize i = 0; i < tracker_size; ++i) {
            const struct gpu_texture_tracker encoder_tracker = encoder->texture_trackers[i];
            const struct gpu_texture_tracker device_tracker  = encoder->device->textures[i];
            if (device_tracker.texture && device_tracker.start_use != GPU_TEXTURE_USE_UNINITIALIZED
                && encoder_tracker.cur_use != device_tracker.start_use) {
                gpu_command_encoder_set_texture_usage(encoder, device_tracker.texture, device_tracker.start_use);
            }
        }
        gpu_command_encoder_insert_pending_texture_barriers(encoder);
    }
    gpu_backend_cmd_end(&encoder->bce);
    return gpu_backend_command_encoder_submit(&encoder->bce, &encoder->device->bd);
}