vkd3d_shader.h

Go to the documentation of this file.

/*
 * Copyright 2017-2019 Józef Kucia for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef __VKD3D_SHADER_H
#define __VKD3D_SHADER_H
 
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <vkd3d_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */


enum vkd3d_shader_api_version
{
    VKD3D_SHADER_API_VERSION_1_0,
    VKD3D_SHADER_API_VERSION_1_1,
    VKD3D_SHADER_API_VERSION_1_2,
    VKD3D_SHADER_API_VERSION_1_3,
    VKD3D_SHADER_API_VERSION_1_4,
    VKD3D_SHADER_API_VERSION_1_5,
    VKD3D_SHADER_API_VERSION_1_6,
    VKD3D_SHADER_API_VERSION_1_7,
    VKD3D_SHADER_API_VERSION_1_8,
    VKD3D_SHADER_API_VERSION_1_9,
    VKD3D_SHADER_API_VERSION_1_10,
    VKD3D_SHADER_API_VERSION_1_11,
    VKD3D_SHADER_API_VERSION_1_12,
    VKD3D_SHADER_API_VERSION_1_13,
    VKD3D_SHADER_API_VERSION_1_14,
    VKD3D_SHADER_API_VERSION_1_15,
    VKD3D_SHADER_API_VERSION_1_16,
    VKD3D_SHADER_API_VERSION_1_17,
    VKD3D_SHADER_API_VERSION_1_18,
    VKD3D_SHADER_API_VERSION_1_19,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION),
};

enum vkd3d_shader_structure_type
{
    VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_INTERFACE_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_SPIRV_DOMAIN_SHADER_TARGET_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_SPIRV_TARGET_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_TRANSFORM_FEEDBACK_INFO,

    VKD3D_SHADER_STRUCTURE_TYPE_HLSL_SOURCE_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_PREPROCESS_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_DESCRIPTOR_OFFSET_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_SCAN_SIGNATURE_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_VARYING_MAP_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_SCAN_COMBINED_RESOURCE_SAMPLER_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_PARAMETER_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_SCAN_HULL_SHADER_TESSELLATION_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_SCAN_THREAD_GROUP_SIZE_INFO,
    VKD3D_SHADER_STRUCTURE_TYPE_D3DBC_SOURCE_INFO,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_STRUCTURE_TYPE),
};

enum vkd3d_shader_compile_option_buffer_uav
{
    VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV_STORAGE_TEXEL_BUFFER = 0x00000000,
    VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV_STORAGE_BUFFER       = 0x00000001,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV),
};

enum vkd3d_shader_compile_option_typed_uav
{
    VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV_READ_FORMAT_R32     = 0x00000000,
    VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV_READ_FORMAT_UNKNOWN = 0x00000001,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV),
};
 
enum vkd3d_shader_compile_option_formatting_flags
{
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING_NONE    = 0x00000000,
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING_COLOUR  = 0x00000001,
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING_INDENT  = 0x00000002,
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING_OFFSETS = 0x00000004,
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING_HEADER  = 0x00000008,
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING_RAW_IDS = 0x00000010,
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING_IO_SIGNATURES = 0x00000020,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_FORMATTING_FLAGS),
};

enum vkd3d_shader_compile_option_pack_matrix_order
{
    VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ROW_MAJOR    = 0x00000001,
    VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_COLUMN_MAJOR = 0x00000002,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER),
};

enum vkd3d_shader_compile_option_backward_compatibility
{
    VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES = 0x00000001,
    VKD3D_SHADER_COMPILE_OPTION_DOUBLE_AS_FLOAT_ALIAS = 0x00000002,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY),
};

enum vkd3d_shader_compile_option_fragment_coordinate_origin
{
    VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000,
    VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN),
};

enum vkd3d_shader_compile_option_feature_flags
{
    VKD3D_SHADER_COMPILE_OPTION_FEATURE_INT64         = 0x00000001,
    VKD3D_SHADER_COMPILE_OPTION_FEATURE_FLOAT64       = 0x00000002,
    VKD3D_SHADER_COMPILE_OPTION_FEATURE_WAVE_OPS      = 0x00000004,
    VKD3D_SHADER_COMPILE_OPTION_FEATURE_ZERO_INITIALIZE_WORKGROUP_MEMORY = 0x00000008,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_FEATURE_FLAGS),
};

enum vkd3d_shader_parse_dxbc_flags
{
    VKD3D_SHADER_PARSE_DXBC_IGNORE_CHECKSUM           = 0x00000001,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_PARSE_DXBC_FLAGS),
};
 
enum vkd3d_shader_compile_option_name
{
    VKD3D_SHADER_COMPILE_OPTION_STRIP_DEBUG = 0x00000001,
    VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV  = 0x00000002,
    VKD3D_SHADER_COMPILE_OPTION_FORMATTING  = 0x00000003,
    VKD3D_SHADER_COMPILE_OPTION_API_VERSION = 0x00000004,
    VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV   = 0x00000005,
    VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE = 0x00000006,
    VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER = 0x00000007,
    VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY = 0x00000008,
    VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN = 0x00000009,
    VKD3D_SHADER_COMPILE_OPTION_FEATURE = 0x0000000a,
    VKD3D_SHADER_COMPILE_OPTION_CHILD_EFFECT = 0x0000000b,
    VKD3D_SHADER_COMPILE_OPTION_WARN_IMPLICIT_TRUNCATION = 0x0000000c,
    VKD3D_SHADER_COMPILE_OPTION_INCLUDE_EMPTY_BUFFERS_IN_EFFECTS = 0x0000000d,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_NAME),
};

struct vkd3d_shader_compile_option
{
    enum vkd3d_shader_compile_option_name name;
    unsigned int value;
};

