2 * Copyright 2018 Henri Verbeet for CodeWeavers
3 * Copyright 2019 Józef Kucia for CodeWeavers
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.
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.
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
20 #include "wined3d_private.h"
21 #define LIBVKD3D_SHADER_SOURCE
22 #include <vkd3d_shader.h>
24 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader
);
26 static const struct wined3d_shader_backend_ops spirv_shader_backend_vk
;
28 struct shader_spirv_resource_bindings
30 struct vkd3d_shader_resource_binding
*bindings
;
31 SIZE_T bindings_size
, binding_count
;
33 struct vkd3d_shader_uav_counter_binding uav_counters
[MAX_UNORDERED_ACCESS_VIEWS
];
34 SIZE_T uav_counter_count
;
36 VkDescriptorSetLayoutBinding
*vk_bindings
;
37 SIZE_T vk_bindings_size
, vk_binding_count
;
39 size_t binding_base
[WINED3D_SHADER_TYPE_COUNT
];
40 enum wined3d_shader_type so_stage
;
43 struct shader_spirv_priv
45 const struct wined3d_vertex_pipe_ops
*vertex_pipe
;
46 const struct wined3d_fragment_pipe_ops
*fragment_pipe
;
47 bool ffp_proj_control
;
49 struct shader_spirv_resource_bindings bindings
;
52 struct shader_spirv_compile_arguments
58 uint32_t alpha_swizzle
;
59 unsigned int sample_count
;
64 struct shader_spirv_graphics_program_variant_vk
66 struct shader_spirv_compile_arguments compile_args
;
67 const struct wined3d_stream_output_desc
*so_desc
;
70 VkShaderModule vk_module
;
73 struct shader_spirv_graphics_program_vk
75 struct shader_spirv_graphics_program_variant_vk
*variants
;
76 SIZE_T variants_size
, variant_count
;
78 struct vkd3d_shader_scan_descriptor_info descriptor_info
;
81 struct shader_spirv_compute_program_vk
83 VkShaderModule vk_module
;
84 VkPipeline vk_pipeline
;
85 VkPipelineLayout vk_pipeline_layout
;
86 VkDescriptorSetLayout vk_set_layout
;
88 struct vkd3d_shader_scan_descriptor_info descriptor_info
;
91 struct wined3d_shader_spirv_compile_args
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
];
98 struct wined3d_shader_spirv_shader_interface
100 struct vkd3d_shader_interface_info vkd3d_interface
;
101 struct vkd3d_shader_transform_feedback_info xfb_info
;
104 static enum vkd3d_shader_visibility
vkd3d_shader_visibility_from_wined3d(enum wined3d_shader_type shader_type
)
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
;
121 ERR("Invalid shader type %s.\n", debug_shader_type(shader_type
));
122 return VKD3D_SHADER_VISIBILITY_ALL
;
126 static void shader_spirv_handle_instruction(const struct wined3d_shader_instruction
*ins
)
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
)
134 struct wined3d_rendertarget_view
*rtv
;
137 memset(args
, 0, sizeof(*args
));
139 switch (shader
->reg_maps
.shader_version
.type
)
141 case WINED3D_SHADER_TYPE_PIXEL
:
142 for (i
= 0; i
< ARRAY_SIZE(state
->fb
.render_targets
); ++i
)
144 if (!(rtv
= state
->fb
.render_targets
[i
]) || rtv
->format
->id
== WINED3DFMT_NULL
)
146 if (rtv
->format
->id
== WINED3DFMT_A8_UNORM
&& !is_identity_fixup(rtv
->format
->color_fixup
))
147 args
->u
.fs
.alpha_swizzle
|= 1u << i
;
149 args
->u
.fs
.sample_count
= sample_count
;
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
)
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
;
169 if (shader_type
== WINED3D_SHADER_TYPE_PIXEL
)
171 unsigned int rt_alpha_swizzle
= compile_args
->u
.fs
.alpha_swizzle
;
172 struct vkd3d_shader_parameter
*shader_parameter
;
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
;
180 args
->spirv_target
.parameter_count
= 1;
181 args
->spirv_target
.parameters
= shader_parameter
;
183 for (i
= 0; i
< ARRAY_SIZE(args
->ps_alpha_swizzle
); ++i
)
185 if (rt_alpha_swizzle
&& (1u << i
))
186 args
->ps_alpha_swizzle
[i
] = VKD3D_SHADER_SWIZZLE(W
, X
, Y
, Z
);
188 args
->ps_alpha_swizzle
[i
] = VKD3D_SHADER_NO_SWIZZLE
;
191 args
->spirv_target
.output_swizzles
= args
->ps_alpha_swizzle
;
192 args
->spirv_target
.output_swizzle_count
= ARRAY_SIZE(args
->ps_alpha_swizzle
);
196 static const char *get_line(const char **ptr
)
201 if (!(q
= strstr(p
, "\n")))
203 if (!*p
) return NULL
;
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
)
215 memset(iface
, 0, sizeof(*iface
));
216 iface
->vkd3d_interface
.type
= VKD3D_SHADER_STRUCTURE_TYPE_INTERFACE_INFO
;
220 iface
->xfb_info
.type
= VKD3D_SHADER_STRUCTURE_TYPE_TRANSFORM_FEEDBACK_INFO
;
221 iface
->xfb_info
.next
= NULL
;
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
;
228 iface
->vkd3d_interface
.next
= &iface
->xfb_info
;
231 iface
->vkd3d_interface
.bindings
= b
->bindings
;
232 iface
->vkd3d_interface
.binding_count
= b
->binding_count
;
234 iface
->vkd3d_interface
.uav_counters
= b
->uav_counters
;
235 iface
->vkd3d_interface
.uav_counter_count
= b
->uav_counter_count
;
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
)
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
;
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
);
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
;
266 info
.option_count
= 0;
267 info
.log_level
= VKD3D_SHADER_LOG_WARNING
;
268 info
.source_name
= NULL
;
270 ret
= vkd3d_shader_compile(&info
, &spirv
, &messages
);
271 if (messages
&& *messages
&& FIXME_ON(d3d_shader
))
273 const char *ptr
= messages
;
276 FIXME("Shader log:\n");
277 while ((line
= get_line(&ptr
)))
279 FIXME(" %.*s", (int)(ptr
- line
), line
);
283 vkd3d_shader_free_messages(messages
);
287 ERR("Failed to compile DXBC, ret %d.\n", ret
);
288 return VK_NULL_HANDLE
;
291 device_vk
= wined3d_device_vk(context_vk
->c
.device
);
292 vk_info
= &device_vk
->vk_info
;
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)
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
;
306 vkd3d_shader_free_shader_code(&spirv
);
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
)
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
;
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
;
328 if (!(program_vk
= shader
->backend_data
))
331 variant_count
= program_vk
->variant_count
;
332 for (i
= 0; i
< variant_count
; ++i
)
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
)))
340 if (!wined3d_array_reserve((void **)&program_vk
->variants
, &program_vk
->variants_size
,
341 variant_count
+ 1, sizeof(*program_vk
->variants
)))
344 variant_vk
= &program_vk
->variants
[variant_count
];
345 variant_vk
->compile_args
= args
;
346 variant_vk
->binding_base
= binding_base
;
348 shader_desc
.byte_code
= shader
->byte_code
;
349 shader_desc
.byte_code_size
= shader
->byte_code_size
;
351 if (!(variant_vk
->vk_module
= shader_spirv_compile_shader(context_vk
, &shader_desc
, shader_type
, &args
,
354 ++program_vk
->variant_count
;
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
)
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
;
371 if (!(program
= shader
->backend_data
))
374 if (program
->vk_module
)
377 shader_desc
.byte_code
= shader
->byte_code
;
378 shader_desc
.byte_code_size
= shader
->byte_code_size
;
380 if (!(program
->vk_module
= shader_spirv_compile_shader(context_vk
, &shader_desc
, WINED3D_SHADER_TYPE_COMPUTE
,
381 NULL
, bindings
, NULL
)))
384 if (!(layout
= wined3d_context_vk_get_pipeline_layout(context_vk
,
385 bindings
->vk_bindings
, bindings
->vk_binding_count
)))
387 VK_CALL(vkDestroyShaderModule(device_vk
->vk_device
, program
->vk_module
, NULL
));
388 program
->vk_module
= VK_NULL_HANDLE
;
391 program
->vk_set_layout
= layout
->vk_set_layout
;
392 program
->vk_pipeline_layout
= layout
->vk_pipeline_layout
;
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)
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
;
419 static void shader_spirv_resource_bindings_cleanup(struct shader_spirv_resource_bindings
*bindings
)
421 heap_free(bindings
->vk_bindings
);
422 heap_free(bindings
->bindings
);
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
)
428 SIZE_T binding_count
= bindings
->vk_binding_count
;
429 VkDescriptorSetLayoutBinding
*binding
;
431 if (!wined3d_array_reserve((void **)&bindings
->vk_bindings
, &bindings
->vk_bindings_size
,
432 binding_count
+ 1, sizeof(*bindings
->vk_bindings
)))
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
;
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
)
452 SIZE_T binding_count
= bindings
->binding_count
;
453 struct vkd3d_shader_resource_binding
*binding
;
455 if (!wined3d_array_reserve((void **)&bindings
->bindings
, &bindings
->bindings_size
,
456 binding_count
+ 1, sizeof(*bindings
->bindings
)))
459 if (!shader_spirv_resource_bindings_add_vk_binding(bindings
, vk_type
, vk_stage
, binding_idx
))
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
;
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
)
480 SIZE_T uav_counter_count
= bindings
->uav_counter_count
;
481 struct vkd3d_shader_uav_counter_binding
*counter
;
483 if (uav_counter_count
>= ARRAY_SIZE(bindings
->uav_counters
))
486 if (!shader_spirv_resource_bindings_add_vk_binding(bindings
,
487 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
, vk_stage
, binding_idx
))
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;
498 ++bindings
->uav_counter_count
;
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
)
508 struct wined3d_shader_resource_binding
*binding
;
509 SIZE_T binding_count
= bindings
->count
;
511 if (!wined3d_array_reserve((void **)&bindings
->bindings
, &bindings
->size
,
512 binding_count
+ 1, sizeof(*bindings
->bindings
)))
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
;
527 static VkDescriptorType
vk_descriptor_type_from_vkd3d(enum vkd3d_shader_descriptor_type type
,
528 enum vkd3d_shader_resource_type resource_type
)
532 case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV
:
533 return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
;
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
;
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
;
545 case VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER
:
546 return VK_DESCRIPTOR_TYPE_SAMPLER
;
549 FIXME("Unhandled descriptor type %#x.\n", type
);
554 static enum wined3d_shader_descriptor_type
wined3d_descriptor_type_from_vkd3d(enum vkd3d_shader_descriptor_type type
)
558 case VKD3D_SHADER_DESCRIPTOR_TYPE_CBV
:
559 return WINED3D_SHADER_DESCRIPTOR_TYPE_CBV
;
561 case VKD3D_SHADER_DESCRIPTOR_TYPE_SRV
:
562 return WINED3D_SHADER_DESCRIPTOR_TYPE_SRV
;
564 case VKD3D_SHADER_DESCRIPTOR_TYPE_UAV
:
565 return WINED3D_SHADER_DESCRIPTOR_TYPE_UAV
;
567 case VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER
:
568 return WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER
;
571 FIXME("Unhandled descriptor type %#x.\n", type
);
576 static enum wined3d_shader_resource_type
wined3d_shader_resource_type_from_vkd3d(enum vkd3d_shader_resource_type t
)
578 return (enum wined3d_shader_resource_type
)t
;
581 static enum wined3d_data_type
wined3d_data_type_from_vkd3d(enum vkd3d_shader_resource_data_type t
)
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
;
596 FIXME("Unhandled resource data type %#x.\n", t
);
597 return WINED3D_DATA_FLOAT
;
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
)
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
;
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;
621 for (shader_type
= 0; shader_type
< WINED3D_SHADER_TYPE_COUNT
; ++shader_type
)
623 bindings
->binding_base
[shader_type
] = bindings
->vk_binding_count
;
625 if (!(shader_mask
& (1u << shader_type
)) || !(shader
= state
->shader
[shader_type
]))
628 if (shader_type
== WINED3D_SHADER_TYPE_COMPUTE
)
630 descriptor_info
= &((struct shader_spirv_compute_program_vk
*)shader
->backend_data
)->descriptor_info
;
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
;
639 vk_stage
= vk_shader_stage_from_wined3d(shader_type
);
640 shader_visibility
= vkd3d_shader_visibility_from_wined3d(shader_type
);
642 for (i
= 0; i
< descriptor_info
->descriptor_count
; ++i
)
644 struct vkd3d_shader_descriptor_info
*d
= &descriptor_info
->descriptors
[i
];
647 if (d
->register_space
)
649 WARN("Unsupported register space %u.\n", d
->register_space
);
653 if (d
->resource_type
== VKD3D_SHADER_RESOURCE_BUFFER
)
654 flags
= VKD3D_SHADER_BINDING_FLAG_BUFFER
;
656 flags
= VKD3D_SHADER_BINDING_FLAG_IMAGE
;
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
))
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
))
669 if (d
->type
== VKD3D_SHADER_DESCRIPTOR_TYPE_UAV
670 && (d
->flags
& VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_COUNTER
))
672 if (!shader_spirv_resource_bindings_add_uav_counter_binding(bindings
,
673 d
->register_index
, shader_visibility
, vk_stage
, &binding_idx
))
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
))
686 static void shader_spirv_scan_shader(struct wined3d_shader
*shader
,
687 struct vkd3d_shader_scan_descriptor_info
*descriptor_info
)
689 struct vkd3d_shader_compile_info info
;
693 memset(descriptor_info
, 0, sizeof(*descriptor_info
));
694 descriptor_info
->type
= VKD3D_SHADER_STRUCTURE_TYPE_SCAN_DESCRIPTOR_INFO
;
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
;
703 info
.option_count
= 0;
704 info
.log_level
= VKD3D_SHADER_LOG_WARNING
;
705 info
.source_name
= NULL
;
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
))
711 const char *ptr
= messages
;
714 FIXME("Shader log:\n");
715 while ((line
= get_line(&ptr
)))
717 FIXME(" %.*s", (int)(ptr
- line
), line
);
721 vkd3d_shader_free_messages(messages
);
724 static void shader_spirv_precompile_compute(struct wined3d_shader
*shader
)
726 struct shader_spirv_compute_program_vk
*program_vk
;
728 if (!(program_vk
= shader
->backend_data
))
730 if (!(program_vk
= heap_alloc_zero(sizeof(*program_vk
))))
731 ERR("Failed to allocate program.\n");
732 shader
->backend_data
= program_vk
;
735 shader_spirv_scan_shader(shader
, &program_vk
->descriptor_info
);
738 static void shader_spirv_precompile(void *shader_priv
, struct wined3d_shader
*shader
)
740 struct shader_spirv_graphics_program_vk
*program_vk
;
742 TRACE("shader_priv %p, shader %p.\n", shader_priv
, shader
);
744 if (shader
->reg_maps
.shader_version
.type
== WINED3D_SHADER_TYPE_COMPUTE
)
746 shader_spirv_precompile_compute(shader
);
750 if (!(program_vk
= shader
->backend_data
))
752 if (!(program_vk
= heap_alloc_zero(sizeof(*program_vk
))))
753 ERR("Failed to allocate program.\n");
754 shader
->backend_data
= program_vk
;
757 shader_spirv_scan_shader(shader
, &program_vk
->descriptor_info
);
760 static void shader_spirv_select(void *shader_priv
, struct wined3d_context
*context
,
761 const struct wined3d_state
*state
)
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
;
772 priv
->vertex_pipe
->vp_enable(context
, !use_vs(state
));
773 priv
->fragment_pipe
->fp_enable(context
, !use_ps(state
));
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
)))
780 ERR("Failed to initialise shader resource bindings.\n");
783 if (context
->shader_update_mask
& (1u << WINED3D_SHADER_TYPE_GEOMETRY
))
784 context
->shader_update_mask
|= 1u << bindings
->so_stage
;
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
;
790 for (shader_type
= 0; shader_type
< ARRAY_SIZE(context_vk
->graphics
.vk_modules
); ++shader_type
)
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
]))
796 if (!(shader
= state
->shader
[shader_type
]) || !shader
->function
)
798 context_vk
->graphics
.vk_modules
[shader_type
] = VK_NULL_HANDLE
;
802 if (!(variant_vk
= shader_spirv_find_graphics_program_variant_vk(priv
, context_vk
, shader
, state
, bindings
)))
804 context_vk
->graphics
.vk_modules
[shader_type
] = variant_vk
->vk_module
;
810 context_vk
->graphics
.vk_set_layout
= VK_NULL_HANDLE
;
811 context_vk
->graphics
.vk_pipeline_layout
= VK_NULL_HANDLE
;
814 static void shader_spirv_select_compute(void *shader_priv
,
815 struct wined3d_context
*context
, const struct wined3d_state
*state
)
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
;
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");
826 if ((shader
= state
->shader
[WINED3D_SHADER_TYPE_COMPUTE
]))
827 program
= shader_spirv_find_compute_program_vk(priv
, context_vk
, shader
, &priv
->bindings
);
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
;
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
;
845 static void shader_spirv_disable(void *shader_priv
, struct wined3d_context
*context
)
847 struct wined3d_context_vk
*context_vk
= wined3d_context_vk(context
);
848 struct shader_spirv_priv
*priv
= shader_priv
;
850 priv
->vertex_pipe
->vp_enable(context
, false);
851 priv
->fragment_pipe
->fp_enable(context
, false);
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
);
862 static void shader_spirv_update_float_vertex_constants(struct wined3d_device
*device
, UINT start
, UINT count
)
864 WARN("Not implemented.\n");
867 static void shader_spirv_update_float_pixel_constants(struct wined3d_device
*device
, UINT start
, UINT count
)
869 WARN("Not implemented.\n");
872 static void shader_spirv_load_constants(void *shader_priv
, struct wined3d_context
*context
,
873 const struct wined3d_state
*state
)
875 WARN("Not implemented.\n");
878 static void shader_spirv_invalidate_compute_program(struct wined3d_context_vk
*context_vk
,
879 const struct shader_spirv_compute_program_vk
*program
)
881 if (context_vk
->compute
.vk_pipeline
== program
->vk_pipeline
)
883 context_vk
->c
.shader_update_mask
|= (1u << WINED3D_SHADER_TYPE_COMPUTE
);
884 context_vk
->compute
.vk_pipeline
= VK_NULL_HANDLE
;
888 static void shader_spirv_invalidate_contexts_compute_program(struct wined3d_device
*device
,
889 const struct shader_spirv_compute_program_vk
*program
)
893 for (i
= 0; i
< device
->context_count
; ++i
)
895 shader_spirv_invalidate_compute_program(wined3d_context_vk(device
->contexts
[i
]), program
);
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
)
902 enum wined3d_shader_type shader_type
;
904 for (shader_type
= 0; shader_type
< WINED3D_SHADER_TYPE_GRAPHICS_COUNT
; ++shader_type
)
906 if (context_vk
->graphics
.vk_modules
[shader_type
] != variant
->vk_module
)
909 context_vk
->graphics
.vk_modules
[shader_type
] = VK_NULL_HANDLE
;
910 context_vk
->c
.shader_update_mask
|= (1u << shader_type
);
914 static void shader_spirv_invalidate_contexts_graphics_program_variant(struct wined3d_device
*device
,
915 const struct shader_spirv_graphics_program_variant_vk
*variant
)
919 for (i
= 0; i
< device
->context_count
; ++i
)
921 shader_spirv_invalidate_graphics_program_variant(wined3d_context_vk(device
->contexts
[i
]), variant
);
925 static void shader_spirv_destroy_compute_vk(struct wined3d_shader
*shader
)
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
;
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
;
939 static void shader_spirv_destroy(struct wined3d_shader
*shader
)
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
;
947 if (!shader
->backend_data
)
950 if (shader
->reg_maps
.shader_version
.type
== WINED3D_SHADER_TYPE_COMPUTE
)
952 shader_spirv_destroy_compute_vk(shader
);
956 program_vk
= shader
->backend_data
;
957 for (i
= 0; i
< program_vk
->variant_count
; ++i
)
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
));
963 heap_free(program_vk
->variants
);
964 vkd3d_shader_free_scan_descriptor_info(&program_vk
->descriptor_info
);
966 shader
->backend_data
= NULL
;
967 heap_free(program_vk
);
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
)
973 struct fragment_caps fragment_caps
;
974 void *vertex_priv
, *fragment_priv
;
975 struct shader_spirv_priv
*priv
;
977 if (!(priv
= heap_alloc(sizeof(*priv
))))
978 return E_OUTOFMEMORY
;
980 if (!(vertex_priv
= vertex_pipe
->vp_alloc(&spirv_shader_backend_vk
, priv
)))
982 ERR("Failed to initialise vertex pipe.\n");
987 if (!(fragment_priv
= fragment_pipe
->alloc_private(&spirv_shader_backend_vk
, priv
)))
989 ERR("Failed to initialise fragment pipe.\n");
990 vertex_pipe
->vp_free(device
, NULL
);
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
));
1001 device
->vertex_priv
= vertex_priv
;
1002 device
->fragment_priv
= fragment_priv
;
1003 device
->shader_priv
= priv
;
1008 static void shader_spirv_free(struct wined3d_device
*device
, struct wined3d_context
*context
)
1010 struct shader_spirv_priv
*priv
= device
->shader_priv
;
1012 shader_spirv_resource_bindings_cleanup(&priv
->bindings
);
1013 priv
->fragment_pipe
->free_private(device
, context
);
1014 priv
->vertex_pipe
->vp_free(device
, context
);
1018 static BOOL
shader_spirv_allocate_context_data(struct wined3d_context
*context
)
1023 static void shader_spirv_free_context_data(struct wined3d_context
*context
)
1027 static void shader_spirv_init_context_state(struct wined3d_context
*context
)
1031 static void shader_spirv_get_caps(const struct wined3d_adapter
*adapter
, struct shader_caps
*caps
)
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);
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
;
1049 static BOOL
shader_spirv_color_fixup_supported(struct color_fixup_desc fixup
)
1051 return is_identity_fixup(fixup
);
1054 static BOOL
shader_spirv_has_ffp_proj_control(void *shader_priv
)
1056 struct shader_spirv_priv
*priv
= shader_priv
;
1058 return priv
->ffp_proj_control
;
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
)
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
);
1068 static const struct wined3d_shader_backend_ops spirv_shader_backend_vk
=
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
,
1090 const struct wined3d_shader_backend_ops
*wined3d_spirv_shader_backend_init_vk(void)
1092 TRACE("Using %s.\n", vkd3d_shader_get_version(NULL
, NULL
));
1094 return &spirv_shader_backend_vk
;
1097 static void spirv_vertex_pipe_vk_vp_enable(const struct wined3d_context
*context
, BOOL enable
)
1099 /* Nothing to do. */
1102 static void spirv_vertex_pipe_vk_vp_get_caps(const struct wined3d_adapter
*adapter
, struct wined3d_vertex_caps
*caps
)
1104 memset(caps
, 0, sizeof(*caps
));
1105 caps
->xyzrhw
= TRUE
;
1106 caps
->ffp_generic_attributes
= TRUE
;
1109 static uint32_t spirv_vertex_pipe_vk_vp_get_emul_mask(const struct wined3d_gl_info
*gl_info
)
1114 static void *spirv_vertex_pipe_vk_vp_alloc(const struct wined3d_shader_backend_ops
*shader_backend
, void *shader_priv
)
1116 if (shader_backend
!= &spirv_shader_backend_vk
)
1118 FIXME("SPIR-V vertex pipe without SPIR-V shader backend not implemented.\n");
1125 static void spirv_vertex_pipe_vk_vp_free(struct wined3d_device
*device
, struct wined3d_context
*context
)
1127 /* Nothing to do. */
1130 static const struct wined3d_state_entry_template spirv_vertex_pipe_vk_vp_states
[] =
1132 {STATE_RENDER(WINED3D_RS_RANGEFOGENABLE
), {STATE_RENDER(WINED3D_RS_RANGEFOGENABLE
), state_nop
}},
1133 {STATE_RENDER(WINED3D_RS_CLIPPING
), {STATE_RENDER(WINED3D_RS_CLIPPING
), state_nop
}},
1134 {STATE_RENDER(WINED3D_RS_LIGHTING
), {STATE_RENDER(WINED3D_RS_LIGHTING
), state_nop
}},
1135 {STATE_RENDER(WINED3D_RS_AMBIENT
), {STATE_RENDER(WINED3D_RS_AMBIENT
), state_nop
}},
1136 {STATE_RENDER(WINED3D_RS_COLORVERTEX
), {STATE_RENDER(WINED3D_RS_COLORVERTEX
), state_nop
}},
1137 {STATE_RENDER(WINED3D_RS_LOCALVIEWER
), {STATE_RENDER(WINED3D_RS_LOCALVIEWER
), state_nop
}},
1138 {STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
), {STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
), state_nop
}},
1139 {STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE
), {STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE
), state_nop
}},
1140 {STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE
), {STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE
), state_nop
}},
1141 {STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE
), {STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE
), state_nop
}},
1142 {STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE
), {STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE
), state_nop
}},
1143 {STATE_RENDER(WINED3D_RS_VERTEXBLEND
), {STATE_RENDER(WINED3D_RS_VERTEXBLEND
), state_nop
}},
1144 {STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
), {STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
), state_nop
}},
1145 {STATE_RENDER(WINED3D_RS_POINTSIZE
), {STATE_RENDER(WINED3D_RS_POINTSIZE
), state_nop
}},
1146 {STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), {STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), state_nop
}},
1147 {STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), {STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), state_nop
}},
1148 {STATE_RENDER(WINED3D_RS_POINTSCALE_A
), {STATE_RENDER(WINED3D_RS_POINTSCALE_A
), state_nop
}},
1149 {STATE_RENDER(WINED3D_RS_POINTSCALE_B
), {STATE_RENDER(WINED3D_RS_POINTSCALE_B
), state_nop
}},
1150 {STATE_RENDER(WINED3D_RS_POINTSCALE_C
), {STATE_RENDER(WINED3D_RS_POINTSCALE_C
), state_nop
}},
1151 {STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), {STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), state_nop
}},
1152 {STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE
), {STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE
), state_nop
}},
1153 {STATE_RENDER(WINED3D_RS_TWEENFACTOR
), {STATE_RENDER(WINED3D_RS_TWEENFACTOR
), state_nop
}},
1154 {STATE_MATERIAL
, {STATE_MATERIAL
, state_nop
}},
1155 {STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX
), {STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX
), state_nop
}},
1156 {STATE_LIGHT_TYPE
, {STATE_LIGHT_TYPE
, state_nop
}},
1157 {0}, /* Terminate */
1160 static const struct wined3d_vertex_pipe_ops spirv_vertex_pipe_vk
=
1162 .vp_enable
= spirv_vertex_pipe_vk_vp_enable
,
1163 .vp_get_caps
= spirv_vertex_pipe_vk_vp_get_caps
,
1164 .vp_get_emul_mask
= spirv_vertex_pipe_vk_vp_get_emul_mask
,
1165 .vp_alloc
= spirv_vertex_pipe_vk_vp_alloc
,
1166 .vp_free
= spirv_vertex_pipe_vk_vp_free
,
1167 .vp_states
= spirv_vertex_pipe_vk_vp_states
,
1170 const struct wined3d_vertex_pipe_ops
*wined3d_spirv_vertex_pipe_init_vk(void)
1172 return &spirv_vertex_pipe_vk
;
1175 static void spirv_fragment_pipe_vk_fp_enable(const struct wined3d_context
*context
, BOOL enable
)
1177 /* Nothing to do. */
1180 static void spirv_fragment_pipe_vk_fp_get_caps(const struct wined3d_adapter
*adapter
, struct fragment_caps
*caps
)
1182 memset(caps
, 0, sizeof(*caps
));
1185 static uint32_t spirv_fragment_pipe_vk_fp_get_emul_mask(const struct wined3d_gl_info
*gl_info
)
1190 static void *spirv_fragment_pipe_vk_fp_alloc(const struct wined3d_shader_backend_ops
*shader_backend
, void *shader_priv
)
1192 if (shader_backend
!= &spirv_shader_backend_vk
)
1194 FIXME("SPIR-V fragment pipe without SPIR-V shader backend not implemented.\n");
1201 static void spirv_fragment_pipe_vk_fp_free(struct wined3d_device
*device
, struct wined3d_context
*context
)
1203 /* Nothing to do. */
1206 static BOOL
spirv_fragment_pipe_vk_fp_alloc_context_data(struct wined3d_context
*context
)
1211 static void spirv_fragment_pipe_vk_fp_free_context_data(struct wined3d_context
*context
)
1213 /* Nothing to do. */
1216 static const struct wined3d_state_entry_template spirv_fragment_pipe_vk_fp_states
[] =
1218 {STATE_RENDER(WINED3D_RS_SHADEMODE
), {STATE_RENDER(WINED3D_RS_SHADEMODE
), state_nop
}},
1219 {STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), {STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), state_nop
}},
1220 {STATE_RENDER(WINED3D_RS_ALPHAREF
), {STATE_RENDER(WINED3D_RS_ALPHAREF
), state_nop
}},
1221 {STATE_RENDER(WINED3D_RS_ALPHAFUNC
), {STATE_RENDER(WINED3D_RS_ALPHAFUNC
), state_nop
}},
1222 {STATE_RENDER(WINED3D_RS_FOGENABLE
), {STATE_RENDER(WINED3D_RS_FOGENABLE
), state_nop
}},
1223 {STATE_RENDER(WINED3D_RS_SPECULARENABLE
), {STATE_RENDER(WINED3D_RS_SPECULARENABLE
), state_nop
}},
1224 {STATE_RENDER(WINED3D_RS_FOGCOLOR
), {STATE_RENDER(WINED3D_RS_FOGCOLOR
), state_nop
}},
1225 {STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), {STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), state_nop
}},
1226 {STATE_RENDER(WINED3D_RS_FOGSTART
), {STATE_RENDER(WINED3D_RS_FOGSTART
), state_nop
}},
1227 {STATE_RENDER(WINED3D_RS_FOGEND
), {STATE_RENDER(WINED3D_RS_FOGEND
), state_nop
}},
1228 {STATE_RENDER(WINED3D_RS_FOGDENSITY
), {STATE_RENDER(WINED3D_RS_FOGDENSITY
), state_nop
}},
1229 {STATE_RENDER(WINED3D_RS_COLORKEYENABLE
), {STATE_RENDER(WINED3D_RS_COLORKEYENABLE
), state_nop
}},
1230 {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), state_nop
}},
1231 {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), state_nop
}},
1232 {STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), {STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), state_nop
}},
1233 {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
), {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
), state_nop
}},
1234 {STATE_POINT_ENABLE
, {STATE_POINT_ENABLE
, state_nop
}},
1235 {STATE_COLOR_KEY
, {STATE_COLOR_KEY
, state_nop
}},
1236 {0}, /* Terminate */
1239 static const struct wined3d_fragment_pipe_ops spirv_fragment_pipe_vk
=
1241 .fp_enable
= spirv_fragment_pipe_vk_fp_enable
,
1242 .get_caps
= spirv_fragment_pipe_vk_fp_get_caps
,
1243 .get_emul_mask
= spirv_fragment_pipe_vk_fp_get_emul_mask
,
1244 .alloc_private
= spirv_fragment_pipe_vk_fp_alloc
,
1245 .free_private
= spirv_fragment_pipe_vk_fp_free
,
1246 .allocate_context_data
= spirv_fragment_pipe_vk_fp_alloc_context_data
,
1247 .free_context_data
= spirv_fragment_pipe_vk_fp_free_context_data
,
1248 .color_fixup_supported
= shader_spirv_color_fixup_supported
,
1249 .states
= spirv_fragment_pipe_vk_fp_states
,
1252 const struct wined3d_fragment_pipe_ops
*wined3d_spirv_fragment_pipe_init_vk(void)
1254 return &spirv_fragment_pipe_vk
;