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