enum vkd3d_shader_visibility
{
    VKD3D_SHADER_VISIBILITY_ALL = 0,
    VKD3D_SHADER_VISIBILITY_VERTEX = 1,
    VKD3D_SHADER_VISIBILITY_HULL = 2,
    VKD3D_SHADER_VISIBILITY_DOMAIN = 3,
    VKD3D_SHADER_VISIBILITY_GEOMETRY = 4,
    VKD3D_SHADER_VISIBILITY_PIXEL = 5,

    VKD3D_SHADER_VISIBILITY_COMPUTE = 1000000000,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_VISIBILITY),
};

struct vkd3d_shader_code
{
    const void *code;
    size_t size;
};

enum vkd3d_shader_descriptor_type
{
    VKD3D_SHADER_DESCRIPTOR_TYPE_SRV     = 0x0,
    VKD3D_SHADER_DESCRIPTOR_TYPE_UAV     = 0x1,
    VKD3D_SHADER_DESCRIPTOR_TYPE_CBV     = 0x2,
    VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER = 0x3,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_DESCRIPTOR_TYPE),
};

struct vkd3d_shader_descriptor_binding
{
    unsigned int set;
    unsigned int binding;
    unsigned int count;
};
 
enum vkd3d_shader_binding_flag
{
    VKD3D_SHADER_BINDING_FLAG_BUFFER = 0x00000001,
    VKD3D_SHADER_BINDING_FLAG_IMAGE  = 0x00000002,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_BINDING_FLAG),
};

enum vkd3d_shader_fog_fragment_mode
{
    VKD3D_SHADER_FOG_FRAGMENT_NONE = 0x0,
    VKD3D_SHADER_FOG_FRAGMENT_EXP = 0x1,
    VKD3D_SHADER_FOG_FRAGMENT_EXP2 = 0x2,
    VKD3D_SHADER_FOG_FRAGMENT_LINEAR = 0x3,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_FOG_FRAGMENT_MODE),
};

enum vkd3d_shader_fog_source
{
    VKD3D_SHADER_FOG_SOURCE_FOG = 0x0,
    VKD3D_SHADER_FOG_SOURCE_FOG_OR_SPECULAR_W = 0x1,
    VKD3D_SHADER_FOG_SOURCE_Z = 0x2,
    VKD3D_SHADER_FOG_SOURCE_W = 0x3,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_FOG_SOURCE),
};

enum vkd3d_shader_parameter_type
{
    VKD3D_SHADER_PARAMETER_TYPE_UNKNOWN,
    VKD3D_SHADER_PARAMETER_TYPE_IMMEDIATE_CONSTANT,
    VKD3D_SHADER_PARAMETER_TYPE_SPECIALIZATION_CONSTANT,
    VKD3D_SHADER_PARAMETER_TYPE_BUFFER,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_PARAMETER_TYPE),
};

enum vkd3d_shader_parameter_data_type
{
    VKD3D_SHADER_PARAMETER_DATA_TYPE_UNKNOWN,
    VKD3D_SHADER_PARAMETER_DATA_TYPE_UINT32,
    VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32,
    VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_PARAMETER_DATA_TYPE),
};

enum vkd3d_shader_parameter_name
{
    VKD3D_SHADER_PARAMETER_NAME_UNKNOWN,
    VKD3D_SHADER_PARAMETER_NAME_RASTERIZER_SAMPLE_COUNT,
    VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_FUNC,
    VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_REF,
    VKD3D_SHADER_PARAMETER_NAME_FLAT_INTERPOLATION,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_MASK,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_0,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_1,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_2,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_3,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_4,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_5,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_6,
    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_7,
    VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE,
    VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MIN,
    VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MAX,
    VKD3D_SHADER_PARAMETER_NAME_POINT_SPRITE,
    VKD3D_SHADER_PARAMETER_NAME_FOG_FRAGMENT_MODE,
    VKD3D_SHADER_PARAMETER_NAME_FOG_COLOUR,
    VKD3D_SHADER_PARAMETER_NAME_FOG_END,
    VKD3D_SHADER_PARAMETER_NAME_FOG_SCALE,
    VKD3D_SHADER_PARAMETER_NAME_FOG_SOURCE,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_0,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_1,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_2,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_3,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_4,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_5,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_0,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_1,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_2,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_3,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_4,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_5,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_0,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_1,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_2,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_3,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_4,
    VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_5,
    VKD3D_SHADER_PARAMETER_NAME_PROJECTED_TEXTURE_MASK,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_PARAMETER_NAME),
};

struct vkd3d_shader_parameter_immediate_constant
{
    union
    {
        uint32_t u32;
        float f32;
    } u;
};

struct vkd3d_shader_parameter_immediate_constant1
{
    union
    {
        uint32_t u32;
        float f32;
        float f32_vec4[4];
        void *_pointer_pad;
        uint32_t _pad[4];
    } u;
};

struct vkd3d_shader_parameter_specialization_constant
{
    uint32_t id;
};

struct vkd3d_shader_parameter_buffer
{
    unsigned int set;
    unsigned int binding;
    uint32_t offset;
};

struct vkd3d_shader_parameter
{
    enum vkd3d_shader_parameter_name name;
    enum vkd3d_shader_parameter_type type;
    enum vkd3d_shader_parameter_data_type data_type;
    union
    {
        struct vkd3d_shader_parameter_immediate_constant immediate_constant;
        struct vkd3d_shader_parameter_specialization_constant specialization_constant;
    } u;
};

struct vkd3d_shader_parameter1
{
    enum vkd3d_shader_parameter_name name;
    enum vkd3d_shader_parameter_type type;
    enum vkd3d_shader_parameter_data_type data_type;
    union
    {
        struct vkd3d_shader_parameter_immediate_constant1 immediate_constant;
        struct vkd3d_shader_parameter_specialization_constant specialization_constant;
        struct vkd3d_shader_parameter_buffer buffer;
        void *_pointer_pad;
        uint32_t _pad[4];
    } u;
};

