vulkan_types.h

Go to the documentation of this file.

 
#pragma once
 
#include <vulkan/vulkan.h>
 
#include "core_render_types.h"
#include "debug/kassert.h"
#include "defines.h"
#include "math/math_types.h"
#include "platform/vulkan_platform.h"
#include "renderer/renderer_types.h"
#include "vulkan/vulkan_core.h"
 
// Frames in flight can differ for double-buffering (1) or triple-buffering (2), but will never exceed this amount.
#define VULKAN_MAX_FRAMES_IN_FLIGHT 2
// The colour buffer count can differ for double-buffering (2) or triple-buffering (3), but will never exceed this amount.
#define VULKAN_MAX_COLOUR_BUFFER_COUNT 3
 
// The array size for resources created per-image. Regardless of whether double- or
// triple-buffering is used, this should always be used for resource array sizes so that
// triple buffering can be toggled in settings.
#define VULKAN_RESOURCE_IMAGE_COUNT 3
 
#define VK_CHECK(expr)               \
    {                                \
        KASSERT(expr == VK_SUCCESS); \
    }
 
struct vulkan_context;
 
typedef struct vkbuffer_info {
    VkBuffer handle;
    VkDeviceMemory memory;
    // 0 unless buffer has been mapped to it.
    void* mapped_memory;
} vkbuffer_info;
 
typedef struct vulkan_buffer {
    u8 handle_count;
    vkbuffer_info* infos;
    VkBufferUsageFlags usage;
    b8 is_locked;
    VkMemoryRequirements memory_requirements;
    i32 memory_index;
    u32 memory_property_flags;
    u64 size;
    kname name;
    renderbuffer_type type;
 
    renderbuffer_flags flags;
 
} vulkan_buffer;
 
typedef struct vulkan_swapchain_support_info {
    VkSurfaceCapabilitiesKHR capabilities;
    u32 format_count;
    VkSurfaceFormatKHR* formats;
    u32 present_mode_count;
    VkPresentModeKHR* present_modes;
} vulkan_swapchain_support_info;
 
typedef enum vulkan_device_support_flag_bits {
    VULKAN_DEVICE_SUPPORT_FLAG_NONE_BIT = 0x00,
 
    VULKAN_DEVICE_SUPPORT_FLAG_NATIVE_DYNAMIC_STATE_BIT = 0x01,
 
    VULKAN_DEVICE_SUPPORT_FLAG_DYNAMIC_STATE_BIT = 0x02,
    VULKAN_DEVICE_SUPPORT_FLAG_LINE_SMOOTH_RASTERISATION_BIT = 0x04
} vulkan_device_support_flag_bits;
 
typedef u32 vulkan_device_support_flags;
 
typedef struct vulkan_device {
    u32 api_major;
 
    u32 api_minor;
 
    u32 api_patch;
 
    VkPhysicalDevice physical_device;
    VkDevice logical_device;
    vulkan_swapchain_support_info swapchain_support;
 
    i32 graphics_queue_index;
    i32 present_queue_index;
    i32 transfer_queue_index;
    b8 supports_device_local_host_visible;
 
    VkQueue graphics_queue;
    VkQueue present_queue;
    VkQueue transfer_queue;
 
    VkCommandPool graphics_command_pool;
 
    VkPhysicalDeviceProperties properties;
    VkPhysicalDeviceFeatures features;
    VkPhysicalDeviceMemoryProperties memory;
 
    VkFormat depth_format;
    u8 depth_channel_count;
 
    vulkan_device_support_flags support_flags;
} vulkan_device;
 
typedef struct vulkan_image {
    VkImage handle;
    VkDeviceMemory memory;
    VkImageCreateInfo image_create_info;
 
    VkImageView view;
    VkImageSubresourceRange view_subresource_range;
    VkImageViewCreateInfo view_create_info;
    VkImageView* layer_views;
    VkImageSubresourceRange* layer_view_subresource_ranges;
    VkImageViewCreateInfo* layer_view_create_infos;
    VkMemoryRequirements memory_requirements;
    VkMemoryPropertyFlags memory_flags;
    VkFormat format;
    u32 width;
    u32 height;
    u16 layer_count;
    char* name;
    ktexture_flag_bits flags;
    u32 mip_levels;
    b8 has_view;
} vulkan_image;
 
