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 "identifiers/khandle.h"
#include "kresources/kresource_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 vulkan_buffer {
    VkBuffer handle;
    VkBufferUsageFlagBits usage;
    b8 is_locked;
    VkDeviceMemory memory;
    VkMemoryRequirements memory_requirements;
    i32 memory_index;
    u32 memory_property_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;
 
    khandle 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;
} vulkan_command_buffer;
 
typedef struct vulkan_shader_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_config {
    char* name;
    u32 stride;
    u32 attribute_count;
    VkVertexInputAttributeDescription* attributes;
    u32 descriptor_set_layout_count;
    VkDescriptorSetLayout* descriptor_set_layouts;
    u32 stage_count;
    VkPipelineShaderStageCreateInfo* stages;
    VkViewport viewport;
    VkRect2D scissor;
    face_cull_mode cull_mode;
    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;
 
typedef struct vulkan_pipeline {
    VkPipeline handle;
    VkPipelineLayout pipeline_layout;
    u32 supported_topology_types;
} vulkan_pipeline;
 
#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_UNIFORMS 128
 
#define VULKAN_SHADER_MAX_PUSH_CONST_RANGES 32
 
// Max number of descriptor sets based on frequency. (0=per-frame, 1=per-group, 2=per-draw)
#define VULKAN_SHADER_DESCRIPTOR_SET_LAYOUT_COUNT 3
 
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_uniform_sampler_state {
    shader_uniform uniform;
 
    khandle* sampler_handles;
 
    vulkan_descriptor_state* descriptor_states;
} vulkan_uniform_sampler_state;
 
typedef struct vulkan_uniform_texture_state {
    shader_uniform uniform;
 
    khandle* texture_handles;
 
    vulkan_descriptor_state* descriptor_states;
} vulkan_uniform_texture_state;
typedef struct vulkan_shader_frequency_state {
    u32 id;
    u64 offset;
 
    VkDescriptorSet descriptor_sets[VULKAN_RESOURCE_IMAGE_COUNT];
 
    // UBO descriptor state.
    vulkan_descriptor_state ubo_descriptor_state;
 
    // A mapping of sampler uniforms to descriptors.
    vulkan_uniform_sampler_state* sampler_states;
    // A mapping of texture uniforms to descriptors.
    vulkan_uniform_texture_state* texture_states;
#ifdef KOHI_DEBUG
    u32 descriptor_set_index;
    shader_update_frequency frequency;
#endif
} vulkan_shader_frequency_state;
 
typedef struct vulkan_shader_frequency_info {
    u64 ubo_size;
    u64 ubo_stride;
    u64 ubo_offset;
 
    u8 uniform_count;
    u8 uniform_sampler_count;
    // Darray. Keeps the uniform indices of samplers for fast lookups.
    u32* sampler_indices;
    u8 uniform_texture_count;
    // Darray. Keeps the uniform indices of textures for fast lookups.
    u32* texture_indices;
 
    // Array of sorted texture/sampler indices for quick lookups.
    u32* sorted_indices;
 
    // The currently-bound id for this frequency.
    u32 bound_id;
} vulkan_shader_frequency_info;
 
typedef struct vulkan_shader {
    // The name of the shader (mostly kept for debugging purposes).
    kname name;
    void* mapped_uniform_buffer_blocks[VULKAN_RESOURCE_IMAGE_COUNT];
    void* per_draw_push_constant_block;
 
    u32 id;
 
    u16 max_descriptor_set_count;
 
    u8 descriptor_set_count;
    vulkan_descriptor_set_config descriptor_set_configs[VULKAN_SHADER_DESCRIPTOR_SET_LAYOUT_COUNT];
 
    u8 attribute_count;
    VkVertexInputAttributeDescription attributes[VULKAN_SHADER_MAX_ATTRIBUTES];
 
    u32 uniform_count;
 
    shader_uniform* uniforms;
 
    u32 attribute_stride;
 
    face_cull_mode cull_mode;
 
    u32 topology_types;
 
    u32 max_groups;
 
    u32 max_per_draw_count;
 
    u8 stage_count;
 
    vulkan_shader_stage stages[VULKAN_SHADER_MAX_STAGES];
 
    u32 pool_size_count;
 
    VkDescriptorPoolSize pool_sizes[3];
 
    VkDescriptorPool descriptor_pool;
 
    VkDescriptorSetLayout descriptor_set_layouts[VULKAN_SHADER_DESCRIPTOR_SET_LAYOUT_COUNT];
 
    renderbuffer uniform_buffers[VULKAN_RESOURCE_IMAGE_COUNT];
 
    vulkan_pipeline** pipelines;
    vulkan_pipeline** wireframe_pipelines;
 
    u8 bound_pipeline_index;
    VkPrimitiveTopology current_topology;
 
    vulkan_shader_frequency_state per_frame_state;
 
    vulkan_shader_frequency_state* group_states;
 
    vulkan_shader_frequency_state* per_draw_states;
 
    u64 required_ubo_alignment;
 
    vulkan_shader_frequency_info per_frame_info;
    vulkan_shader_frequency_info per_group_info;
    vulkan_shader_frequency_info per_draw_info;
 
    // 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* image_available_semaphores;
 
    VkSemaphore* queue_complete_semaphores;
 
    VkFence* in_flight_fences;
 
    renderbuffer* staging;
 
    khandle** 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 {
    // Used for handle validation.
    u64 handle_uniqueid;
    // The generation of the internal sampler. Incremented every time the sampler is changed.
    u16 generation;
    // 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 {
    // Unique identifier for this texture.
    u64 uniqueid;
 
    // 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;
 
    vec4 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;
 
    vulkan_texture_handle_data* textures;
 
    vulkan_shader* shaders;
 
    i32 (*find_memory_index)(struct vulkan_context* context, u32 type_filter, u32 property_flags);
 
    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;
 
    vulkan_shader* bound_shader;
 
    struct shaderc_compiler* shader_compiler;
} vulkan_context;