enum vkd3d_shader_d3dbc_constant_register
{
    VKD3D_SHADER_D3DBC_FLOAT_CONSTANT_REGISTER  = 0x0,
    VKD3D_SHADER_D3DBC_INT_CONSTANT_REGISTER    = 0x1,
    VKD3D_SHADER_D3DBC_BOOL_CONSTANT_REGISTER   = 0x2,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_D3DBC_CONSTANT_REGISTER),
};

struct vkd3d_shader_resource_binding
{
    enum vkd3d_shader_descriptor_type type;
    unsigned int register_space;
    unsigned int register_index;
    enum vkd3d_shader_visibility shader_visibility;
    unsigned int flags;

    struct vkd3d_shader_descriptor_binding binding;
};
 
#define VKD3D_SHADER_DUMMY_SAMPLER_INDEX ~0u

struct vkd3d_shader_combined_resource_sampler
{
    unsigned int resource_space;
    unsigned int resource_index;
    unsigned int sampler_space;
    unsigned int sampler_index;
    enum vkd3d_shader_visibility shader_visibility;
    unsigned int flags;

    struct vkd3d_shader_descriptor_binding binding;
};

struct vkd3d_shader_uav_counter_binding
{
    unsigned int register_space;
    unsigned int register_index;
    enum vkd3d_shader_visibility shader_visibility;

    struct vkd3d_shader_descriptor_binding binding;
    unsigned int offset;
};

struct vkd3d_shader_push_constant_buffer
{
    unsigned int register_space;
    unsigned int register_index;
    enum vkd3d_shader_visibility shader_visibility;

    unsigned int offset;
    unsigned int size;
};

struct vkd3d_shader_interface_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    const struct vkd3d_shader_resource_binding *bindings;
    unsigned int binding_count;

    const struct vkd3d_shader_push_constant_buffer *push_constant_buffers;
    unsigned int push_constant_buffer_count;

    const struct vkd3d_shader_combined_resource_sampler *combined_samplers;
    unsigned int combined_sampler_count;

    const struct vkd3d_shader_uav_counter_binding *uav_counters;
    unsigned int uav_counter_count;
};
 
struct vkd3d_shader_transform_feedback_element
{
    unsigned int stream_index;
    const char *semantic_name;
    unsigned int semantic_index;
    uint8_t component_index;
    uint8_t component_count;
    uint8_t output_slot;
};
 
/* Extends vkd3d_shader_interface_info. */
struct vkd3d_shader_transform_feedback_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;
 
    const struct vkd3d_shader_transform_feedback_element *elements;
    unsigned int element_count;
    const unsigned int *buffer_strides;
    unsigned int buffer_stride_count;
};
 
struct vkd3d_shader_descriptor_offset
{
    unsigned int static_offset;
    unsigned int dynamic_offset_index;
};

struct vkd3d_shader_descriptor_offset_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    unsigned int descriptor_table_offset;
    unsigned int descriptor_table_count;

    const struct vkd3d_shader_descriptor_offset *binding_offsets;

    const struct vkd3d_shader_descriptor_offset *uav_counter_offsets;
};

enum vkd3d_shader_source_type
{
    VKD3D_SHADER_SOURCE_NONE,
    VKD3D_SHADER_SOURCE_DXBC_TPF,
    VKD3D_SHADER_SOURCE_HLSL,
    VKD3D_SHADER_SOURCE_D3D_BYTECODE,
    VKD3D_SHADER_SOURCE_DXBC_DXIL,
    VKD3D_SHADER_SOURCE_FX,
    VKD3D_SHADER_SOURCE_TX,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SOURCE_TYPE),
};

enum vkd3d_shader_target_type
{
    VKD3D_SHADER_TARGET_NONE,
    VKD3D_SHADER_TARGET_SPIRV_BINARY,
    VKD3D_SHADER_TARGET_SPIRV_TEXT,
    VKD3D_SHADER_TARGET_D3D_ASM,
    VKD3D_SHADER_TARGET_D3D_BYTECODE,
    VKD3D_SHADER_TARGET_DXBC_TPF,
    VKD3D_SHADER_TARGET_GLSL,
    VKD3D_SHADER_TARGET_FX,
    VKD3D_SHADER_TARGET_MSL,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_TARGET_TYPE),
};

enum vkd3d_shader_log_level
{
    VKD3D_SHADER_LOG_NONE,
    VKD3D_SHADER_LOG_ERROR,
    VKD3D_SHADER_LOG_WARNING,
    VKD3D_SHADER_LOG_INFO,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_LOG_LEVEL),
};

struct vkd3d_shader_compile_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    struct vkd3d_shader_code source;

    enum vkd3d_shader_source_type source_type;
    enum vkd3d_shader_target_type target_type;

    const struct vkd3d_shader_compile_option *options;
    unsigned int option_count;

    enum vkd3d_shader_log_level log_level;
    const char *source_name;
};
 
enum vkd3d_shader_spirv_environment
{
    VKD3D_SHADER_SPIRV_ENVIRONMENT_NONE,
    VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5,
    VKD3D_SHADER_SPIRV_ENVIRONMENT_VULKAN_1_0, /* default target */
    VKD3D_SHADER_SPIRV_ENVIRONMENT_VULKAN_1_1,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SPIRV_ENVIRONMENT),
};
 
enum vkd3d_shader_spirv_extension
{
    VKD3D_SHADER_SPIRV_EXTENSION_NONE,
    VKD3D_SHADER_SPIRV_EXTENSION_EXT_DEMOTE_TO_HELPER_INVOCATION,
    VKD3D_SHADER_SPIRV_EXTENSION_EXT_DESCRIPTOR_INDEXING,
    VKD3D_SHADER_SPIRV_EXTENSION_EXT_STENCIL_EXPORT,
    VKD3D_SHADER_SPIRV_EXTENSION_EXT_VIEWPORT_INDEX_LAYER,
    VKD3D_SHADER_SPIRV_EXTENSION_EXT_FRAGMENT_SHADER_INTERLOCK,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SPIRV_EXTENSION),
};
 