typedef struct vulkan_swapchain {
    VkSurfaceFormatKHR image_format;
 
    renderer_config_flags flags;
 
    VkSwapchainKHR handle;
    u32 image_count;
 
    b8 supports_blit_dest;
 
    b8 supports_blit_src;
 
    ktexture swapchain_colour_texture;
 
    u32 image_index;
} vulkan_swapchain;
 
typedef enum vulkan_command_buffer_state {
    COMMAND_BUFFER_STATE_READY,
    COMMAND_BUFFER_STATE_RECORDING,
    COMMAND_BUFFER_STATE_IN_RENDER_PASS,
    COMMAND_BUFFER_STATE_RECORDING_ENDED,
    COMMAND_BUFFER_STATE_SUBMITTED,
    COMMAND_BUFFER_STATE_NOT_ALLOCATED
} vulkan_command_buffer_state;
 
typedef struct vulkan_command_buffer {
    VkCommandBuffer handle;
 
#ifdef KOHI_DEBUG
    // Name, kept for debugging purposes.
    const char* name;
#endif
 
    vulkan_command_buffer_state state;
 
    b8 is_primary;
 
    u16 secondary_count;
    struct vulkan_command_buffer* secondary_buffers;
 
    u16 secondary_buffer_index;
    b8 in_secondary;
 
    struct vulkan_command_buffer* parent;
 
    // Current attachments.
    u8 colour_attachment_count;
    ktexture colour_attachments[16];
    ktexture depth_attachment;
} vulkan_command_buffer;
 
typedef struct vulkan_shader_stage {
    shader_stage stage;
    VkShaderModuleCreateInfo create_info;
    VkShaderModule handle;
    VkPipelineShaderStageCreateInfo shader_stage_create_info;
} vulkan_shader_stage;
 
typedef enum vulkan_topology_class {
    VULKAN_TOPOLOGY_CLASS_POINT = 0,
    VULKAN_TOPOLOGY_CLASS_LINE = 1,
    VULKAN_TOPOLOGY_CLASS_TRIANGLE = 2,
    VULKAN_TOPOLOGY_CLASS_MAX = VULKAN_TOPOLOGY_CLASS_TRIANGLE + 1
} vulkan_topology_class;
 
typedef struct vulkan_pipeline {
    VkPipeline handle;
    VkPipelineLayout pipeline_layout;
    primitive_topology_type_bits supported_topology_types;
} vulkan_pipeline;
 
typedef struct vulkan_vertex_layout_pipeline {
    u8 stage_count;
    vulkan_shader_stage* stages;
    VkPipelineShaderStageCreateInfo* stage_create_infos;
    // Shallow copy of config'd stage sources.
    const char** stage_sources;
 
    u32 attribute_stride;
    u32 attribute_count;
    VkVertexInputAttributeDescription* attributes;
 
    vulkan_pipeline* pipelines;
    vulkan_pipeline* wireframe_pipelines;
 
    u8 bound_pipeline_index;
    u8 default_pipeline_index;
} vulkan_vertex_layout_pipeline;
 
typedef struct vulkan_pipeline_config {
    char* name;
    u8 stage_count;
    vulkan_shader_stage* stages;
    VkPipelineShaderStageCreateInfo* stage_create_infos;
 
    u32 attribute_stride;
    u32 attribute_count;
    VkVertexInputAttributeDescription* attributes;
 
    u32 descriptor_set_layout_count;
    VkDescriptorSetLayout* descriptor_set_layouts;
    u32 shader_flags;
    u32 push_constant_range_count;
    krange* push_constant_ranges;
    u32 topology_types;
    renderer_winding winding;
 
    u32 colour_attachment_count;
    VkFormat* colour_attachment_formats;
    VkFormat depth_attachment_format;
    VkFormat stencil_attachment_format;
} vulkan_pipeline_config;
 
