dlls/wined3d/shader_spirv.c

   1 /*
   2  * Copyright 2018 Henri Verbeet for CodeWeavers
   3  * Copyright 2019 Józef Kucia for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "wined3d_private.h"
  21 #include "wined3d_vk.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  24
  25 static const struct wined3d_shader_backend_ops spirv_shader_backend_vk;
  26
  27 static const struct vkd3d_shader_compile_option spirv_compile_options[] =
  28 {
  29     {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_7},
  30     {VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE, 0},
  31 };
  32
  33 struct shader_spirv_resource_bindings
  34 {
  35     struct vkd3d_shader_resource_binding *bindings;
  36     SIZE_T bindings_size, binding_count;
  37
  38     struct vkd3d_shader_uav_counter_binding uav_counters[MAX_UNORDERED_ACCESS_VIEWS];
  39     SIZE_T uav_counter_count;
  40
  41     VkDescriptorSetLayoutBinding *vk_bindings;
  42     SIZE_T vk_bindings_size, vk_binding_count;
  43
  44     size_t binding_base[WINED3D_SHADER_TYPE_COUNT];
  45     enum wined3d_shader_type so_stage;
  46 };
  47
  48 struct shader_spirv_priv
  49 {
  50     const struct wined3d_vertex_pipe_ops *vertex_pipe;
  51     const struct wined3d_fragment_pipe_ops *fragment_pipe;
  52     bool ffp_proj_control;
  53
  54     struct shader_spirv_resource_bindings bindings;
  55 };
  56
  57 struct shader_spirv_compile_arguments
  58 {
  59     union
  60     {
  61         struct
  62         {
  63             uint32_t alpha_swizzle;
  64             unsigned int sample_count;
  65             bool dual_source_blending;
  66         } fs;
  67     } u;
  68 };
  69
  70 struct shader_spirv_graphics_program_variant_vk
  71 {
  72     struct shader_spirv_compile_arguments compile_args;
  73     const struct wined3d_stream_output_desc *so_desc;
  74     size_t binding_base;
  75
  76     VkShaderModule vk_module;
  77 };
  78
  79 struct shader_spirv_graphics_program_vk
  80 {
  81     struct shader_spirv_graphics_program_variant_vk *variants;
  82     SIZE_T variants_size, variant_count;
  83
  84     struct vkd3d_shader_scan_descriptor_info descriptor_info;
  85 };
  86
  87 struct shader_spirv_compute_program_vk
  88 {
  89     VkShaderModule vk_module;
  90     VkPipeline vk_pipeline;
  91     VkPipelineLayout vk_pipeline_layout;
  92     VkDescriptorSetLayout vk_set_layout;
  93
  94     struct vkd3d_shader_scan_descriptor_info descriptor_info;
  95 };
  96
  97 struct wined3d_shader_spirv_compile_args
  98 {
  99     struct vkd3d_shader_spirv_target_info spirv_target;
 100     struct vkd3d_shader_parameter sample_count;
 101     unsigned int ps_alpha_swizzle[WINED3D_MAX_RENDER_TARGETS];
 102 };
 103
 104 struct wined3d_shader_spirv_shader_interface
 105 {
 106     struct vkd3d_shader_interface_info vkd3d_interface;
 107     struct vkd3d_shader_transform_feedback_info xfb_info;
 108 };
 109
 110 static enum vkd3d_shader_visibility vkd3d_shader_visibility_from_wined3d(enum wined3d_shader_type shader_type)
 111 {
 112     switch (shader_type)
 113     {
 114         case WINED3D_SHADER_TYPE_VERTEX:
 115             return VKD3D_SHADER_VISIBILITY_VERTEX;
 116         case WINED3D_SHADER_TYPE_HULL:
 117             return VKD3D_SHADER_VISIBILITY_HULL;
 118         case WINED3D_SHADER_TYPE_DOMAIN:
 119             return VKD3D_SHADER_VISIBILITY_DOMAIN;
 120         case WINED3D_SHADER_TYPE_GEOMETRY:
 121             return VKD3D_SHADER_VISIBILITY_GEOMETRY;
 122         case WINED3D_SHADER_TYPE_PIXEL:
 123             return VKD3D_SHADER_VISIBILITY_PIXEL;
 124         case WINED3D_SHADER_TYPE_COMPUTE:
 125             return VKD3D_SHADER_VISIBILITY_COMPUTE;
 126         default:
 127             ERR("Invalid shader type %s.\n", debug_shader_type(shader_type));
 128             return VKD3D_SHADER_VISIBILITY_ALL;
 129     }
 130 }
 131
 132 static void shader_spirv_handle_instruction(const struct wined3d_shader_instruction *ins)
 133 {
 134 }
 135
 136 static void shader_spirv_compile_arguments_init(struct shader_spirv_compile_arguments *args,
 137         const struct wined3d_context *context, const struct wined3d_shader *shader,
 138         const struct wined3d_state *state, unsigned int sample_count)
 139 {
 140     struct wined3d_rendertarget_view *rtv;
 141     unsigned int i;
 142
 143     memset(args, 0, sizeof(*args));
 144
 145     switch (shader->reg_maps.shader_version.type)
 146     {
 147         case WINED3D_SHADER_TYPE_PIXEL:
 148             for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i)
 149             {
 150                 if (!(rtv = state->fb.render_targets[i]) || rtv->format->id == WINED3DFMT_NULL)
 151                     continue;
 152                 if (rtv->format->id == WINED3DFMT_A8_UNORM && !is_identity_fixup(rtv->format->color_fixup))
 153                     args->u.fs.alpha_swizzle |= 1u << i;
 154             }
 155             args->u.fs.sample_count = sample_count;
 156             args->u.fs.dual_source_blending = state->blend_state && state->blend_state->dual_source;
 157             break;
 158
 159         default:
 160             break;
 161     }
 162 }
 163
 164 static void shader_spirv_init_compile_args(struct wined3d_shader_spirv_compile_args *args,
 165         struct vkd3d_shader_interface_info *vkd3d_interface, enum vkd3d_shader_spirv_environment environment,
 166         enum wined3d_shader_type shader_type, const struct shader_spirv_compile_arguments *compile_args)
 167 {
 168     unsigned int i;
 169
 170     memset(args, 0, sizeof(*args));
 171     args->spirv_target.type = VKD3D_SHADER_STRUCTURE_TYPE_SPIRV_TARGET_INFO;
 172     args->spirv_target.next = vkd3d_interface;
 173     args->spirv_target.entry_point = "main";
 174     args->spirv_target.environment = environment;
 175
 176     if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
 177     {
 178         unsigned int rt_alpha_swizzle = compile_args->u.fs.alpha_swizzle;
 179         struct vkd3d_shader_parameter *shader_parameter;
 180
 181         shader_parameter = &args->sample_count;
 182         shader_parameter->name = VKD3D_SHADER_PARAMETER_NAME_RASTERIZER_SAMPLE_COUNT;
 183         shader_parameter->type = VKD3D_SHADER_PARAMETER_TYPE_IMMEDIATE_CONSTANT;
 184         shader_parameter->data_type = VKD3D_SHADER_PARAMETER_DATA_TYPE_UINT32;
 185         shader_parameter->u.immediate_constant.u.u32 = compile_args->u.fs.sample_count;
 186
 187         args->spirv_target.dual_source_blending = compile_args->u.fs.dual_source_blending;
 188
 189         args->spirv_target.parameter_count = 1;
 190         args->spirv_target.parameters = shader_parameter;
 191
 192         for (i = 0; i < ARRAY_SIZE(args->ps_alpha_swizzle); ++i)
 193         {
 194             if (rt_alpha_swizzle && (1u << i))
 195                 args->ps_alpha_swizzle[i] = VKD3D_SHADER_SWIZZLE(W, X, Y, Z);
 196             else
 197                 args->ps_alpha_swizzle[i] = VKD3D_SHADER_NO_SWIZZLE;
 198         }
 199
 200         args->spirv_target.output_swizzles = args->ps_alpha_swizzle;
 201         args->spirv_target.output_swizzle_count = ARRAY_SIZE(args->ps_alpha_swizzle);
 202     }
 203 }
 204
 205 static void shader_spirv_init_shader_interface_vk(struct wined3d_shader_spirv_shader_interface *iface,
 206         const struct shader_spirv_resource_bindings *b, const struct wined3d_stream_output_desc *so_desc)
 207 {
 208     memset(iface, 0, sizeof(*iface));
 209     iface->vkd3d_interface.type = VKD3D_SHADER_STRUCTURE_TYPE_INTERFACE_INFO;
 210
 211     if (so_desc)
 212     {
 213         iface->xfb_info.type = VKD3D_SHADER_STRUCTURE_TYPE_TRANSFORM_FEEDBACK_INFO;
 214         iface->xfb_info.next = NULL;
 215
 216         iface->xfb_info.elements = (const struct vkd3d_shader_transform_feedback_element *)so_desc->elements;
 217         iface->xfb_info.element_count = so_desc->element_count;
 218         iface->xfb_info.buffer_strides = so_desc->buffer_strides;
 219         iface->xfb_info.buffer_stride_count = so_desc->buffer_stride_count;
 220
 221         iface->vkd3d_interface.next = &iface->xfb_info;
 222     }
 223
 224     iface->vkd3d_interface.bindings = b->bindings;
 225     iface->vkd3d_interface.binding_count = b->binding_count;
 226
 227     iface->vkd3d_interface.uav_counters = b->uav_counters;
 228     iface->vkd3d_interface.uav_counter_count = b->uav_counter_count;
 229 }
 230
 231 static VkShaderModule shader_spirv_compile_shader(struct wined3d_context_vk *context_vk,
 232         const struct wined3d_shader_desc *shader_desc, enum wined3d_shader_type shader_type,
 233         const struct shader_spirv_compile_arguments *args, const struct shader_spirv_resource_bindings *bindings,
 234         const struct wined3d_stream_output_desc *so_desc)
 235 {
 236     struct wined3d_shader_spirv_compile_args compile_args;
 237     struct wined3d_shader_spirv_shader_interface iface;
 238     VkShaderModuleCreateInfo shader_create_info;
 239     struct vkd3d_shader_compile_info info;
 240     const struct wined3d_vk_info *vk_info;
 241     struct wined3d_device_vk *device_vk;
 242     struct vkd3d_shader_code spirv;
 243     VkShaderModule module;
 244     char *messages;
 245     VkResult vr;
 246     int ret;
 247
 248     shader_spirv_init_shader_interface_vk(&iface, bindings, so_desc);
 249     shader_spirv_init_compile_args(&compile_args, &iface.vkd3d_interface,
 250             VKD3D_SHADER_SPIRV_ENVIRONMENT_VULKAN_1_0, shader_type, args);
 251
 252     info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO;
 253     info.next = &compile_args.spirv_target;
 254     info.source.code = shader_desc->byte_code;
 255     info.source.size = shader_desc->byte_code_size;
 256     info.source_type = VKD3D_SHADER_SOURCE_DXBC_TPF;
 257     info.target_type = VKD3D_SHADER_TARGET_SPIRV_BINARY;
 258     info.options = spirv_compile_options;
 259     info.option_count = ARRAY_SIZE(spirv_compile_options);
 260     info.log_level = VKD3D_SHADER_LOG_WARNING;
 261     info.source_name = NULL;
 262
 263     ret = vkd3d_shader_compile(&info, &spirv, &messages);
 264     if (messages && *messages && FIXME_ON(d3d_shader))
 265     {
 266         const char *ptr, *end, *line;
 267
 268         FIXME("Shader log:\n");
 269         ptr = messages;
 270         end = ptr + strlen(ptr);
 271         while ((line = wined3d_get_line(&ptr, end)))
 272         {
 273             FIXME("    %.*s", (int)(ptr - line), line);
 274         }
 275         FIXME("\n");
 276     }
 277     vkd3d_shader_free_messages(messages);
 278
 279     if (ret < 0)
 280     {
 281         ERR("Failed to compile DXBC, ret %d.\n", ret);
 282         return VK_NULL_HANDLE;
 283     }
 284
 285     device_vk = wined3d_device_vk(context_vk->c.device);
 286     vk_info = &device_vk->vk_info;
 287
 288     shader_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
 289     shader_create_info.pNext = NULL;
 290     shader_create_info.flags = 0;
 291     shader_create_info.codeSize = spirv.size;
 292     shader_create_info.pCode = spirv.code;
 293     if ((vr = VK_CALL(vkCreateShaderModule(device_vk->vk_device, &shader_create_info, NULL, &module))) < 0)
 294     {
 295         vkd3d_shader_free_shader_code(&spirv);
 296         WARN("Failed to create Vulkan shader module, vr %s.\n", wined3d_debug_vkresult(vr));
 297         return VK_NULL_HANDLE;
 298     }
 299
 300     vkd3d_shader_free_shader_code(&spirv);
 301
 302     return module;
 303 }
 304
 305 static struct shader_spirv_graphics_program_variant_vk *shader_spirv_find_graphics_program_variant_vk(
 306         struct shader_spirv_priv *priv, struct wined3d_context_vk *context_vk, struct wined3d_shader *shader,
 307         const struct wined3d_state *state, const struct shader_spirv_resource_bindings *bindings)
 308 {
 309     enum wined3d_shader_type shader_type = shader->reg_maps.shader_version.type;
 310     struct shader_spirv_graphics_program_variant_vk *variant_vk;
 311     size_t binding_base = bindings->binding_base[shader_type];
 312     const struct wined3d_stream_output_desc *so_desc = NULL;
 313     struct shader_spirv_graphics_program_vk *program_vk;
 314     struct shader_spirv_compile_arguments args;
 315     struct wined3d_shader_desc shader_desc;
 316     size_t variant_count, i;
 317
 318     shader_spirv_compile_arguments_init(&args, &context_vk->c, shader, state, context_vk->sample_count);
 319     if (bindings->so_stage == shader_type)
 320         so_desc = state->shader[WINED3D_SHADER_TYPE_GEOMETRY]->u.gs.so_desc;
 321
 322     if (!(program_vk = shader->backend_data))
 323         return NULL;
 324
 325     variant_count = program_vk->variant_count;
 326     for (i = 0; i < variant_count; ++i)
 327     {
 328         variant_vk = &program_vk->variants[i];
 329         if (variant_vk->so_desc == so_desc && variant_vk->binding_base == binding_base
 330                 && !memcmp(&variant_vk->compile_args, &args, sizeof(args)))
 331             return variant_vk;
 332     }
 333
 334     if (!wined3d_array_reserve((void **)&program_vk->variants, &program_vk->variants_size,
 335             variant_count + 1, sizeof(*program_vk->variants)))
 336         return NULL;
 337
 338     variant_vk = &program_vk->variants[variant_count];
 339     variant_vk->compile_args = args;
 340     variant_vk->binding_base = binding_base;
 341
 342     shader_desc.byte_code = shader->byte_code;
 343     shader_desc.byte_code_size = shader->byte_code_size;
 344
 345     if (!(variant_vk->vk_module = shader_spirv_compile_shader(context_vk, &shader_desc, shader_type, &args,
 346             bindings, so_desc)))
 347         return NULL;
 348     ++program_vk->variant_count;
 349
 350     return variant_vk;
 351 }
 352
 353 static struct shader_spirv_compute_program_vk *shader_spirv_find_compute_program_vk(struct shader_spirv_priv *priv,
 354         struct wined3d_context_vk *context_vk, struct wined3d_shader *shader,
 355         const struct shader_spirv_resource_bindings *bindings)
 356 {
 357     struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
 358     const struct wined3d_vk_info *vk_info = context_vk->vk_info;
 359     struct shader_spirv_compute_program_vk *program;
 360     struct wined3d_pipeline_layout_vk *layout;
 361     VkComputePipelineCreateInfo pipeline_info;
 362     struct wined3d_shader_desc shader_desc;
 363     VkResult vr;
 364
 365     if (!(program = shader->backend_data))
 366         return NULL;
 367
 368     if (program->vk_module)
 369         return program;
 370
 371     shader_desc.byte_code = shader->byte_code;
 372     shader_desc.byte_code_size = shader->byte_code_size;
 373
 374     if (!(program->vk_module = shader_spirv_compile_shader(context_vk, &shader_desc, WINED3D_SHADER_TYPE_COMPUTE,
 375             NULL, bindings, NULL)))
 376         return NULL;
 377
 378     if (!(layout = wined3d_context_vk_get_pipeline_layout(context_vk,
 379             bindings->vk_bindings, bindings->vk_binding_count)))
 380     {
 381         VK_CALL(vkDestroyShaderModule(device_vk->vk_device, program->vk_module, NULL));
 382         program->vk_module = VK_NULL_HANDLE;
 383         return NULL;
 384     }
 385     program->vk_set_layout = layout->vk_set_layout;
 386     program->vk_pipeline_layout = layout->vk_pipeline_layout;
 387
 388     pipeline_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
 389     pipeline_info.pNext = NULL;
 390     pipeline_info.flags = 0;
 391     pipeline_info.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 392     pipeline_info.stage.pNext = NULL;
 393     pipeline_info.stage.flags = 0;
 394     pipeline_info.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
 395     pipeline_info.stage.pName = "main";
 396     pipeline_info.stage.pSpecializationInfo = NULL;
 397     pipeline_info.stage.module = program->vk_module;
 398     pipeline_info.layout = program->vk_pipeline_layout;
 399     pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
 400     pipeline_info.basePipelineIndex = -1;
 401     if ((vr = VK_CALL(vkCreateComputePipelines(device_vk->vk_device,
 402             VK_NULL_HANDLE, 1, &pipeline_info, NULL, &program->vk_pipeline))) < 0)
 403     {
 404         ERR("Failed to create Vulkan compute pipeline, vr %s.\n", wined3d_debug_vkresult(vr));
 405         VK_CALL(vkDestroyShaderModule(device_vk->vk_device, program->vk_module, NULL));
 406         program->vk_module = VK_NULL_HANDLE;
 407         return NULL;
 408     }
 409
 410     return program;
 411 }
 412
 413 static void shader_spirv_resource_bindings_cleanup(struct shader_spirv_resource_bindings *bindings)
 414 {
 415     heap_free(bindings->vk_bindings);
 416     heap_free(bindings->bindings);
 417 }
 418
 419 static bool shader_spirv_resource_bindings_add_vk_binding(struct shader_spirv_resource_bindings *bindings,
 420         VkDescriptorType vk_type, VkShaderStageFlagBits vk_stage, size_t *binding_idx)
 421 {
 422     SIZE_T binding_count = bindings->vk_binding_count;
 423     VkDescriptorSetLayoutBinding *binding;
 424
 425     if (!wined3d_array_reserve((void **)&bindings->vk_bindings, &bindings->vk_bindings_size,
 426             binding_count + 1, sizeof(*bindings->vk_bindings)))
 427         return false;
 428
 429     *binding_idx = binding_count;
 430     binding = &bindings->vk_bindings[binding_count];
 431     binding->binding = binding_count;
 432     binding->descriptorType = vk_type;
 433     binding->descriptorCount = 1;
 434     binding->stageFlags = vk_stage;
 435     binding->pImmutableSamplers = NULL;
 436     ++bindings->vk_binding_count;
 437
 438     return true;
 439 }
 440
 441 static bool shader_spirv_resource_bindings_add_binding(struct shader_spirv_resource_bindings *bindings,
 442         enum vkd3d_shader_descriptor_type vkd3d_type, VkDescriptorType vk_type, size_t register_idx,
 443         enum vkd3d_shader_visibility vkd3d_visibility, VkShaderStageFlagBits vk_stage,
 444         uint32_t flags, size_t *binding_idx)
 445 {
 446     SIZE_T binding_count = bindings->binding_count;
 447     struct vkd3d_shader_resource_binding *binding;
 448
 449     if (!wined3d_array_reserve((void **)&bindings->bindings, &bindings->bindings_size,
 450             binding_count + 1, sizeof(*bindings->bindings)))
 451         return false;
 452
 453     if (!shader_spirv_resource_bindings_add_vk_binding(bindings, vk_type, vk_stage, binding_idx))
 454         return false;
 455
 456     binding = &bindings->bindings[binding_count];
 457     binding->type = vkd3d_type;
 458     binding->register_space = 0;
 459     binding->register_index = register_idx;
 460     binding->shader_visibility = vkd3d_visibility;
 461     binding->flags = flags;
 462     binding->binding.set = 0;
 463     binding->binding.binding = *binding_idx;
 464     binding->binding.count = 1;
 465     ++bindings->binding_count;
 466
 467     return true;
 468 }
 469
 470 static bool shader_spirv_resource_bindings_add_uav_counter_binding(struct shader_spirv_resource_bindings *bindings,
 471         size_t register_idx, enum vkd3d_shader_visibility vkd3d_visibility,
 472         VkShaderStageFlagBits vk_stage, size_t *binding_idx)
 473 {
 474     SIZE_T uav_counter_count = bindings->uav_counter_count;
 475     struct vkd3d_shader_uav_counter_binding *counter;
 476
 477     if (uav_counter_count >= ARRAY_SIZE(bindings->uav_counters))
 478         return false;
 479
 480     if (!shader_spirv_resource_bindings_add_vk_binding(bindings,
 481             VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, vk_stage, binding_idx))
 482         return false;
 483
 484     counter = &bindings->uav_counters[uav_counter_count];
 485     counter->register_space = 0;
 486     counter->register_index = register_idx;
 487     counter->shader_visibility = vkd3d_visibility;
 488     counter->binding.set = 0;
 489     counter->binding.binding = *binding_idx;
 490     counter->binding.count = 1;
 491     counter->offset = 0;
 492     ++bindings->uav_counter_count;
 493
 494     return true;
 495 }
 496
 497 static bool wined3d_shader_resource_bindings_add_binding(struct wined3d_shader_resource_bindings *bindings,
 498         enum wined3d_shader_type shader_type, enum wined3d_shader_descriptor_type shader_descriptor_type,
 499         size_t resource_idx, enum wined3d_shader_resource_type resource_type,
 500         enum wined3d_data_type resource_data_type, size_t binding_idx)
 501 {
 502     struct wined3d_shader_resource_binding *binding;
 503     SIZE_T binding_count = bindings->count;
 504
 505     if (!wined3d_array_reserve((void **)&bindings->bindings, &bindings->size,
 506             binding_count + 1, sizeof(*bindings->bindings)))
 507         return false;
 508
 509     binding = &bindings->bindings[binding_count];
 510     binding->shader_type = shader_type;
 511     binding->shader_descriptor_type = shader_descriptor_type;
 512     binding->resource_idx = resource_idx;
 513     binding->resource_type = resource_type;
 514     binding->resource_data_type = resource_data_type;
 515     binding->binding_idx = binding_idx;
 516     ++bindings->count;
 517
 518     return true;
 519 }
 520
 521 static VkDescriptorType vk_descriptor_type_from_vkd3d(enum vkd3d_shader_descriptor_type type,
 522         enum vkd3d_shader_resource_type resource_type)
 523 {
 524     switch (type)
 525     {
 526         case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV:
 527             return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
 528
 529         case VKD3D_SHADER_DESCRIPTOR_TYPE_SRV:
 530             if (resource_type == VKD3D_SHADER_RESOURCE_BUFFER)
 531                 return VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
 532             return VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
 533
 534         case VKD3D_SHADER_DESCRIPTOR_TYPE_UAV:
 535             if (resource_type == VKD3D_SHADER_RESOURCE_BUFFER)
 536                 return VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
 537             return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
 538
 539         case VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER:
 540             return VK_DESCRIPTOR_TYPE_SAMPLER;
 541
 542         default:
 543             FIXME("Unhandled descriptor type %#x.\n", type);
 544             return ~0u;
 545     }
 546 }
 547
 548 static enum wined3d_shader_descriptor_type wined3d_descriptor_type_from_vkd3d(enum vkd3d_shader_descriptor_type type)
 549 {
 550     switch (type)
 551     {
 552         case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV:
 553             return WINED3D_SHADER_DESCRIPTOR_TYPE_CBV;
 554
 555         case VKD3D_SHADER_DESCRIPTOR_TYPE_SRV:
 556             return WINED3D_SHADER_DESCRIPTOR_TYPE_SRV;
 557
 558         case VKD3D_SHADER_DESCRIPTOR_TYPE_UAV:
 559             return WINED3D_SHADER_DESCRIPTOR_TYPE_UAV;
 560
 561         case VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER:
 562             return WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER;
 563
 564         default:
 565             FIXME("Unhandled descriptor type %#x.\n", type);
 566             return ~0u;
 567     }
 568 }
 569
 570 static enum wined3d_shader_resource_type wined3d_shader_resource_type_from_vkd3d(enum vkd3d_shader_resource_type t)
 571 {
 572     return (enum wined3d_shader_resource_type)t;
 573 }
 574
 575 static enum wined3d_data_type wined3d_data_type_from_vkd3d(enum vkd3d_shader_resource_data_type t)
 576 {
 577     switch (t)
 578     {
 579         case VKD3D_SHADER_RESOURCE_DATA_UNORM:
 580             return WINED3D_DATA_UNORM;
 581         case VKD3D_SHADER_RESOURCE_DATA_SNORM:
 582             return WINED3D_DATA_SNORM;
 583         case VKD3D_SHADER_RESOURCE_DATA_INT:
 584             return WINED3D_DATA_INT;
 585         case VKD3D_SHADER_RESOURCE_DATA_UINT:
 586             return WINED3D_DATA_UINT;
 587         case VKD3D_SHADER_RESOURCE_DATA_FLOAT:
 588             return WINED3D_DATA_FLOAT;
 589         case VKD3D_SHADER_RESOURCE_DATA_MIXED:
 590             return WINED3D_DATA_UINT;
 591         default:
 592             FIXME("Unhandled resource data type %#x.\n", t);
 593             return WINED3D_DATA_FLOAT;
 594     }
 595 }
 596
 597 static bool shader_spirv_resource_bindings_init(struct shader_spirv_resource_bindings *bindings,
 598         struct wined3d_shader_resource_bindings *wined3d_bindings,
 599         const struct wined3d_state *state, uint32_t shader_mask)
 600 {
 601     const struct vkd3d_shader_scan_descriptor_info *descriptor_info;
 602     enum wined3d_shader_descriptor_type wined3d_type;
 603     enum vkd3d_shader_visibility shader_visibility;
 604     enum wined3d_shader_type shader_type;
 605     VkDescriptorType vk_descriptor_type;
 606     VkShaderStageFlagBits vk_stage;
 607     struct wined3d_shader *shader;
 608     size_t binding_idx;
 609     unsigned int i;
 610
 611     bindings->binding_count = 0;
 612     bindings->uav_counter_count = 0;
 613     bindings->vk_binding_count = 0;
 614     bindings->so_stage = WINED3D_SHADER_TYPE_GEOMETRY;
 615     wined3d_bindings->count = 0;
 616
 617     for (shader_type = 0; shader_type < WINED3D_SHADER_TYPE_COUNT; ++shader_type)
 618     {
 619         bindings->binding_base[shader_type] = bindings->vk_binding_count;
 620
 621         if (!(shader_mask & (1u << shader_type)) || !(shader = state->shader[shader_type]))
 622             continue;
 623
 624         if (shader_type == WINED3D_SHADER_TYPE_COMPUTE)
 625         {
 626             descriptor_info = &((struct shader_spirv_compute_program_vk *)shader->backend_data)->descriptor_info;
 627         }
 628         else
 629         {
 630             descriptor_info = &((struct shader_spirv_graphics_program_vk *)shader->backend_data)->descriptor_info;
 631             if (shader_type == WINED3D_SHADER_TYPE_GEOMETRY && !shader->function)
 632                 bindings->so_stage = WINED3D_SHADER_TYPE_VERTEX;
 633         }
 634
 635         vk_stage = vk_shader_stage_from_wined3d(shader_type);
 636         shader_visibility = vkd3d_shader_visibility_from_wined3d(shader_type);
 637
 638         for (i = 0; i < descriptor_info->descriptor_count; ++i)
 639         {
 640             const struct vkd3d_shader_descriptor_info *d = &descriptor_info->descriptors[i];
 641             uint32_t flags;
 642
 643             if (d->register_space)
 644             {
 645                 WARN("Unsupported register space %u.\n", d->register_space);
 646                 return false;
 647             }
 648
 649             if (d->resource_type == VKD3D_SHADER_RESOURCE_BUFFER)
 650                 flags = VKD3D_SHADER_BINDING_FLAG_BUFFER;
 651             else
 652                 flags = VKD3D_SHADER_BINDING_FLAG_IMAGE;
 653
 654             vk_descriptor_type = vk_descriptor_type_from_vkd3d(d->type, d->resource_type);
 655             if (!shader_spirv_resource_bindings_add_binding(bindings, d->type, vk_descriptor_type,
 656                     d->register_index, shader_visibility, vk_stage, flags, &binding_idx))
 657                 return false;
 658
 659             wined3d_type = wined3d_descriptor_type_from_vkd3d(d->type);
 660             if (!wined3d_shader_resource_bindings_add_binding(wined3d_bindings, shader_type,
 661                     wined3d_type, d->register_index, wined3d_shader_resource_type_from_vkd3d(d->resource_type),
 662                     wined3d_data_type_from_vkd3d(d->resource_data_type), binding_idx))
 663                 return false;
 664
 665             if (d->type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV
 666                     && (d->flags & VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_COUNTER))
 667             {
 668                 if (!shader_spirv_resource_bindings_add_uav_counter_binding(bindings,
 669                         d->register_index, shader_visibility, vk_stage, &binding_idx))
 670                     return false;
 671                 if (!wined3d_shader_resource_bindings_add_binding(wined3d_bindings,
 672                         shader_type, WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER, d->register_index,
 673                         WINED3D_SHADER_RESOURCE_BUFFER, WINED3D_DATA_UINT, binding_idx))
 674                     return false;
 675             }
 676         }
 677     }
 678
 679     return true;
 680 }
 681
 682 static void shader_spirv_scan_shader(struct wined3d_shader *shader,
 683         struct vkd3d_shader_scan_descriptor_info *descriptor_info)
 684 {
 685     struct vkd3d_shader_compile_info info;
 686     char *messages;
 687     int ret;
 688
 689     memset(descriptor_info, 0, sizeof(*descriptor_info));
 690     descriptor_info->type = VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO;
 691
 692     info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO;
 693     info.next = descriptor_info;
 694     info.source.code = shader->byte_code;
 695     info.source.size = shader->byte_code_size;
 696     info.source_type = VKD3D_SHADER_SOURCE_DXBC_TPF;
 697     info.target_type = VKD3D_SHADER_TARGET_SPIRV_BINARY;
 698     info.options = spirv_compile_options;
 699     info.option_count = ARRAY_SIZE(spirv_compile_options);
 700     info.log_level = VKD3D_SHADER_LOG_WARNING;
 701     info.source_name = NULL;
 702
 703     if ((ret = vkd3d_shader_scan(&info, &messages)) < 0)
 704         ERR("Failed to scan shader, ret %d.\n", ret);
 705     if (messages && *messages && FIXME_ON(d3d_shader))
 706     {
 707         const char *ptr, *end, *line;
 708
 709         FIXME("Shader log:\n");
 710         ptr = messages;
 711         end = ptr + strlen(ptr);
 712         while ((line = wined3d_get_line(&ptr, end)))
 713         {
 714             FIXME("    %.*s", (int)(ptr - line), line);
 715         }
 716         FIXME("\n");
 717     }
 718     vkd3d_shader_free_messages(messages);
 719 }
 720
 721 static void shader_spirv_precompile_compute(struct wined3d_shader *shader)
 722 {
 723     struct shader_spirv_compute_program_vk *program_vk;
 724
 725     if (!(program_vk = shader->backend_data))
 726     {
 727         if (!(program_vk = heap_alloc_zero(sizeof(*program_vk))))
 728             ERR("Failed to allocate program.\n");
 729         shader->backend_data = program_vk;
 730     }
 731
 732     shader_spirv_scan_shader(shader, &program_vk->descriptor_info);
 733 }
 734
 735 static void shader_spirv_precompile(void *shader_priv, struct wined3d_shader *shader)
 736 {
 737     struct shader_spirv_graphics_program_vk *program_vk;
 738
 739     TRACE("shader_priv %p, shader %p.\n", shader_priv, shader);
 740
 741     if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_COMPUTE)
 742     {
 743         shader_spirv_precompile_compute(shader);
 744         return;
 745     }
 746
 747     if (!(program_vk = shader->backend_data))
 748     {
 749         if (!(program_vk = heap_alloc_zero(sizeof(*program_vk))))
 750             ERR("Failed to allocate program.\n");
 751         shader->backend_data = program_vk;
 752     }
 753
 754     shader_spirv_scan_shader(shader, &program_vk->descriptor_info);
 755 }
 756
 757 static void shader_spirv_select(void *shader_priv, struct wined3d_context *context,
 758         const struct wined3d_state *state)
 759 {
 760     struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
 761     struct shader_spirv_graphics_program_variant_vk *variant_vk;
 762     struct shader_spirv_resource_bindings *bindings;
 763     size_t binding_base[WINED3D_SHADER_TYPE_COUNT];
 764     struct wined3d_pipeline_layout_vk *layout_vk;
 765     struct shader_spirv_priv *priv = shader_priv;
 766     enum wined3d_shader_type shader_type;
 767     struct wined3d_shader *shader;
 768
 769     priv->vertex_pipe->vp_enable(context, !use_vs(state));
 770     priv->fragment_pipe->fp_enable(context, !use_ps(state));
 771
 772     bindings = &priv->bindings;
 773     memcpy(binding_base, bindings->binding_base, sizeof(bindings->binding_base));
 774     if (!shader_spirv_resource_bindings_init(bindings, &context_vk->graphics.bindings,
 775             state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE)))
 776     {
 777         ERR("Failed to initialise shader resource bindings.\n");
 778         goto fail;
 779     }
 780     if (context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_GEOMETRY))
 781         context->shader_update_mask |= 1u << bindings->so_stage;
 782
 783     layout_vk = wined3d_context_vk_get_pipeline_layout(context_vk, bindings->vk_bindings, bindings->vk_binding_count);
 784     context_vk->graphics.vk_set_layout = layout_vk->vk_set_layout;
 785     context_vk->graphics.vk_pipeline_layout = layout_vk->vk_pipeline_layout;
 786
 787     for (shader_type = 0; shader_type < ARRAY_SIZE(context_vk->graphics.vk_modules); ++shader_type)
 788     {
 789         if (!(context->shader_update_mask & (1u << shader_type)) && (!context_vk->graphics.vk_modules[shader_type]
 790                 || binding_base[shader_type] == bindings->binding_base[shader_type]))
 791             continue;
 792
 793         if (!(shader = state->shader[shader_type]) || !shader->function)
 794         {
 795             context_vk->graphics.vk_modules[shader_type] = VK_NULL_HANDLE;
 796             continue;
 797         }
 798
 799         if (!(variant_vk = shader_spirv_find_graphics_program_variant_vk(priv, context_vk, shader, state, bindings)))
 800             goto fail;
 801         context_vk->graphics.vk_modules[shader_type] = variant_vk->vk_module;
 802     }
 803
 804     return;
 805
 806 fail:
 807     context_vk->graphics.vk_set_layout = VK_NULL_HANDLE;
 808     context_vk->graphics.vk_pipeline_layout = VK_NULL_HANDLE;
 809 }
 810
 811 static void shader_spirv_select_compute(void *shader_priv,
 812         struct wined3d_context *context, const struct wined3d_state *state)
 813 {
 814     struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
 815     struct shader_spirv_compute_program_vk *program;
 816     struct shader_spirv_priv *priv = shader_priv;
 817     struct wined3d_shader *shader;
 818
 819     if (!shader_spirv_resource_bindings_init(&priv->bindings,
 820             &context_vk->compute.bindings, state, 1u << WINED3D_SHADER_TYPE_COMPUTE))
 821         ERR("Failed to initialise shader resource bindings.\n");
 822
 823     if ((shader = state->shader[WINED3D_SHADER_TYPE_COMPUTE]))
 824         program = shader_spirv_find_compute_program_vk(priv, context_vk, shader, &priv->bindings);
 825     else
 826         program = NULL;
 827
 828     if (program)
 829     {
 830         context_vk->compute.vk_pipeline = program->vk_pipeline;
 831         context_vk->compute.vk_set_layout = program->vk_set_layout;
 832         context_vk->compute.vk_pipeline_layout = program->vk_pipeline_layout;
 833     }
 834     else
 835     {
 836         context_vk->compute.vk_pipeline = VK_NULL_HANDLE;
 837         context_vk->compute.vk_set_layout = VK_NULL_HANDLE;
 838         context_vk->compute.vk_pipeline_layout = VK_NULL_HANDLE;
 839     }
 840 }
 841
 842 static void shader_spirv_disable(void *shader_priv, struct wined3d_context *context)
 843 {
 844     struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
 845     struct shader_spirv_priv *priv = shader_priv;
 846
 847     priv->vertex_pipe->vp_enable(context, false);
 848     priv->fragment_pipe->fp_enable(context, false);
 849
 850     context_vk->compute.vk_pipeline = VK_NULL_HANDLE;
 851     context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
 852             | (1u << WINED3D_SHADER_TYPE_VERTEX)
 853             | (1u << WINED3D_SHADER_TYPE_GEOMETRY)
 854             | (1u << WINED3D_SHADER_TYPE_HULL)
 855             | (1u << WINED3D_SHADER_TYPE_DOMAIN)
 856             | (1u << WINED3D_SHADER_TYPE_COMPUTE);
 857 }
 858
 859 static void shader_spirv_update_float_vertex_constants(struct wined3d_device *device, UINT start, UINT count)
 860 {
 861     WARN("Not implemented.\n");
 862 }
 863
 864 static void shader_spirv_update_float_pixel_constants(struct wined3d_device *device, UINT start, UINT count)
 865 {
 866     WARN("Not implemented.\n");
 867 }
 868
 869 static void shader_spirv_load_constants(void *shader_priv, struct wined3d_context *context,
 870         const struct wined3d_state *state)
 871 {
 872     WARN("Not implemented.\n");
 873 }
 874
 875 static void shader_spirv_invalidate_compute_program(struct wined3d_context_vk *context_vk,
 876         const struct shader_spirv_compute_program_vk *program)
 877 {
 878     if (context_vk->compute.vk_pipeline == program->vk_pipeline)
 879     {
 880         context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_COMPUTE);
 881         context_vk->compute.vk_pipeline = VK_NULL_HANDLE;
 882     }
 883 }
 884
 885 static void shader_spirv_invalidate_contexts_compute_program(struct wined3d_device *device,
 886     const struct shader_spirv_compute_program_vk *program)
 887 {
 888     unsigned int i;
 889
 890     for (i = 0; i < device->context_count; ++i)
 891     {
 892         shader_spirv_invalidate_compute_program(wined3d_context_vk(device->contexts[i]), program);
 893     }
 894 }
 895
 896 static void shader_spirv_invalidate_graphics_program_variant(struct wined3d_context_vk *context_vk,
 897         const struct shader_spirv_graphics_program_variant_vk *variant)
 898 {
 899     enum wined3d_shader_type shader_type;
 900
 901     for (shader_type = 0; shader_type < WINED3D_SHADER_TYPE_GRAPHICS_COUNT; ++shader_type)
 902     {
 903         if (context_vk->graphics.vk_modules[shader_type] != variant->vk_module)
 904             continue;
 905
 906         context_vk->graphics.vk_modules[shader_type] = VK_NULL_HANDLE;
 907         context_vk->c.shader_update_mask |= (1u << shader_type);
 908     }
 909 }
 910
 911 static void shader_spirv_invalidate_contexts_graphics_program_variant(struct wined3d_device *device,
 912         const struct shader_spirv_graphics_program_variant_vk *variant)
 913 {
 914     unsigned int i;
 915
 916     for (i = 0; i < device->context_count; ++i)
 917     {
 918         shader_spirv_invalidate_graphics_program_variant(wined3d_context_vk(device->contexts[i]), variant);
 919     }
 920 }
 921
 922 static void shader_spirv_destroy_compute_vk(struct wined3d_shader *shader)
 923 {
 924     struct wined3d_device_vk *device_vk = wined3d_device_vk(shader->device);
 925     struct shader_spirv_compute_program_vk *program = shader->backend_data;
 926     struct wined3d_context_vk *context_vk = &device_vk->context_vk;
 927     struct wined3d_vk_info *vk_info = &device_vk->vk_info;
 928
 929     shader_spirv_invalidate_contexts_compute_program(&device_vk->d, program);
 930     wined3d_context_vk_destroy_vk_pipeline(context_vk, program->vk_pipeline, context_vk->current_command_buffer.id);
 931     VK_CALL(vkDestroyShaderModule(device_vk->vk_device, program->vk_module, NULL));
 932     vkd3d_shader_free_scan_descriptor_info(&program->descriptor_info);
 933     shader->backend_data = NULL;
 934     heap_free(program);
 935 }
 936
 937 static void shader_spirv_destroy(struct wined3d_shader *shader)
 938 {
 939     struct wined3d_device_vk *device_vk = wined3d_device_vk(shader->device);
 940     struct shader_spirv_graphics_program_variant_vk *variant_vk;
 941     struct wined3d_vk_info *vk_info = &device_vk->vk_info;
 942     struct shader_spirv_graphics_program_vk *program_vk;
 943     size_t i;
 944
 945     if (!shader->backend_data)
 946         return;
 947
 948     if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_COMPUTE)
 949     {
 950         shader_spirv_destroy_compute_vk(shader);
 951         return;
 952     }
 953
 954     program_vk = shader->backend_data;
 955     for (i = 0; i < program_vk->variant_count; ++i)
 956     {
 957         variant_vk = &program_vk->variants[i];
 958         shader_spirv_invalidate_contexts_graphics_program_variant(&device_vk->d, variant_vk);
 959         VK_CALL(vkDestroyShaderModule(device_vk->vk_device, variant_vk->vk_module, NULL));
 960     }
 961     heap_free(program_vk->variants);
 962     vkd3d_shader_free_scan_descriptor_info(&program_vk->descriptor_info);
 963
 964     shader->backend_data = NULL;
 965     heap_free(program_vk);
 966 }
 967
 968 static HRESULT shader_spirv_alloc(struct wined3d_device *device,
 969         const struct wined3d_vertex_pipe_ops *vertex_pipe, const struct wined3d_fragment_pipe_ops *fragment_pipe)
 970 {
 971     struct fragment_caps fragment_caps;
 972     void *vertex_priv, *fragment_priv;
 973     struct shader_spirv_priv *priv;
 974
 975     if (!(priv = heap_alloc(sizeof(*priv))))
 976         return E_OUTOFMEMORY;
 977
 978     if (!(vertex_priv = vertex_pipe->vp_alloc(&spirv_shader_backend_vk, priv)))
 979     {
 980         ERR("Failed to initialise vertex pipe.\n");
 981         heap_free(priv);
 982         return E_FAIL;
 983     }
 984
 985     if (!(fragment_priv = fragment_pipe->alloc_private(&spirv_shader_backend_vk, priv)))
 986     {
 987         ERR("Failed to initialise fragment pipe.\n");
 988         vertex_pipe->vp_free(device, NULL);
 989         heap_free(priv);
 990         return E_FAIL;
 991     }
 992
 993     priv->vertex_pipe = vertex_pipe;
 994     priv->fragment_pipe = fragment_pipe;
 995     fragment_pipe->get_caps(device->adapter, &fragment_caps);
 996     priv->ffp_proj_control = fragment_caps.proj_control;
 997     memset(&priv->bindings, 0, sizeof(priv->bindings));
 998
 999     device->vertex_priv = vertex_priv;
1000     device->fragment_priv = fragment_priv;
1001     device->shader_priv = priv;
1002
1003     return WINED3D_OK;
1004 }
1005
1006 static void shader_spirv_free(struct wined3d_device *device, struct wined3d_context *context)
1007 {
1008     struct shader_spirv_priv *priv = device->shader_priv;
1009
1010     shader_spirv_resource_bindings_cleanup(&priv->bindings);
1011     priv->fragment_pipe->free_private(device, context);
1012     priv->vertex_pipe->vp_free(device, context);
1013     heap_free(priv);
1014 }
1015
1016 static BOOL shader_spirv_allocate_context_data(struct wined3d_context *context)
1017 {
1018     return TRUE;
1019 }
1020
1021 static void shader_spirv_free_context_data(struct wined3d_context *context)
1022 {
1023 }
1024
1025 static void shader_spirv_init_context_state(struct wined3d_context *context)
1026 {
1027 }
1028
1029 static void shader_spirv_get_caps(const struct wined3d_adapter *adapter, struct shader_caps *caps)
1030 {
1031     caps->vs_version = min(wined3d_settings.max_sm_vs, 5);
1032     caps->hs_version = min(wined3d_settings.max_sm_hs, 5);
1033     caps->ds_version = min(wined3d_settings.max_sm_ds, 5);
1034     caps->gs_version = min(wined3d_settings.max_sm_gs, 5);
1035     caps->ps_version = min(wined3d_settings.max_sm_ps, 5);
1036     caps->cs_version = min(wined3d_settings.max_sm_cs, 5);
1037
1038     caps->vs_uniform_count = WINED3D_MAX_VS_CONSTS_F;
1039     caps->ps_uniform_count = WINED3D_MAX_PS_CONSTS_F;
1040     caps->ps_1x_max_value = FLT_MAX;
1041     caps->varying_count = 0;
1042     caps->wined3d_caps = WINED3D_SHADER_CAP_VS_CLIPPING
1043             | WINED3D_SHADER_CAP_SRGB_WRITE
1044             | WINED3D_SHADER_CAP_FULL_FFP_VARYINGS;
1045 }
1046
1047 static BOOL shader_spirv_color_fixup_supported(struct color_fixup_desc fixup)
1048 {
1049     return is_identity_fixup(fixup);
1050 }
1051
1052 static BOOL shader_spirv_has_ffp_proj_control(void *shader_priv)
1053 {
1054     struct shader_spirv_priv *priv = shader_priv;
1055
1056     return priv->ffp_proj_control;
1057 }
1058
1059 static uint64_t shader_spirv_compile(struct wined3d_context *context, const struct wined3d_shader_desc *shader_desc,
1060         enum wined3d_shader_type shader_type)
1061 {
1062     struct shader_spirv_resource_bindings bindings = {0};
1063     return (uint64_t)shader_spirv_compile_shader(wined3d_context_vk(context), shader_desc, shader_type, NULL, &bindings, NULL);
1064 }
1065
1066 static const struct wined3d_shader_backend_ops spirv_shader_backend_vk =
1067 {
1068     .shader_handle_instruction = shader_spirv_handle_instruction,
1069     .shader_precompile = shader_spirv_precompile,
1070     .shader_select = shader_spirv_select,
1071     .shader_select_compute = shader_spirv_select_compute,
1072     .shader_disable = shader_spirv_disable,
1073     .shader_update_float_vertex_constants = shader_spirv_update_float_vertex_constants,
1074     .shader_update_float_pixel_constants = shader_spirv_update_float_pixel_constants,
1075     .shader_load_constants = shader_spirv_load_constants,
1076     .shader_destroy = shader_spirv_destroy,
1077     .shader_alloc_private = shader_spirv_alloc,
1078     .shader_free_private = shader_spirv_free,
1079     .shader_allocate_context_data = shader_spirv_allocate_context_data,
1080     .shader_free_context_data = shader_spirv_free_context_data,
1081     .shader_init_context_state = shader_spirv_init_context_state,
1082     .shader_get_caps = shader_spirv_get_caps,
1083     .shader_color_fixup_supported = shader_spirv_color_fixup_supported,
1084     .shader_has_ffp_proj_control = shader_spirv_has_ffp_proj_control,
1085     .shader_compile = shader_spirv_compile,
1086 };
1087
1088 const struct wined3d_shader_backend_ops *wined3d_spirv_shader_backend_init_vk(void)
1089 {
1090     TRACE("Using %s.\n", vkd3d_shader_get_version(NULL, NULL));
1091
1092     return &spirv_shader_backend_vk;
1093 }
1094
1095 static void spirv_vertex_pipe_vk_vp_enable(const struct wined3d_context *context, BOOL enable)
1096 {
1097     /* Nothing to do. */
1098 }
1099
1100 static void spirv_vertex_pipe_vk_vp_get_caps(const struct wined3d_adapter *adapter, struct wined3d_vertex_caps *caps)
1101 {
1102     memset(caps, 0, sizeof(*caps));
1103     caps->xyzrhw = TRUE;
1104     caps->ffp_generic_attributes = TRUE;
1105 }
1106
1107 static unsigned int spirv_vertex_pipe_vk_vp_get_emul_mask(const struct wined3d_adapter *adapter)
1108 {
1109     return 0;
1110 }
1111
1112 static void *spirv_vertex_pipe_vk_vp_alloc(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv)
1113 {
1114     if (shader_backend != &spirv_shader_backend_vk)
1115     {
1116         FIXME("SPIR-V vertex pipe without SPIR-V shader backend not implemented.\n");
1117         return NULL;
1118     }
1119
1120     return shader_priv;
1121 }
1122
1123 static void spirv_vertex_pipe_vk_vp_free(struct wined3d_device *device, struct wined3d_context *context)
1124 {
1125     /* Nothing to do. */
1126 }
1127
1128 static const struct wined3d_state_entry_template spirv_vertex_pipe_vk_vp_states[] =
1129 {
1130     {STATE_RENDER(WINED3D_RS_RANGEFOGENABLE),           {STATE_RENDER(WINED3D_RS_RANGEFOGENABLE),           state_nop}},
1131     {STATE_RENDER(WINED3D_RS_CLIPPING),                 {STATE_RENDER(WINED3D_RS_CLIPPING),                 state_nop}},
1132     {STATE_RENDER(WINED3D_RS_LIGHTING),                 {STATE_RENDER(WINED3D_RS_LIGHTING),                 state_nop}},
1133     {STATE_RENDER(WINED3D_RS_AMBIENT),                  {STATE_RENDER(WINED3D_RS_AMBIENT),                  state_nop}},
1134     {STATE_RENDER(WINED3D_RS_COLORVERTEX),              {STATE_RENDER(WINED3D_RS_COLORVERTEX),              state_nop}},
1135     {STATE_RENDER(WINED3D_RS_LOCALVIEWER),              {STATE_RENDER(WINED3D_RS_LOCALVIEWER),              state_nop}},
1136     {STATE_RENDER(WINED3D_RS_NORMALIZENORMALS),         {STATE_RENDER(WINED3D_RS_NORMALIZENORMALS),         state_nop}},
1137     {STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE),    {STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE),    state_nop}},
1138     {STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE),   {STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE),   state_nop}},
1139     {STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE),    {STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE),    state_nop}},
1140     {STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE),   {STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE),   state_nop}},
1141     {STATE_RENDER(WINED3D_RS_VERTEXBLEND),              {STATE_RENDER(WINED3D_RS_VERTEXBLEND),              state_nop}},
1142     {STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE),          {STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE),          state_nop}},
1143     {STATE_RENDER(WINED3D_RS_POINTSIZE),                {STATE_RENDER(WINED3D_RS_POINTSIZE),                state_nop}},
1144     {STATE_RENDER(WINED3D_RS_POINTSIZE_MIN),            {STATE_RENDER(WINED3D_RS_POINTSIZE_MIN),            state_nop}},
1145     {STATE_RENDER(WINED3D_RS_POINTSCALEENABLE),         {STATE_RENDER(WINED3D_RS_POINTSCALEENABLE),         state_nop}},
1146     {STATE_RENDER(WINED3D_RS_POINTSCALE_A),             {STATE_RENDER(WINED3D_RS_POINTSCALE_A),             state_nop}},
1147     {STATE_RENDER(WINED3D_RS_POINTSCALE_B),             {STATE_RENDER(WINED3D_RS_POINTSCALE_B),             state_nop}},
1148     {STATE_RENDER(WINED3D_RS_POINTSCALE_C),             {STATE_RENDER(WINED3D_RS_POINTSCALE_C),             state_nop}},
1149     {STATE_RENDER(WINED3D_RS_POINTSIZE_MAX),            {STATE_RENDER(WINED3D_RS_POINTSIZE_MAX),            state_nop}},
1150     {STATE_MATERIAL,                                    {STATE_MATERIAL,                                    state_nop}},
1151     {STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX),          {STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX),          state_nop}},
1152     {STATE_LIGHT_TYPE,                                  {STATE_LIGHT_TYPE,                                  state_nop}},
1153     {0}, /* Terminate */
1154 };
1155
1156 static const struct wined3d_vertex_pipe_ops spirv_vertex_pipe_vk =
1157 {
1158     .vp_enable = spirv_vertex_pipe_vk_vp_enable,
1159     .vp_get_caps = spirv_vertex_pipe_vk_vp_get_caps,
1160     .vp_get_emul_mask = spirv_vertex_pipe_vk_vp_get_emul_mask,
1161     .vp_alloc = spirv_vertex_pipe_vk_vp_alloc,
1162     .vp_free = spirv_vertex_pipe_vk_vp_free,
1163     .vp_states = spirv_vertex_pipe_vk_vp_states,
1164 };
1165
1166 const struct wined3d_vertex_pipe_ops *wined3d_spirv_vertex_pipe_init_vk(void)
1167 {
1168     return &spirv_vertex_pipe_vk;
1169 }
1170
1171 static void spirv_fragment_pipe_vk_fp_enable(const struct wined3d_context *context, BOOL enable)
1172 {
1173     /* Nothing to do. */
1174 }
1175
1176 static void spirv_fragment_pipe_vk_fp_get_caps(const struct wined3d_adapter *adapter, struct fragment_caps *caps)
1177 {
1178     memset(caps, 0, sizeof(*caps));
1179 }
1180
1181 static unsigned int spirv_fragment_pipe_vk_fp_get_emul_mask(const struct wined3d_adapter *adapter)
1182 {
1183     return 0;
1184 }
1185
1186 static void *spirv_fragment_pipe_vk_fp_alloc(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv)
1187 {
1188     if (shader_backend != &spirv_shader_backend_vk)
1189     {
1190         FIXME("SPIR-V fragment pipe without SPIR-V shader backend not implemented.\n");
1191         return NULL;
1192     }
1193
1194     return shader_priv;
1195 }
1196
1197 static void spirv_fragment_pipe_vk_fp_free(struct wined3d_device *device, struct wined3d_context *context)
1198 {
1199     /* Nothing to do. */
1200 }
1201
1202 static BOOL spirv_fragment_pipe_vk_fp_alloc_context_data(struct wined3d_context *context)
1203 {
1204     return TRUE;
1205 }
1206
1207 static void spirv_fragment_pipe_vk_fp_free_context_data(struct wined3d_context *context)
1208 {
1209     /* Nothing to do. */
1210 }
1211
1212 static const struct wined3d_state_entry_template spirv_fragment_pipe_vk_fp_states[] =
1213 {
1214     {STATE_RENDER(WINED3D_RS_SHADEMODE),         {STATE_RENDER(WINED3D_RS_SHADEMODE),         state_nop}},
1215     {STATE_RENDER(WINED3D_RS_ALPHATESTENABLE),   {STATE_RENDER(WINED3D_RS_ALPHATESTENABLE),   state_nop}},
1216     {STATE_RENDER(WINED3D_RS_ALPHAREF),          {STATE_RENDER(WINED3D_RS_ALPHAREF),          state_nop}},
1217     {STATE_RENDER(WINED3D_RS_ALPHAFUNC),         {STATE_RENDER(WINED3D_RS_ALPHAFUNC),         state_nop}},
1218     {STATE_RENDER(WINED3D_RS_FOGENABLE),         {STATE_RENDER(WINED3D_RS_FOGENABLE),         state_nop}},
1219     {STATE_RENDER(WINED3D_RS_SPECULARENABLE),    {STATE_RENDER(WINED3D_RS_SPECULARENABLE),    state_nop}},
1220     {STATE_RENDER(WINED3D_RS_FOGCOLOR),          {STATE_RENDER(WINED3D_RS_FOGCOLOR),          state_nop}},
1221     {STATE_RENDER(WINED3D_RS_FOGTABLEMODE),      {STATE_RENDER(WINED3D_RS_FOGTABLEMODE),      state_nop}},
1222     {STATE_RENDER(WINED3D_RS_FOGSTART),          {STATE_RENDER(WINED3D_RS_FOGSTART),          state_nop}},
1223     {STATE_RENDER(WINED3D_RS_FOGEND),            {STATE_RENDER(WINED3D_RS_FOGEND),            state_nop}},
1224     {STATE_RENDER(WINED3D_RS_FOGDENSITY),        {STATE_RENDER(WINED3D_RS_FOGDENSITY),        state_nop}},
1225     {STATE_RENDER(WINED3D_RS_COLORKEYENABLE),    {STATE_RENDER(WINED3D_RS_COLORKEYENABLE),    state_nop}},
1226     {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR),     {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR),     state_nop}},
1227     {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE),     {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE),     state_nop}},
1228     {STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), {STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), state_nop}},
1229     {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE),   {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE),   state_nop}},
1230     {STATE_POINT_ENABLE,                         {STATE_POINT_ENABLE,                         state_nop}},
1231     {STATE_COLOR_KEY,                            {STATE_COLOR_KEY,                            state_nop}},
1232     {0}, /* Terminate */
1233 };
1234
1235 static const struct wined3d_fragment_pipe_ops spirv_fragment_pipe_vk =
1236 {
1237     .fp_enable = spirv_fragment_pipe_vk_fp_enable,
1238     .get_caps = spirv_fragment_pipe_vk_fp_get_caps,
1239     .get_emul_mask = spirv_fragment_pipe_vk_fp_get_emul_mask,
1240     .alloc_private = spirv_fragment_pipe_vk_fp_alloc,
1241     .free_private = spirv_fragment_pipe_vk_fp_free,
1242     .allocate_context_data = spirv_fragment_pipe_vk_fp_alloc_context_data,
1243     .free_context_data = spirv_fragment_pipe_vk_fp_free_context_data,
1244     .color_fixup_supported = shader_spirv_color_fixup_supported,
1245     .states = spirv_fragment_pipe_vk_fp_states,
1246 };
1247
1248 const struct wined3d_fragment_pipe_ops *wined3d_spirv_fragment_pipe_init_vk(void)
1249 {
1250     return &spirv_fragment_pipe_vk;
1251 }