/* Extends vkd3d_shader_compile_info. */
struct vkd3d_shader_spirv_target_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;
 
    const char *entry_point; /* "main" if NULL. */
 
    enum vkd3d_shader_spirv_environment environment;
 
    const enum vkd3d_shader_spirv_extension *extensions;
    unsigned int extension_count;
 
    const struct vkd3d_shader_parameter *parameters;
    unsigned int parameter_count;
 
    bool dual_source_blending;
    const unsigned int *output_swizzles;
    unsigned int output_swizzle_count;
};
 
enum vkd3d_shader_tessellator_output_primitive
{
    VKD3D_SHADER_TESSELLATOR_OUTPUT_POINT        = 0x1,
    VKD3D_SHADER_TESSELLATOR_OUTPUT_LINE         = 0x2,
    VKD3D_SHADER_TESSELLATOR_OUTPUT_TRIANGLE_CW  = 0x3,
    VKD3D_SHADER_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 0x4,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_TESSELLATOR_OUTPUT_PRIMITIVE),
};
 
enum vkd3d_shader_tessellator_partitioning
{
    VKD3D_SHADER_TESSELLATOR_PARTITIONING_INTEGER         = 0x1,
    VKD3D_SHADER_TESSELLATOR_PARTITIONING_POW2            = 0x2,
    VKD3D_SHADER_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD  = 0x3,
    VKD3D_SHADER_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 0x4,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_TESSELLATOR_PARTITIONING),
};
 
/* Extends vkd3d_shader_spirv_target_info. */
struct vkd3d_shader_spirv_domain_shader_target_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;
 
    enum vkd3d_shader_tessellator_output_primitive output_primitive;
    enum vkd3d_shader_tessellator_partitioning partitioning;
};

struct vkd3d_shader_macro
{
    const char *name;
    const char *value;
};

typedef int (*PFN_vkd3d_shader_open_include)(const char *filename, bool local,
        const char *parent_data, void *context, struct vkd3d_shader_code *out);
typedef void (*PFN_vkd3d_shader_close_include)(const struct vkd3d_shader_code *code, void *context);

struct vkd3d_shader_preprocess_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    const struct vkd3d_shader_macro *macros;
    unsigned int macro_count;

    PFN_vkd3d_shader_open_include pfn_open_include;
    PFN_vkd3d_shader_close_include pfn_close_include;
    void *include_context;
};

struct vkd3d_shader_hlsl_source_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    const char *entry_point;
    struct vkd3d_shader_code secondary_code;
    const char *profile;
};
 
/* root signature 1.0 */
enum vkd3d_shader_filter
{
    VKD3D_SHADER_FILTER_MIN_MAG_MIP_POINT                          = 0x000,
    VKD3D_SHADER_FILTER_MIN_MAG_POINT_MIP_LINEAR                   = 0x001,
    VKD3D_SHADER_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT             = 0x004,
    VKD3D_SHADER_FILTER_MIN_POINT_MAG_MIP_LINEAR                   = 0x005,
    VKD3D_SHADER_FILTER_MIN_LINEAR_MAG_MIP_POINT                   = 0x010,
    VKD3D_SHADER_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR            = 0x011,
    VKD3D_SHADER_FILTER_MIN_MAG_LINEAR_MIP_POINT                   = 0x014,
    VKD3D_SHADER_FILTER_MIN_MAG_MIP_LINEAR                         = 0x015,
    VKD3D_SHADER_FILTER_ANISOTROPIC                                = 0x055,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_MAG_MIP_POINT               = 0x080,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR        = 0x081,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT  = 0x084,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR        = 0x085,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT        = 0x090,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x091,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT        = 0x094,
    VKD3D_SHADER_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR              = 0x095,
    VKD3D_SHADER_FILTER_COMPARISON_ANISOTROPIC                     = 0x0d5,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_MAG_MIP_POINT                  = 0x100,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR           = 0x101,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT     = 0x104,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR           = 0x105,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT           = 0x110,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR    = 0x111,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT           = 0x114,
    VKD3D_SHADER_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR                 = 0x115,
    VKD3D_SHADER_FILTER_MINIMUM_ANISOTROPIC                        = 0x155,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_MAG_MIP_POINT                  = 0x180,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR           = 0x181,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT     = 0x184,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR           = 0x185,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT           = 0x190,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR    = 0x191,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT           = 0x194,
    VKD3D_SHADER_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR                 = 0x195,
    VKD3D_SHADER_FILTER_MAXIMUM_ANISOTROPIC                        = 0x1d5,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_FILTER),
};
 
enum vkd3d_shader_texture_address_mode
{
    VKD3D_SHADER_TEXTURE_ADDRESS_MODE_WRAP        = 0x1,
    VKD3D_SHADER_TEXTURE_ADDRESS_MODE_MIRROR      = 0x2,
    VKD3D_SHADER_TEXTURE_ADDRESS_MODE_CLAMP       = 0x3,
    VKD3D_SHADER_TEXTURE_ADDRESS_MODE_BORDER      = 0x4,
    VKD3D_SHADER_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 0x5,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_TEXTURE_ADDRESS_MODE),
};
 
enum vkd3d_shader_comparison_func
{
    VKD3D_SHADER_COMPARISON_FUNC_NEVER         = 0x1,
    VKD3D_SHADER_COMPARISON_FUNC_LESS          = 0x2,
    VKD3D_SHADER_COMPARISON_FUNC_EQUAL         = 0x3,
    VKD3D_SHADER_COMPARISON_FUNC_LESS_EQUAL    = 0x4,
    VKD3D_SHADER_COMPARISON_FUNC_GREATER       = 0x5,
    VKD3D_SHADER_COMPARISON_FUNC_NOT_EQUAL     = 0x6,
    VKD3D_SHADER_COMPARISON_FUNC_GREATER_EQUAL = 0x7,
    VKD3D_SHADER_COMPARISON_FUNC_ALWAYS        = 0x8,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPARISON_FUNC),
};
 