#define VULKAN_SHADER_MAX_STAGES 8
#define VULKAN_SHADER_MAX_TEXTURE_BINDINGS 16
#define VULKAN_SHADER_MAX_SAMPLER_BINDINGS 16
#define VULKAN_SHADER_MAX_ATTRIBUTES 16
 
#define VULKAN_SHADER_MAX_PUSH_CONST_RANGES 32
 
typedef struct vulkan_descriptor_set_config {
    u8 binding_count;
    VkDescriptorSetLayoutBinding* bindings;
} vulkan_descriptor_set_config;
 
typedef struct vulkan_descriptor_state {
    u16 renderer_frame_number[VULKAN_RESOURCE_IMAGE_COUNT];
} vulkan_descriptor_state;
 
typedef struct vulkan_sampler_state {
    shader_sampler_type type;
 
    ksampler_backend* sampler_handles;
 
    vulkan_descriptor_state* descriptor_states;
 
    u8 array_size;
} vulkan_sampler_state;
 
typedef struct vulkan_texture_state {
    ktexture_type type;
 
    ktexture* texture_handles;
 
    vulkan_descriptor_state* descriptor_states;
 
    u8 array_size;
} vulkan_texture_state;
 
typedef struct vulkan_ssbo_state {
    krenderbuffer buffer;
 
    vulkan_descriptor_state descriptor_state;
 
} vulkan_ssbo_state;
 
typedef struct vulkan_shader_binding {
    shader_binding_type binding_type;
    u8 binding_type_index;
} vulkan_shader_binding;
 
typedef struct vulkan_shader_binding_set_instance_state {
    u64 ubo_size;
    u64 ubo_stride;
    u64 ubo_offset;
 
    VkDescriptorSet descriptor_sets[VULKAN_RESOURCE_IMAGE_COUNT];
 
    // UBO descriptor state for this set. Max of one UBO per set.
    vulkan_descriptor_state ubo_descriptor_state;
 
    // SSBO descriptor states for this set.
    vulkan_ssbo_state* ssbo_states;
 
    // A mapping of samplers to descriptors.
    vulkan_sampler_state* sampler_states;
 
    // A mapping of textures to descriptors.
    vulkan_texture_state* texture_states;
 
    // Used to determine if this instance state has already been updated for a given frame.
    u16 renderer_frame_number;
 
#ifdef KOHI_DEBUG
    // Also the binding set index. Just here for debugging purposes (debug builds only)
    u32 descriptor_set_index;
#endif
} vulkan_shader_binding_set_instance_state;
 
typedef struct vulkan_shader_binding_set_state {
    // Total number of uses.
    u32 max_instance_count;
    // Binding set state per use. Array size = max_use_count
    vulkan_shader_binding_set_instance_state* instances;
 
    // The number of bindings in this set.
    u8 binding_count;
    // A lookup table of bindings for this binding set.
    vulkan_shader_binding* bindings;
 
    u8 texture_binding_count;
    u8 ssbo_binding_count;
    u8 sampler_binding_count;
} vulkan_shader_binding_set_state;
 
typedef struct vulkan_shader {
    // The name of the shader (mostly kept for debugging purposes).
    kname name;
 
    u32 id;
 
    u8 descriptor_set_count;
    vulkan_descriptor_set_config* descriptor_set_configs;
    VkDescriptorSetLayout* descriptor_set_layouts;
    vulkan_shader_binding_set_state* binding_set_states;
 
    primitive_topology_type topology_types;
 
    // The size of the immediates block of memory
    u8 immediate_size;
 
    u32 pool_size_count;
 
    VkDescriptorPoolSize pool_sizes[SHADER_BINDING_TYPE_COUNT];
 
    VkDescriptorPool descriptor_pool;
 
    krenderbuffer uniform_buffer;
 
    u8 colour_attachment_count;
    VkFormat* colour_attachments;
 
    VkFormat depth_attachment;
    VkFormat stencil_attachment;
 
    u8 vertex_layout_pipeline_count;
    // One per vertex layout
    vulkan_vertex_layout_pipeline* vertex_layout_pipelines;
    // Index into the vertex_layout_pipelines array.
    u8 vertex_layout_index;
 
    u16 renderer_frame_number;
 
    VkPrimitiveTopology default_topology;
 
    // Shader flags
    shader_flags flags;
} vulkan_shader;
 
