types.h

#pragma once
 
#include <kiba/containers/array.h>
#include <kiba/core/id.h>
#include <kiba/core/types.h>
#include <kiba/gpu/enums.h>
#include <kiba/gpu/internal.h>
#include <kiba/gpu/limits.h>
#include <vulkan/vulkan.h>
 
struct gpu_extent_3d {
    usize width, height;
 
    union {
        usize depth;
        usize layers;
    };
};
 
// TODO gpu_surface_capabilities
 
struct gpu_surface_configuration {
    // TODO is texture usage required when the only valid one is RENDER_ATTACHMENT anyway??
    enum gpu_texture_format format;
    enum gpu_present_mode   present_mode;
    u32                     width;
    u32                     height;
    // TODO composite alpha mode
    // investigate view_formats
};
 
struct gpu_device;
typedef struct gpu_device *gpu_device;
 
struct gpu_texture_descriptor {
    const char           *label;
    struct gpu_extent_3d  size;
    usize                 mip_level_count;
    usize                 sample_count;
 
    enum gpu_texture_dimension dimension;
 
    enum gpu_texture_format format;
 
    enum gpu_texture_usage usage;
 
    // TODO view_formats
};
 
struct gpu_texture {
    struct gpu_backend_texture    bt;
    gpu_device                    device;
    identifier                    tracker_id;
    struct gpu_texture_descriptor desc;
};
typedef struct gpu_texture *gpu_texture;
 
struct gpu_texture_tracker {
    gpu_texture          texture;
    enum gpu_texture_use start_use;
    enum gpu_texture_use cur_use;
};
 
struct gpu_surface {
    struct gpu_backend_surface       bs;
    struct gpu_surface_configuration config;
    gpu_device                       device;
    gpu_texture                      presentation;
};
typedef struct gpu_surface *gpu_surface;
 
struct gpu_texture_view_descriptor {
    const char                     *label;
    enum gpu_texture_format         format;  // must either be texture format or inside texture's view_formats list
    enum gpu_texture_view_dimension dimension;
    enum gpu_texture_aspect         aspect;
    usize                           base_mip_level;
    usize                           mip_level_count;
    usize                           base_array_layer;
    usize                           array_layer_count;
};
 
struct gpu_texture_view {
    struct gpu_backend_texture_view   btv;
    struct gpu_texture_view_descriptor desc;
    gpu_texture                        texture;
    gpu_device                         device;
    // TODO store more info e.g. extent, samples, mips and layers
    // (https://github.com/gfx-rs/wgpu/blob/5b8be97a887eb198f1e58963b4c94d46cf4a84db/wgpu-core/src/resource.rs#L1286)
};
typedef struct gpu_texture_view *gpu_texture_view;
 
struct gpu_buffer_descriptor {
    const char           *label;
    usize                 size;
    enum gpu_buffer_usage usage;
};
 
struct gpu_buffer {
    struct gpu_backend_buffer    bb;
    gpu_device                   device;
    identifier                   tracker_id;
    struct gpu_buffer_descriptor desc;
};
typedef struct gpu_buffer *gpu_buffer;
 
struct gpu_buffer_tracker {
    gpu_buffer            buffer;
    enum gpu_buffer_usage start_use;
    enum gpu_buffer_usage cur_use;
};
 
struct gpu_texture_barrier {
    struct gpu_backend_texture *tex;
    enum gpu_texture_format     format;
    enum gpu_texture_use        source_use;
    enum gpu_texture_use        target_use;
};
 
struct gpu_buffer_barrier {
    struct gpu_backend_buffer *buf;
    enum gpu_buffer_usage      source_usage;
    enum gpu_buffer_usage      target_usage;
};
 
struct gpu_color {
    f64 r, g, b, a;
};
 
struct gpu_command_encoder_descriptor {
    const char      *label;
    struct gpu_color debug_color;
};
 
struct gpu_command_encoder {
    struct gpu_backend_command_encoder bce;
    gpu_device                         device;
    array_of(struct gpu_texture_tracker) texture_trackers;
    array_of(struct gpu_texture_barrier) pending_barriers;
    array_of(struct gpu_buffer_tracker) buffer_trackers;
    array_of(struct gpu_buffer_barrier) pending_buffer_barriers;
    struct gpu_command_encoder_descriptor desc;
};
typedef struct gpu_command_encoder *gpu_command_encoder;
 
enum gpu_device_resource_type {
    GPU_DEVICE_RESOURCE_TEXTURE,
    GPU_DEVICE_RESOURCE_TEXTURE_VIEW,
    GPU_DEVICE_RESOURCE_PIPELINE,
    GPU_DEVICE_RESOURCE_PIPELINE_LAYOUT,
    GPU_DEVICE_RESOURCE_SHADER_MODULE,
    GPU_DEVICE_RESOURCE_BUFFER,
    GPU_DEVICE_RESOURCE_COMMAND_ENCODER,
};
 
struct gpu_device_resource {
    enum gpu_device_resource_type type;
    void                         *handle;
};
struct gpu_queued_resource_destructions {
    array_of(struct gpu_device_resource) resources;
};
 
// TODO add device feature struct
struct gpu_device {
    struct gpu_backend_device bd;
    id_generator texture_id_gen;
    array_of(struct gpu_texture_tracker) textures;  // TODO rename this to texture_trackers
    id_generator buffer_id_gen;
    array_of(struct gpu_buffer_tracker) buffer_trackers;
    struct gpu_queued_resource_destructions destruction_queues[2];
    usize                     destruction_queue_index;
    allocator                 alloc;
};
 
struct gpu_operations {
    enum {
        GPU_LOAD_OP_CLEAR,
        GPU_LOAD_OP_LOAD,
    } load;
 