enum vkd3d_shader_static_border_colour
{
    VKD3D_SHADER_STATIC_BORDER_COLOUR_TRANSPARENT_BLACK = 0x0,
    VKD3D_SHADER_STATIC_BORDER_COLOUR_OPAQUE_BLACK      = 0x1,
    VKD3D_SHADER_STATIC_BORDER_COLOUR_OPAQUE_WHITE      = 0x2,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_STATIC_BORDER_COLOUR),
};
 
struct vkd3d_shader_static_sampler_desc
{
    enum vkd3d_shader_filter filter;
    enum vkd3d_shader_texture_address_mode address_u;
    enum vkd3d_shader_texture_address_mode address_v;
    enum vkd3d_shader_texture_address_mode address_w;
    float mip_lod_bias;
    unsigned int max_anisotropy;
    enum vkd3d_shader_comparison_func comparison_func;
    enum vkd3d_shader_static_border_colour border_colour;
    float min_lod;
    float max_lod;
    unsigned int shader_register;
    unsigned int register_space;
    enum vkd3d_shader_visibility shader_visibility;
};
 
struct vkd3d_shader_descriptor_range
{
    enum vkd3d_shader_descriptor_type range_type;
    unsigned int descriptor_count;
    unsigned int base_shader_register;
    unsigned int register_space;
    unsigned int descriptor_table_offset;
};
 
struct vkd3d_shader_root_descriptor_table
{
    unsigned int descriptor_range_count;
    const struct vkd3d_shader_descriptor_range *descriptor_ranges;
};
 
struct vkd3d_shader_root_constants
{
    unsigned int shader_register;
    unsigned int register_space;
    unsigned int value_count;
};
 
struct vkd3d_shader_root_descriptor
{
    unsigned int shader_register;
    unsigned int register_space;
};
 
enum vkd3d_shader_root_parameter_type
{
    VKD3D_SHADER_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = 0x0,
    VKD3D_SHADER_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS  = 0x1,
    VKD3D_SHADER_ROOT_PARAMETER_TYPE_CBV              = 0x2,
    VKD3D_SHADER_ROOT_PARAMETER_TYPE_SRV              = 0x3,
    VKD3D_SHADER_ROOT_PARAMETER_TYPE_UAV              = 0x4,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_ROOT_PARAMETER_TYPE),
};
 
struct vkd3d_shader_root_parameter
{
    enum vkd3d_shader_root_parameter_type parameter_type;
    union
    {
        struct vkd3d_shader_root_descriptor_table descriptor_table;
        struct vkd3d_shader_root_constants constants;
        struct vkd3d_shader_root_descriptor descriptor;
    } u;
    enum vkd3d_shader_visibility shader_visibility;
};
 
enum vkd3d_shader_root_signature_flags
{
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_NONE                               = 0x00,
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 0x01,
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS     = 0x02,
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS       = 0x04,
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS     = 0x08,
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS   = 0x10,
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS      = 0x20,
    VKD3D_SHADER_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT                = 0x40,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_ROOT_SIGNATURE_FLAGS),
};
 
struct vkd3d_shader_root_signature_desc
{
    unsigned int parameter_count;
    const struct vkd3d_shader_root_parameter *parameters;
    unsigned int static_sampler_count;
    const struct vkd3d_shader_static_sampler_desc *static_samplers;
    enum vkd3d_shader_root_signature_flags flags;
};
 
/* root signature 1.1 */
enum vkd3d_shader_root_descriptor_flags
{
    VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_NONE                             = 0x0,
    VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE                    = 0x2,
    VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4,
    VKD3D_SHADER_ROOT_DESCRIPTOR_FLAG_DATA_STATIC                      = 0x8,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_ROOT_DESCRIPTOR_FLAGS),
};
 
enum vkd3d_shader_descriptor_range_flags
{
    VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_NONE                             = 0x0,
    VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE             = 0x1,
    VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE                    = 0x2,
    VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4,
    VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DATA_STATIC                      = 0x8,
    VKD3D_SHADER_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 0x10000,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_DESCRIPTOR_RANGE_FLAGS),
};
 
struct vkd3d_shader_descriptor_range1
{
    enum vkd3d_shader_descriptor_type range_type;
    unsigned int descriptor_count;
    unsigned int base_shader_register;
    unsigned int register_space;
    enum vkd3d_shader_descriptor_range_flags flags;
    unsigned int descriptor_table_offset;
};
 
struct vkd3d_shader_root_descriptor_table1
{
    unsigned int descriptor_range_count;
    const struct vkd3d_shader_descriptor_range1 *descriptor_ranges;
};
 
struct vkd3d_shader_root_descriptor1
{
    unsigned int shader_register;
    unsigned int register_space;
    enum vkd3d_shader_root_descriptor_flags flags;
};
 
struct vkd3d_shader_root_parameter1
{
    enum vkd3d_shader_root_parameter_type parameter_type;
    union
    {
        struct vkd3d_shader_root_descriptor_table1 descriptor_table;
        struct vkd3d_shader_root_constants constants;
        struct vkd3d_shader_root_descriptor1 descriptor;
    } u;
    enum vkd3d_shader_visibility shader_visibility;
};
 
struct vkd3d_shader_root_signature_desc1
{
    unsigned int parameter_count;
    const struct vkd3d_shader_root_parameter1 *parameters;
    unsigned int static_sampler_count;
    const struct vkd3d_shader_static_sampler_desc *static_samplers;
    enum vkd3d_shader_root_signature_flags flags;
};
 
enum vkd3d_shader_root_signature_version
{
    VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0 = 0x1,
    VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_1 = 0x2,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_ROOT_SIGNATURE_VERSION),
};
 
struct vkd3d_shader_versioned_root_signature_desc
{
    enum vkd3d_shader_root_signature_version version;
    union
    {
        struct vkd3d_shader_root_signature_desc v_1_0;
        struct vkd3d_shader_root_signature_desc1 v_1_1;
    } u;
};