// Forward declare shaderc compiler.
struct shaderc_compiler;
 
typedef struct kwindow_renderer_backend_state {
    VkSurfaceKHR surface;
    vulkan_swapchain swapchain;
 
    u32 image_index;
    u32 current_frame;
 
    u8 max_frames_in_flight;
 
    b8 recreating_swapchain;
 
    vulkan_command_buffer* graphics_command_buffers;
 
    VkSemaphore* acquire_semaphores;
 
    VkSemaphore* submit_semaphores;
 
    VkFence* in_flight_fences;
 
    krenderbuffer* staging;
 
    ktexture** frame_texture_updated_list;
 
    u64 framebuffer_size_generation;
    u64 framebuffer_previous_size_generation;
 
    u8 skip_frames;
} kwindow_renderer_backend_state;
 
typedef struct vulkan_sampler_handle_data {
    // Sampler name for named lookups and serialization.
    kname name;
    // The underlying sampler handle.
    VkSampler sampler;
} vulkan_sampler_handle_data;
 
typedef struct vulkan_texture_handle_data {
 
    // The generation of the internal texture. Incremented every time the texture is changed.
    u16 generation;
 
    // Number of vulkan_images in the array. This is typically 1 unless the texture
    // requires the frame_count to be taken into account.
    u32 image_count;
    // Array of images. See image_count.
    vulkan_image* images;
} vulkan_texture_handle_data;
 
typedef struct vulkan_context {
    u32 api_major;
 
    u32 api_minor;
 
    u32 api_patch;
 
    renderer_config_flags flags;
 
    VkClearColorValue colour_clear_value;
    VkClearDepthStencilValue depth_stencil_clear_value;
 
    rect_2di viewport_rect;
 
    /* vec4 scissor_rect; */
 
    VkInstance instance;
    VkAllocationCallbacks* allocator;
 
    VkDebugUtilsMessengerEXT debug_messenger;
 
    PFN_vkSetDebugUtilsObjectNameEXT pfnSetDebugUtilsObjectNameEXT;
 
    PFN_vkSetDebugUtilsObjectTagEXT pfnSetDebugUtilsObjectTagEXT;
 
    PFN_vkCmdBeginDebugUtilsLabelEXT pfnCmdBeginDebugUtilsLabelEXT;
    PFN_vkCmdEndDebugUtilsLabelEXT pfnCmdEndDebugUtilsLabelEXT;
 
    vulkan_device device;
 
    struct kwindow* current_window;
 
    b8 render_flag_changed;
 
    b8 validation_enabled;
 
    b8 multithreading_enabled;
 
    b8 triple_buffering_enabled;
 
    vulkan_sampler_handle_data* samplers;
 
    u32 max_texture_count;
    vulkan_texture_handle_data* textures;
 
    vulkan_shader* shaders;
 
    PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT;
    PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT;
    PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT;
    PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT;
    PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT;
    PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT;
    PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT;
 
    PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
    PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
 
    // The render hardware interface.
    krhi_vulkan rhi;
 
    kshader bound_shader;
 
    // Darray of vulkan buffers, which matches up to the frontend's krenderbuffers.
    vulkan_buffer* renderbuffers;
 
    // Cached handles to renderbuffers.
    kname standard_vertex_buffer_name;
    kname index_buffer_name;
 
    struct shaderc_compiler* shader_compiler;
} vulkan_context;