    enum {
        GPU_STORE_OP_STORE,
        GPU_STORE_OP_DISCARD,
    } store;
 
    union {
        struct gpu_color clear_color;
        f32              clear_depth;
        u32              clear_stencil;
    };
};
 
static inline enum gpu_attachment_ops gpu_operations_to_attachment_ops(struct gpu_operations ops) {
    enum gpu_attachment_ops ret = 0;
    if (ops.load == GPU_LOAD_OP_LOAD) {
        ret |= GPU_ATTACHMENT_OP_LOAD;
    }
    if (ops.store == GPU_STORE_OP_STORE) {
        ret |= GPU_ATTACHMENT_OP_STORE;
    }
    return ret;
}
 
struct gpu_color_attachment {
    gpu_texture_view      view;
    // TODO resolve target
    struct gpu_operations ops;
};
 
struct gpu_depth_stencil_attachment {
    gpu_texture_view     *view;
    struct gpu_operations depth_ops;
    struct gpu_operations stencil_ops;
};
 
struct gpu_render_pass_descriptor {
    const char                         *label;
    struct gpu_extent_3d                extent;
    u32                                 color_attachment_count;
    struct gpu_color_attachment         color_attachments[KB_GPU_MAX_COLOR_ATTACHMENTS];
    struct gpu_depth_stencil_attachment depth_stencil_attachment;
    // TODO timestamp writes, occulusion query set
};
 
// shader
 
struct gpu_shader_module_descriptor {
    const char          *label;
    enum gpu_shader_type type;
    array_of(u8) code;
};
 
struct gpu_shader_module {
    struct gpu_backend_shader_module bs;
    gpu_device                       device;
    enum gpu_shader_type             type;
};
typedef struct gpu_shader_module *gpu_shader_module;
 
// pipeline
 
struct gpu_sampler_descriptor {
    enum {
        GPU_ADDRESS_MODE_CLAMP_TO_EDGE,
        GPU_ADDRESS_MODE_REPEAT,
        GPU_ADDRESS_MODE_MIRROR_REPEAT,
        GPU_ADDRESS_MODE_CLAMP_TO_BORDER,  // TODO check if this should be supported
    } u, v, w;
 
    enum {
        GPU_FILTER_MODE_LINEAR,
        GPU_FILTER_MODE_NEAREST,
    } mag_filter, min_filter, mipmap_filter;
 
    f32 load_min_clamp, load_max_clamp;
};
 
struct gpu_pipeline_layout_descriptor {
    const char *label;
    // TODO push constant ranges
    array_of(gpu_bind_group_layout) bind_group_layouts;  // TODO from struct gpu_bind_group_layout_descriptor
};
 
struct gpu_pipeline_layout {
    struct gpu_backend_pipeline_layout bl;
    gpu_device                         device;
};
typedef struct gpu_pipeline_layout *gpu_pipeline_layout;
 
struct gpu_vertex_buffer_layout_attribute {
    usize                  offset;
    usize                  location;
    enum gpu_vertex_format format;
};
 
struct gpu_vertex_buffer_layout {
    usize              stride;
    enum gpu_step_mode step_mode;
    array_of(struct gpu_vertex_buffer_layout_attribute) attributes;
};
 
struct gpu_vertex_state {
    gpu_shader_module shader;
    const char *entry_point;  // TODO This is pointless with the current shader impl. glslc only supports one entry
                              // point per compilation unit of glsl. In glsl that entry point must be named `main`.
    array_of(struct gpu_vertex_buffer_layout) buffers;
};
 
struct gpu_primitive_state {
    enum gpu_primitive_topology topology;
    // TODO check strip index format
    enum gpu_front_face         front_face;
    enum gpu_cull_mode          cull_mode;
    // TODO check unclipped depth
    enum gpu_polygon_mode       polygon_mode;
    // TODO check conservative
};
 
struct gpu_blend_state {
    b8 active;
    // TODO
};
 
struct gpu_color_target_state {
    enum gpu_texture_format format;
    struct gpu_blend_state  blend;
    enum gpu_color_writes   write_mask;
};
 
struct gpu_fragment_state {
    b8                active;
    gpu_shader_module shader;
    const char       *entry_point;
    array_of(struct gpu_color_target_state) targets;
    // TODO multiview
};
 
struct gpu_depth_stencil_state {
    enum gpu_texture_format format;
    b8                      depth_write_enabled;
    enum gpu_compare_func   depth_compare;
 
    struct {
        struct {
            enum gpu_compare_func compare;
 
            enum {
                GPU_STENCIL_OPERATION_KEEP,
                GPU_STENCIL_OPERATION_ZERO,
                GPU_STENCIL_OPERATION_REPLACE,
                GPU_STENCIL_OPERATION_INVERT,
                GPU_STENCIL_OPERATION_INCREMENT_CLAMP,
                GPU_STENCIL_OPERATION_DECREMENT_CLAMP,
                GPU_STENCIL_OPERATION_INCREMENT_WRAP,
                GPU_STENCIL_OPERATION_DECREMENT_WRAP,
            } fail_op, depth_fail_op, pass_op;
        } front, back;
 
        u8 read_mask, write_mask;
    } stencil;
 
    struct {
        f32 constant;
        f32 slope_scale;
        f32 clamp;
    } depth_bias;
};
 
struct gpu_render_pipeline_descriptor {
    const char                    *label;
    gpu_pipeline_layout            layout;
    struct gpu_vertex_state        vertex;
    struct gpu_primitive_state     primitive;
    struct gpu_depth_stencil_state depth_stencil;
    struct gpu_fragment_state      fragment;
    // TODO multisample state, multiview
};
 
struct gpu_pipeline {
    struct gpu_backend_pipeline bp;
    gpu_device                  device;
};
typedef struct gpu_pipeline *gpu_pipeline;