enum vkd3d_shader_resource_type
{
    VKD3D_SHADER_RESOURCE_NONE              = 0x0,
    VKD3D_SHADER_RESOURCE_BUFFER            = 0x1,
    VKD3D_SHADER_RESOURCE_TEXTURE_1D        = 0x2,
    VKD3D_SHADER_RESOURCE_TEXTURE_2D        = 0x3,
    VKD3D_SHADER_RESOURCE_TEXTURE_2DMS      = 0x4,
    VKD3D_SHADER_RESOURCE_TEXTURE_3D        = 0x5,
    VKD3D_SHADER_RESOURCE_TEXTURE_CUBE      = 0x6,
    VKD3D_SHADER_RESOURCE_TEXTURE_1DARRAY   = 0x7,
    VKD3D_SHADER_RESOURCE_TEXTURE_2DARRAY   = 0x8,
    VKD3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY = 0x9,
    VKD3D_SHADER_RESOURCE_TEXTURE_CUBEARRAY = 0xa,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_RESOURCE_TYPE),
};

enum vkd3d_shader_resource_data_type
{
    VKD3D_SHADER_RESOURCE_DATA_NONE      = 0x0,
    VKD3D_SHADER_RESOURCE_DATA_UNORM     = 0x1,
    VKD3D_SHADER_RESOURCE_DATA_SNORM     = 0x2,
    VKD3D_SHADER_RESOURCE_DATA_INT       = 0x3,
    VKD3D_SHADER_RESOURCE_DATA_UINT      = 0x4,
    VKD3D_SHADER_RESOURCE_DATA_FLOAT     = 0x5,
    VKD3D_SHADER_RESOURCE_DATA_MIXED     = 0x6,
    VKD3D_SHADER_RESOURCE_DATA_DOUBLE    = 0x7,
    VKD3D_SHADER_RESOURCE_DATA_CONTINUED = 0x8,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_RESOURCE_DATA_TYPE),
};

enum vkd3d_shader_descriptor_info_flag
{
    VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_COUNTER             = 0x00000001,
    VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_READ                = 0x00000002,
    VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_SAMPLER_COMPARISON_MODE = 0x00000004,
    VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_ATOMICS             = 0x00000008,
    VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_RAW_BUFFER              = 0x00000010,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_DESCRIPTOR_INFO_FLAG),
};

struct vkd3d_shader_descriptor_info
{
    enum vkd3d_shader_descriptor_type type;
    unsigned int register_space;
    unsigned int register_index;
    enum vkd3d_shader_resource_type resource_type;
    enum vkd3d_shader_resource_data_type resource_data_type;
    unsigned int flags;
    unsigned int count;
};

struct vkd3d_shader_scan_descriptor_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    struct vkd3d_shader_descriptor_info *descriptors;
    unsigned int descriptor_count;
};

struct vkd3d_shader_combined_resource_sampler_info
{
    unsigned int resource_space;
    unsigned int resource_index;
    unsigned int sampler_space;
    unsigned int sampler_index;
};

struct vkd3d_shader_scan_combined_resource_sampler_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    struct vkd3d_shader_combined_resource_sampler_info *combined_samplers;
    unsigned int combined_sampler_count;
};

struct vkd3d_shader_scan_hull_shader_tessellation_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    enum vkd3d_shader_tessellator_output_primitive output_primitive;
    enum vkd3d_shader_tessellator_partitioning partitioning;
};

struct vkd3d_shader_scan_thread_group_size_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    unsigned int x, y, z;
};

struct vkd3d_shader_d3dbc_source_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    enum vkd3d_shader_resource_type texture_dimensions[6];

    uint32_t shadow_samplers;
};

enum vkd3d_shader_component_type
{
    VKD3D_SHADER_COMPONENT_VOID     = 0x0,
    VKD3D_SHADER_COMPONENT_UINT     = 0x1,
    VKD3D_SHADER_COMPONENT_INT      = 0x2,
    VKD3D_SHADER_COMPONENT_FLOAT    = 0x3,
    VKD3D_SHADER_COMPONENT_BOOL     = 0x4,
    VKD3D_SHADER_COMPONENT_DOUBLE   = 0x5,
    VKD3D_SHADER_COMPONENT_UINT64   = 0x6,
    VKD3D_SHADER_COMPONENT_INT64    = 0x7,
    VKD3D_SHADER_COMPONENT_FLOAT16  = 0x8,
    VKD3D_SHADER_COMPONENT_UINT16   = 0x9,
    VKD3D_SHADER_COMPONENT_INT16    = 0xa,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPONENT_TYPE),
};

enum vkd3d_shader_sysval_semantic
{
    VKD3D_SHADER_SV_NONE                      = 0x00,
    VKD3D_SHADER_SV_POSITION                  = 0x01,
    VKD3D_SHADER_SV_CLIP_DISTANCE             = 0x02,
    VKD3D_SHADER_SV_CULL_DISTANCE             = 0x03,
    VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX = 0x04,
    VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX      = 0x05,
    VKD3D_SHADER_SV_VERTEX_ID                 = 0x06,
    VKD3D_SHADER_SV_PRIMITIVE_ID              = 0x07,
    VKD3D_SHADER_SV_INSTANCE_ID               = 0x08,
    VKD3D_SHADER_SV_IS_FRONT_FACE             = 0x09,
    VKD3D_SHADER_SV_SAMPLE_INDEX              = 0x0a,
    VKD3D_SHADER_SV_TESS_FACTOR_QUADEDGE      = 0x0b,
    VKD3D_SHADER_SV_TESS_FACTOR_QUADINT       = 0x0c,
    VKD3D_SHADER_SV_TESS_FACTOR_TRIEDGE       = 0x0d,
    VKD3D_SHADER_SV_TESS_FACTOR_TRIINT        = 0x0e,
    VKD3D_SHADER_SV_TESS_FACTOR_LINEDET       = 0x0f,
    VKD3D_SHADER_SV_TESS_FACTOR_LINEDEN       = 0x10,
    VKD3D_SHADER_SV_TARGET                    = 0x40,
    VKD3D_SHADER_SV_DEPTH                     = 0x41,
    VKD3D_SHADER_SV_COVERAGE                  = 0x42,
    VKD3D_SHADER_SV_DEPTH_GREATER_EQUAL       = 0x43,
    VKD3D_SHADER_SV_DEPTH_LESS_EQUAL          = 0x44,
    VKD3D_SHADER_SV_STENCIL_REF               = 0x45,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SYSVAL_SEMANTIC),
};

