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