enum vkd3d_shader_minimum_precision
{
    VKD3D_SHADER_MINIMUM_PRECISION_NONE      = 0,
    VKD3D_SHADER_MINIMUM_PRECISION_FLOAT_16  = 1,
    VKD3D_SHADER_MINIMUM_PRECISION_FIXED_8_2 = 2,
    VKD3D_SHADER_MINIMUM_PRECISION_INT_16    = 4,
    VKD3D_SHADER_MINIMUM_PRECISION_UINT_16   = 5,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_MINIMUM_PRECISION),
};

struct vkd3d_shader_signature_element
{
    const char *semantic_name;
    unsigned int semantic_index;
    unsigned int stream_index;
    enum vkd3d_shader_sysval_semantic sysval_semantic;
    enum vkd3d_shader_component_type component_type;
    unsigned int register_index;
    unsigned int mask;
    unsigned int used_mask;
    enum vkd3d_shader_minimum_precision min_precision;
};

struct vkd3d_shader_signature
{
    struct vkd3d_shader_signature_element *elements;
    unsigned int element_count;
};

enum vkd3d_shader_swizzle_component
{
    VKD3D_SHADER_SWIZZLE_X = 0x0,
    VKD3D_SHADER_SWIZZLE_Y = 0x1,
    VKD3D_SHADER_SWIZZLE_Z = 0x2,
    VKD3D_SHADER_SWIZZLE_W = 0x3,
 
    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SWIZZLE_COMPONENT),
};

struct vkd3d_shader_dxbc_section_desc
{
    uint32_t tag;
    struct vkd3d_shader_code data;
};

struct vkd3d_shader_dxbc_desc
{
    uint32_t tag;
    uint32_t checksum[4];
    unsigned int version;
    size_t size;
    size_t section_count;
    struct vkd3d_shader_dxbc_section_desc *sections;
};

#define VKD3D_SHADER_SWIZZLE_MASK (0xffu)
#define VKD3D_SHADER_SWIZZLE_SHIFT(idx) (8u * (idx))

#define VKD3D_SHADER_SWIZZLE(x, y, z, w) \
        (VKD3D_SHADER_SWIZZLE_ ## x << VKD3D_SHADER_SWIZZLE_SHIFT(0) \
                | VKD3D_SHADER_SWIZZLE_ ## y << VKD3D_SHADER_SWIZZLE_SHIFT(1) \
                | VKD3D_SHADER_SWIZZLE_ ## z << VKD3D_SHADER_SWIZZLE_SHIFT(2) \
                | VKD3D_SHADER_SWIZZLE_ ## w << VKD3D_SHADER_SWIZZLE_SHIFT(3))

#define VKD3D_SHADER_NO_SWIZZLE VKD3D_SHADER_SWIZZLE(X, Y, Z, W)

static inline uint32_t vkd3d_shader_create_swizzle(enum vkd3d_shader_swizzle_component x,
        enum vkd3d_shader_swizzle_component y, enum vkd3d_shader_swizzle_component z,
        enum vkd3d_shader_swizzle_component w)
{
    return ((x & VKD3D_SHADER_SWIZZLE_MASK) << VKD3D_SHADER_SWIZZLE_SHIFT(0))
            | ((y & VKD3D_SHADER_SWIZZLE_MASK) << VKD3D_SHADER_SWIZZLE_SHIFT(1))
            | ((z & VKD3D_SHADER_SWIZZLE_MASK) << VKD3D_SHADER_SWIZZLE_SHIFT(2))
            | ((w & VKD3D_SHADER_SWIZZLE_MASK) << VKD3D_SHADER_SWIZZLE_SHIFT(3));
}

struct vkd3d_shader_scan_signature_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    struct vkd3d_shader_signature input;

    struct vkd3d_shader_signature output;

    struct vkd3d_shader_signature patch_constant;
};

struct vkd3d_shader_varying_map
{
    unsigned int output_signature_index;
    unsigned int input_register_index;
    unsigned int input_mask;
};

struct vkd3d_shader_varying_map_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    const struct vkd3d_shader_varying_map *varying_map;
    unsigned int varying_count;
};

struct vkd3d_shader_parameter_info
{
    enum vkd3d_shader_structure_type type;
    const void *next;

    const struct vkd3d_shader_parameter1 *parameters;
    unsigned int parameter_count;
};
 
#ifdef LIBVKD3D_SHADER_SOURCE
# define VKD3D_SHADER_API VKD3D_EXPORT
#else
# define VKD3D_SHADER_API VKD3D_IMPORT
#endif
 
#ifndef VKD3D_SHADER_NO_PROTOTYPES

VKD3D_SHADER_API const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor);
VKD3D_SHADER_API const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count);
VKD3D_SHADER_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types(
        enum vkd3d_shader_source_type source_type, unsigned int *count);

VKD3D_SHADER_API int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info,
        struct vkd3d_shader_code *out, char **messages);
VKD3D_SHADER_API void vkd3d_shader_free_messages(char *messages);
VKD3D_SHADER_API void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);

VKD3D_SHADER_API int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
        struct vkd3d_shader_versioned_root_signature_desc *root_signature, char **messages);
VKD3D_SHADER_API void vkd3d_shader_free_root_signature(
        struct vkd3d_shader_versioned_root_signature_desc *root_signature);

VKD3D_SHADER_API int vkd3d_shader_serialize_root_signature(
        const struct vkd3d_shader_versioned_root_signature_desc *root_signature,
        struct vkd3d_shader_code *dxbc, char **messages);
VKD3D_SHADER_API int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst,
        enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src);

VKD3D_SHADER_API int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages);
VKD3D_SHADER_API void vkd3d_shader_free_scan_descriptor_info(
        struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info);

VKD3D_SHADER_API int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
        struct vkd3d_shader_signature *signature, char **messages);
VKD3D_SHADER_API struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
        const struct vkd3d_shader_signature *signature, const char *semantic_name,
        unsigned int semantic_index, unsigned int stream_index);
VKD3D_SHADER_API void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature);
 
/* 1.3 */

VKD3D_SHADER_API int vkd3d_shader_preprocess(const struct vkd3d_shader_compile_info *compile_info,
        struct vkd3d_shader_code *out, char **messages);

VKD3D_SHADER_API void vkd3d_shader_set_log_callback(PFN_vkd3d_log callback);

VKD3D_SHADER_API void vkd3d_shader_free_dxbc(struct vkd3d_shader_dxbc_desc *dxbc);

VKD3D_SHADER_API int vkd3d_shader_parse_dxbc(const struct vkd3d_shader_code *dxbc,
        uint32_t flags, struct vkd3d_shader_dxbc_desc *desc, char **messages);

VKD3D_SHADER_API int vkd3d_shader_serialize_dxbc(size_t section_count,
        const struct vkd3d_shader_dxbc_section_desc *sections, struct vkd3d_shader_code *dxbc, char **messages);

VKD3D_SHADER_API void vkd3d_shader_free_scan_signature_info(struct vkd3d_shader_scan_signature_info *info);

VKD3D_SHADER_API void vkd3d_shader_build_varying_map(const struct vkd3d_shader_signature *output_signature,
        const struct vkd3d_shader_signature *input_signature,
        unsigned int *count, struct vkd3d_shader_varying_map *varyings);

VKD3D_SHADER_API void vkd3d_shader_free_scan_combined_resource_sampler_info(
        struct vkd3d_shader_scan_combined_resource_sampler_info *info);
 
#endif  /* VKD3D_SHADER_NO_PROTOTYPES */

typedef const char *(*PFN_vkd3d_shader_get_version)(unsigned int *major, unsigned int *minor);
typedef const enum vkd3d_shader_source_type *(*PFN_vkd3d_shader_get_supported_source_types)(unsigned int *count);
typedef const enum vkd3d_shader_target_type *(*PFN_vkd3d_shader_get_supported_target_types)(
        enum vkd3d_shader_source_type source_type, unsigned int *count);

typedef int (*PFN_vkd3d_shader_compile)(const struct vkd3d_shader_compile_info *compile_info,
        struct vkd3d_shader_code *out, char **messages);
typedef void (*PFN_vkd3d_shader_free_messages)(char *messages);
typedef void (*PFN_vkd3d_shader_free_shader_code)(struct vkd3d_shader_code *code);

typedef int (*PFN_vkd3d_shader_parse_root_signature)(const struct vkd3d_shader_code *dxbc,
        struct vkd3d_shader_versioned_root_signature_desc *root_signature, char **messages);
typedef void (*PFN_vkd3d_shader_free_root_signature)(struct vkd3d_shader_versioned_root_signature_desc *root_signature);

typedef int (*PFN_vkd3d_shader_serialize_root_signature)(
        const struct vkd3d_shader_versioned_root_signature_desc *root_signature,
        struct vkd3d_shader_code *dxbc, char **messages);

typedef int (*PFN_vkd3d_shader_convert_root_signature)(struct vkd3d_shader_versioned_root_signature_desc *dst,
        enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src);

typedef int (*PFN_vkd3d_shader_scan)(const struct vkd3d_shader_compile_info *compile_info, char **messages);
typedef void (*PFN_vkd3d_shader_free_scan_descriptor_info)(
        struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info);

typedef int (*PFN_vkd3d_shader_parse_input_signature)(const struct vkd3d_shader_code *dxbc,
        struct vkd3d_shader_signature *signature, char **messages);
typedef struct vkd3d_shader_signature_element * (*PFN_vkd3d_shader_find_signature_element)(
        const struct vkd3d_shader_signature *signature, const char *semantic_name,
        unsigned int semantic_index, unsigned int stream_index);
typedef void (*PFN_vkd3d_shader_free_shader_signature)(struct vkd3d_shader_signature *signature);

typedef void (*PFN_vkd3d_shader_preprocess)(struct vkd3d_shader_compile_info *compile_info,
        struct vkd3d_shader_code *out, char **messages);

typedef void (*PFN_vkd3d_shader_set_log_callback)(PFN_vkd3d_log callback);

typedef void (*PFN_vkd3d_shader_free_dxbc)(struct vkd3d_shader_dxbc_desc *dxbc);
typedef int (*PFN_vkd3d_shader_parse_dxbc)(const struct vkd3d_shader_code *dxbc,
        uint32_t flags, struct vkd3d_shader_dxbc_desc *desc, char **messages);
typedef int (*PFN_vkd3d_shader_serialize_dxbc)(size_t section_count,
        const struct vkd3d_shader_dxbc_section_desc *sections, struct vkd3d_shader_code *dxbc, char **messages);

typedef void (*PFN_vkd3d_shader_build_varying_map)(const struct vkd3d_shader_signature *output_signature,
        const struct vkd3d_shader_signature *input_signature,
        unsigned int *count, struct vkd3d_shader_varying_map *varyings);
typedef void (*PFN_vkd3d_shader_free_scan_signature_info)(struct vkd3d_shader_scan_signature_info *info);

typedef void (*PFN_vkd3d_shader_free_scan_combined_resource_sampler_info)(
        struct vkd3d_shader_scan_combined_resource_sampler_info *info);
 
#ifdef __cplusplus
}
#endif  /* __cplusplus */
 
#endif  /* __VKD3D_SHADER_H */