ReactOS 0.4.17-dev-923-g4c9a150
adapter_vk.c
Go to the documentation of this file.
1/*
2 * Copyright 2018 Henri Verbeet for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19#include "wined3d_private.h"
20#include "wined3d_vk.h"
21
22WINE_DEFAULT_DEBUG_CHANNEL(d3d);
23
24static const struct wined3d_state_entry_template misc_state_template_vk[] =
25{
26 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX), state_nop}},
27 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL), state_nop}},
28 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN), state_nop}},
29 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY), state_nop}},
30 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL), state_nop}},
31 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE), state_nop}},
32 {STATE_GRAPHICS_SHADER_RESOURCE_BINDING, {STATE_GRAPHICS_SHADER_RESOURCE_BINDING, state_nop}},
33 {STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING, {STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING, state_nop}},
34 {STATE_COMPUTE_SHADER_RESOURCE_BINDING, {STATE_COMPUTE_SHADER_RESOURCE_BINDING, state_nop}},
35 {STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING, {STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING, state_nop}},
36 {STATE_STREAM_OUTPUT, {STATE_STREAM_OUTPUT, state_nop}},
37 {STATE_BLEND, {STATE_BLEND, state_nop}},
38 {STATE_BLEND_FACTOR, {STATE_BLEND_FACTOR, state_nop}},
39 {STATE_SAMPLE_MASK, {STATE_SAMPLE_MASK, state_nop}},
40 {STATE_STREAMSRC, {STATE_STREAMSRC, state_nop}},
41 {STATE_VDECL, {STATE_VDECL, state_nop}},
42 {STATE_DEPTH_STENCIL, {STATE_DEPTH_STENCIL, state_nop}},
43 {STATE_STENCIL_REF, {STATE_STENCIL_REF, state_nop}},
44 {STATE_DEPTH_BOUNDS, {STATE_DEPTH_BOUNDS, state_nop}},
45 {STATE_RASTERIZER, {STATE_RASTERIZER, state_nop}},
46 {STATE_SCISSORRECT, {STATE_SCISSORRECT, state_nop}},
47 {STATE_VIEWPORT, {STATE_VIEWPORT, state_nop}},
48 {STATE_INDEXBUFFER, {STATE_INDEXBUFFER, state_nop}},
49 {STATE_RENDER(WINED3D_RS_LINEPATTERN), {STATE_RENDER(WINED3D_RS_LINEPATTERN), state_nop}},
50 {STATE_RENDER(WINED3D_RS_DITHERENABLE), {STATE_RENDER(WINED3D_RS_DITHERENABLE), state_nop}},
51 {STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), {STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), state_nop}},
52 {STATE_BASEVERTEXINDEX, {STATE_STREAMSRC}},
53 {STATE_FRAMEBUFFER, {STATE_FRAMEBUFFER, state_nop}},
54 {STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL), {STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL), state_nop}},
55 {STATE_SHADER(WINED3D_SHADER_TYPE_HULL), {STATE_SHADER(WINED3D_SHADER_TYPE_HULL), state_nop}},
56 {STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN), {STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN), state_nop}},
57 {STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY), {STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY), state_nop}},
58 {STATE_SHADER(WINED3D_SHADER_TYPE_COMPUTE), {STATE_SHADER(WINED3D_SHADER_TYPE_COMPUTE), state_nop}},
59 {0}, /* Terminate */
60};
61
62static inline const struct wined3d_adapter_vk *wined3d_adapter_vk_const(const struct wined3d_adapter *adapter)
63{
64 return CONTAINING_RECORD(adapter, struct wined3d_adapter_vk, a);
65}
66
67static const char *debug_vk_version(uint32_t version)
68{
69 return wine_dbg_sprintf("%u.%u.%u",
70 VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version), VK_VERSION_PATCH(version));
71}
72
73static HRESULT hresult_from_vk_result(VkResult vr)
74{
75 switch (vr)
76 {
77 case VK_SUCCESS:
78 return S_OK;
79 case VK_ERROR_OUT_OF_HOST_MEMORY:
80 WARN("Out of host memory.\n");
81 return E_OUTOFMEMORY;
82 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
83 WARN("Out of device memory.\n");
84 return E_OUTOFMEMORY;
85 case VK_ERROR_DEVICE_LOST:
86 WARN("Device lost.\n");
87 return E_FAIL;
88 case VK_ERROR_EXTENSION_NOT_PRESENT:
89 WARN("Extension not present.\n");
90 return E_FAIL;
91 default:
92 FIXME("Unhandled VkResult %d.\n", vr);
93 return E_FAIL;
94 }
95}
96
97static BOOL wined3d_load_vulkan(struct wined3d_vk_info *vk_info)
98{
99 struct vulkan_ops *vk_ops = &vk_info->vk_ops;
100
101 if (!(vk_info->vulkan_lib = LoadLibraryA("winevulkan.dll"))
102 && !(vk_info->vulkan_lib = LoadLibraryA("vulkan-1.dll")))
103 {
104 WARN("Failed to load vulkan-1.dll.\n");
105 return FALSE;
106 }
107
108 vk_ops->vkGetInstanceProcAddr = (void *)GetProcAddress(vk_info->vulkan_lib, "vkGetInstanceProcAddr");
109 if (!vk_ops->vkGetInstanceProcAddr)
110 {
111 FreeLibrary(vk_info->vulkan_lib);
112 return FALSE;
113 }
114
115 return TRUE;
116}
117
118static void wined3d_unload_vulkan(struct wined3d_vk_info *vk_info)
119{
120 if (vk_info->vulkan_lib)
121 {
122 FreeLibrary(vk_info->vulkan_lib);
123 vk_info->vulkan_lib = NULL;
124 }
125}
126
127static void adapter_vk_destroy(struct wined3d_adapter *adapter)
128{
129 struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk(adapter);
130 struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
131
132 VK_CALL(vkDestroyInstance(vk_info->instance, NULL));
133 wined3d_unload_vulkan(vk_info);
134 wined3d_adapter_cleanup(&adapter_vk->a);
135 free(adapter_vk->device_extensions);
136 free(adapter_vk);
137}
138
139static HRESULT wined3d_select_vulkan_queue_family(const struct wined3d_adapter_vk *adapter_vk,
140 uint32_t *queue_family_index, uint32_t *timestamp_bits)
141{
142 VkPhysicalDevice physical_device = adapter_vk->physical_device;
143 const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
144 VkQueueFamilyProperties *queue_properties;
145 uint32_t count, i;
146
147 VK_CALL(vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, NULL));
148
149 if (!(queue_properties = calloc(count, sizeof(*queue_properties))))
150 return E_OUTOFMEMORY;
151
152 VK_CALL(vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, queue_properties));
153
154 for (i = 0; i < count; ++i)
155 {
156 if (queue_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
157 {
158 *queue_family_index = i;
159 *timestamp_bits = queue_properties[i].timestampValidBits;
160 free(queue_properties);
161 return WINED3D_OK;
162 }
163 }
164 free(queue_properties);
165
166 WARN("Failed to find graphics queue.\n");
167 return E_FAIL;
168}
169
170struct wined3d_physical_device_info
171{
172 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state_features;
173 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT dynamic_state2_features;
174 VkPhysicalDeviceExtendedDynamicState3FeaturesEXT dynamic_state3_features;
175 VkPhysicalDeviceHostQueryResetFeatures host_query_reset_features;
176 VkPhysicalDeviceShaderDrawParametersFeatures draw_parameters_features;
177 VkPhysicalDeviceTransformFeedbackFeaturesEXT xfb_features;
178 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT vertex_divisor_features;
179
180 VkPhysicalDeviceFeatures2 features2;
181};
182
183static void wined3d_disable_vulkan_features(struct wined3d_physical_device_info *info)
184{
185 VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *dynamic_state3 = &info->dynamic_state3_features;
186 VkPhysicalDeviceFeatures *features = &info->features2.features;
187
188 features->depthBounds = VK_FALSE;
189 features->wideLines = VK_FALSE;
190 features->alphaToOne = VK_FALSE;
191 features->textureCompressionETC2 = VK_FALSE;
192 features->textureCompressionASTC_LDR = VK_FALSE;
193 features->shaderStorageImageMultisample = VK_FALSE;
194 features->shaderUniformBufferArrayDynamicIndexing = VK_FALSE;
195 features->shaderSampledImageArrayDynamicIndexing = VK_FALSE;
196 features->shaderStorageBufferArrayDynamicIndexing = VK_FALSE;
197 features->shaderStorageImageArrayDynamicIndexing = VK_FALSE;
198 features->shaderInt64 = VK_FALSE;
199 features->shaderInt16 = VK_FALSE;
200 features->shaderResourceResidency = VK_FALSE;
201 features->shaderResourceMinLod = VK_FALSE;
202 features->shaderTessellationAndGeometryPointSize = VK_FALSE;
203 features->sparseBinding = VK_FALSE;
204 features->sparseResidencyBuffer = VK_FALSE;
205 features->sparseResidencyImage2D = VK_FALSE;
206 features->sparseResidencyImage3D = VK_FALSE;
207 features->sparseResidency2Samples = VK_FALSE;
208 features->sparseResidency4Samples = VK_FALSE;
209 features->sparseResidency8Samples = VK_FALSE;
210 features->sparseResidency16Samples = VK_FALSE;
211 features->sparseResidencyAliased = VK_FALSE;
212 features->inheritedQueries = VK_FALSE;
213
214 dynamic_state3->extendedDynamicState3AlphaToOneEnable = VK_FALSE;
215 dynamic_state3->extendedDynamicState3ColorBlendAdvanced = VK_FALSE;
216 dynamic_state3->extendedDynamicState3ConservativeRasterizationMode = VK_FALSE;
217 dynamic_state3->extendedDynamicState3CoverageModulationMode = VK_FALSE;
218 dynamic_state3->extendedDynamicState3CoverageModulationTable = VK_FALSE;
219 dynamic_state3->extendedDynamicState3CoverageModulationTableEnable = VK_FALSE;
220 dynamic_state3->extendedDynamicState3CoverageReductionMode = VK_FALSE;
221 dynamic_state3->extendedDynamicState3CoverageToColorEnable = VK_FALSE;
222 dynamic_state3->extendedDynamicState3CoverageToColorLocation = VK_FALSE;
223 dynamic_state3->extendedDynamicState3DepthClipEnable = VK_FALSE;
224 dynamic_state3->extendedDynamicState3DepthClipNegativeOneToOne = VK_FALSE;
225 dynamic_state3->extendedDynamicState3ExtraPrimitiveOverestimationSize = VK_FALSE;
226 dynamic_state3->extendedDynamicState3LineRasterizationMode = VK_FALSE;
227 dynamic_state3->extendedDynamicState3LineStippleEnable = VK_FALSE;
228 dynamic_state3->extendedDynamicState3LogicOpEnable = VK_FALSE;
229 dynamic_state3->extendedDynamicState3PolygonMode = VK_FALSE;
230 dynamic_state3->extendedDynamicState3ProvokingVertexMode = VK_FALSE;
231 dynamic_state3->extendedDynamicState3RasterizationStream = VK_FALSE;
232 dynamic_state3->extendedDynamicState3RepresentativeFragmentTestEnable = VK_FALSE;
233 dynamic_state3->extendedDynamicState3SampleLocationsEnable = VK_FALSE;
234 dynamic_state3->extendedDynamicState3ShadingRateImageEnable = VK_FALSE;
235 dynamic_state3->extendedDynamicState3TessellationDomainOrigin = VK_FALSE;
236 dynamic_state3->extendedDynamicState3ViewportWScalingEnable = VK_FALSE;
237 dynamic_state3->extendedDynamicState3ViewportSwizzle = VK_FALSE;
238}
239
240static struct wined3d_allocator_chunk *wined3d_allocator_vk_create_chunk(struct wined3d_allocator *allocator,
241 struct wined3d_context *context, unsigned int memory_type, size_t chunk_size)
242{
243 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
244 struct wined3d_allocator_chunk_vk *chunk_vk;
245
246 if (!(chunk_vk = malloc(sizeof(*chunk_vk))))
247 return NULL;
248
249 if (!wined3d_allocator_chunk_init(&chunk_vk->c, allocator))
250 {
251 free(chunk_vk);
252 return NULL;
253 }
254
255 if (!(chunk_vk->vk_memory = wined3d_context_vk_allocate_vram_chunk_memory(context_vk, memory_type, chunk_size)))
256 {
257 wined3d_allocator_chunk_cleanup(&chunk_vk->c);
258 free(chunk_vk);
259 return NULL;
260 }
261 list_add_head(&allocator->pools[memory_type].chunks, &chunk_vk->c.entry);
262
263 return &chunk_vk->c;
264}
265
266static void wined3d_allocator_vk_destroy_chunk(struct wined3d_allocator_chunk *chunk)
267{
268 struct wined3d_allocator_chunk_vk *chunk_vk = wined3d_allocator_chunk_vk(chunk);
269 const struct wined3d_vk_info *vk_info;
270 struct wined3d_device_vk *device_vk;
271
272 TRACE("chunk %p.\n", chunk);
273
274 device_vk = wined3d_device_vk_from_allocator(chunk_vk->c.allocator);
275 vk_info = &device_vk->vk_info;
276
277 if (chunk_vk->c.map_ptr)
278 {
279 VK_CALL(vkUnmapMemory(device_vk->vk_device, chunk_vk->vk_memory));
280 adapter_adjust_mapped_memory(device_vk->d.adapter, -WINED3D_ALLOCATOR_CHUNK_SIZE);
281 }
282 VK_CALL(vkFreeMemory(device_vk->vk_device, chunk_vk->vk_memory, NULL));
283 TRACE("Freed memory 0x%s.\n", wine_dbgstr_longlong(chunk_vk->vk_memory));
284 wined3d_allocator_chunk_cleanup(&chunk_vk->c);
285 free(chunk_vk);
286}
287
288static const struct wined3d_allocator_ops wined3d_allocator_vk_ops =
289{
290 .allocator_create_chunk = wined3d_allocator_vk_create_chunk,
291 .allocator_destroy_chunk = wined3d_allocator_vk_destroy_chunk,
292};
293
294static void add_structure(VkPhysicalDeviceFeatures2 *features2, void *s)
295{
296 VkBaseOutStructure *base = s;
297
298 base->pNext = features2->pNext;
299 features2->pNext = base;
300}
301
302static void get_physical_device_info(const struct wined3d_adapter_vk *adapter_vk, struct wined3d_physical_device_info *info)
303{
304 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *vertex_divisor_features = &info->vertex_divisor_features;
305 VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *dynamic_state3_features = &info->dynamic_state3_features;
306 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *dynamic_state2_features = &info->dynamic_state2_features;
307 VkPhysicalDeviceShaderDrawParametersFeatures *draw_parameters_features = &info->draw_parameters_features;
308 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *dynamic_state_features = &info->dynamic_state_features;
309 VkPhysicalDeviceHostQueryResetFeatures *host_query_reset_features = &info->host_query_reset_features;
310 VkPhysicalDeviceTransformFeedbackFeaturesEXT *xfb_features = &info->xfb_features;
311 VkPhysicalDevice physical_device = adapter_vk->physical_device;
312 const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
313 VkPhysicalDeviceFeatures2 *features2 = &info->features2;
314
315 memset(info, 0, sizeof(*info));
316
317 draw_parameters_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
318 if (vk_info->api_version >= VK_API_VERSION_1_1)
319 add_structure(features2, draw_parameters_features);
320 else
321 draw_parameters_features->shaderDrawParameters = vk_info->supported[WINED3D_VK_KHR_SHADER_DRAW_PARAMETERS];
322
323 xfb_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
324 if (vk_info->supported[WINED3D_VK_EXT_TRANSFORM_FEEDBACK])
325 add_structure(features2, xfb_features);
326
327 vertex_divisor_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
328 if (vk_info->supported[WINED3D_VK_EXT_VERTEX_ATTRIBUTE_DIVISOR])
329 add_structure(features2, vertex_divisor_features);
330
331 host_query_reset_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
332 if (vk_info->supported[WINED3D_VK_EXT_HOST_QUERY_RESET])
333 add_structure(features2, host_query_reset_features);
334
335 dynamic_state3_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
336 if (vk_info->supported[WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE3])
337 add_structure(features2, dynamic_state3_features);
338
339 dynamic_state2_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
340 if (vk_info->supported[WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE2])
341 add_structure(features2, dynamic_state2_features);
342
343 dynamic_state_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
344 if (vk_info->supported[WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE])
345 add_structure(features2, dynamic_state_features);
346
347 features2->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
348
349 if (vk_info->vk_ops.vkGetPhysicalDeviceFeatures2)
350 VK_CALL(vkGetPhysicalDeviceFeatures2(physical_device, features2));
351 else
352 VK_CALL(vkGetPhysicalDeviceFeatures(physical_device, &features2->features));
353}
354
355static HRESULT adapter_vk_create_device(struct wined3d *wined3d, const struct wined3d_adapter *adapter,
356 enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment,
357 const enum wined3d_feature_level *levels, unsigned int level_count,
358 struct wined3d_device_parent *device_parent, struct wined3d_device **device)
359{
360 const struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk_const(adapter);
361 const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
362 struct wined3d_physical_device_info physical_device_info;
363 static const float priorities[] = {1.0f};
364 struct wined3d_device_vk *device_vk;
365 VkDevice vk_device = VK_NULL_HANDLE;
366 VkDeviceQueueCreateInfo queue_info;
367 VkPhysicalDevice physical_device;
368 VkDeviceCreateInfo device_info;
369 uint32_t queue_family_index;
370 uint32_t timestamp_bits;
371 VkResult vr;
372 HRESULT hr;
373
374 if (!(device_vk = calloc(1, sizeof(*device_vk))))
375 return E_OUTOFMEMORY;
376
377 if (FAILED(hr = wined3d_select_vulkan_queue_family(adapter_vk, &queue_family_index, &timestamp_bits)))
378 goto fail;
379
380 physical_device = adapter_vk->physical_device;
381
382 get_physical_device_info(adapter_vk, &physical_device_info);
383 wined3d_disable_vulkan_features(&physical_device_info);
384
385 queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
386 queue_info.pNext = NULL;
387 queue_info.flags = 0;
388 queue_info.queueFamilyIndex = queue_family_index;
389 queue_info.queueCount = ARRAY_SIZE(priorities);
390 queue_info.pQueuePriorities = priorities;
391
392 device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
393 device_info.pNext = physical_device_info.features2.pNext;
394 device_info.flags = 0;
395 device_info.queueCreateInfoCount = 1;
396 device_info.pQueueCreateInfos = &queue_info;
397 device_info.enabledLayerCount = 0;
398 device_info.ppEnabledLayerNames = NULL;
399 device_info.enabledExtensionCount = adapter_vk->device_extension_count;
400 device_info.ppEnabledExtensionNames = adapter_vk->device_extensions;
401 device_info.pEnabledFeatures = &physical_device_info.features2.features;
402
403 if ((vr = VK_CALL(vkCreateDevice(physical_device, &device_info, NULL, &vk_device))) < 0)
404 {
405 WARN("Failed to create Vulkan device, vr %s.\n", wined3d_debug_vkresult(vr));
406 vk_device = VK_NULL_HANDLE;
407 hr = hresult_from_vk_result(vr);
408 goto fail;
409 }
410
411 device_vk->vk_device = vk_device;
412 VK_CALL(vkGetDeviceQueue(vk_device, queue_family_index, 0, &device_vk->vk_queue));
413 device_vk->vk_queue_family_index = queue_family_index;
414 device_vk->timestamp_bits = timestamp_bits;
415
416 device_vk->vk_info = *vk_info;
417#define VK_DEVICE_PFN(name) \
418 if (!(device_vk->vk_info.vk_ops.name = (void *)VK_CALL(vkGetDeviceProcAddr(vk_device, #name)))) \
419 { \
420 WARN("Could not get device proc addr for '" #name "'.\n"); \
421 hr = E_FAIL; \
422 goto fail; \
423 }
424#define VK_DEVICE_EXT_PFN(name) \
425 device_vk->vk_info.vk_ops.name = (void *)VK_CALL(vkGetDeviceProcAddr(vk_device, #name));
426 VK_DEVICE_FUNCS()
427#undef VK_DEVICE_EXT_PFN
428#undef VK_DEVICE_PFN
429
430 if (!wined3d_allocator_init(&device_vk->allocator,
431 adapter_vk->memory_properties.memoryTypeCount, &wined3d_allocator_vk_ops))
432 {
433 WARN("Failed to initialise allocator.\n");
434 hr = E_FAIL;
435 goto fail;
436 }
437
438 if (FAILED(hr = wined3d_device_init(&device_vk->d, wined3d, adapter->ordinal, device_type, focus_window,
439 flags, surface_alignment, levels, level_count, vk_info->supported, device_parent)))
440 {
441 WARN("Failed to initialize device, hr %#lx.\n", hr);
442 wined3d_allocator_cleanup(&device_vk->allocator);
443 goto fail;
444 }
445
446 wined3d_lock_init(&device_vk->allocator_cs, "wined3d_device_vk.allocator_cs");
447
448 *device = &device_vk->d;
449
450 return WINED3D_OK;
451
452fail:
453 VK_CALL(vkDestroyDevice(vk_device, NULL));
454 free(device_vk);
455 return hr;
456}
457
458static void adapter_vk_destroy_device(struct wined3d_device *device)
459{
460 struct wined3d_device_vk *device_vk = wined3d_device_vk(device);
461 const struct wined3d_vk_info *vk_info = &device_vk->vk_info;
462
463 wined3d_device_cleanup(&device_vk->d);
464 wined3d_allocator_cleanup(&device_vk->allocator);
465
466 wined3d_lock_cleanup(&device_vk->allocator_cs);
467
468 VK_CALL(vkDestroyDevice(device_vk->vk_device, NULL));
469 free(device_vk);
470}
471
472static struct wined3d_context *adapter_vk_acquire_context(struct wined3d_device *device,
473 struct wined3d_texture *texture, unsigned int sub_resource_idx)
474{
475 TRACE("device %p, texture %p, sub_resource_idx %u.\n", device, texture, sub_resource_idx);
476
477 wined3d_from_cs(device->cs);
478
479 if (!device->context_count)
480 return NULL;
481
482 return &wined3d_device_vk(device)->context_vk.c;
483}
484
485static void adapter_vk_release_context(struct wined3d_context *context)
486{
487 TRACE("context %p.\n", context);
488}
489
490static void adapter_vk_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps)
491{
492 const struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk_const(adapter);
493 const VkPhysicalDeviceLimits *limits = &adapter_vk->device_limits;
494 bool sampler_anisotropy = limits->maxSamplerAnisotropy > 1.0f;
495 const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
496
497 caps->ddraw_caps.dds_caps |= WINEDDSCAPS_BACKBUFFER
498 | WINEDDSCAPS_COMPLEX
499 | WINEDDSCAPS_FRONTBUFFER
500 | WINEDDSCAPS_3DDEVICE
501 | WINEDDSCAPS_VIDEOMEMORY
502 | WINEDDSCAPS_OWNDC
503 | WINEDDSCAPS_LOCALVIDMEM
504 | WINEDDSCAPS_NONLOCALVIDMEM;
505 caps->ddraw_caps.caps |= WINEDDCAPS_3D;
506
507 caps->Caps2 |= WINED3DCAPS2_CANGENMIPMAP;
508
509 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_BLENDOP
510 | WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
511 | WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
512 | WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT
513 | WINED3DPMISCCAPS_SEPARATEALPHABLEND;
514
515 caps->RasterCaps |= WINED3DPRASTERCAPS_MIPMAPLODBIAS;
516
517 if (sampler_anisotropy)
518 {
519 caps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY;
520
521 caps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
522 | WINED3DPTFILTERCAPS_MINFANISOTROPIC;
523
524 caps->MaxAnisotropy = limits->maxSamplerAnisotropy;
525 }
526
527 caps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
528 caps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR
529 | WINED3DPBLENDCAPS_SRCALPHASAT;
530
531 caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP
532 | WINED3DPTEXTURECAPS_MIPVOLUMEMAP
533 | WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
534 caps->VolumeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR
535 | WINED3DPTFILTERCAPS_MAGFPOINT
536 | WINED3DPTFILTERCAPS_MINFLINEAR
537 | WINED3DPTFILTERCAPS_MINFPOINT
538 | WINED3DPTFILTERCAPS_MIPFLINEAR
539 | WINED3DPTFILTERCAPS_MIPFPOINT
540 | WINED3DPTFILTERCAPS_LINEAR
541 | WINED3DPTFILTERCAPS_LINEARMIPLINEAR
542 | WINED3DPTFILTERCAPS_LINEARMIPNEAREST
543 | WINED3DPTFILTERCAPS_MIPLINEAR
544 | WINED3DPTFILTERCAPS_MIPNEAREST
545 | WINED3DPTFILTERCAPS_NEAREST;
546 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_INDEPENDENTUV
547 | WINED3DPTADDRESSCAPS_CLAMP
548 | WINED3DPTADDRESSCAPS_WRAP;
549 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER
550 | WINED3DPTADDRESSCAPS_MIRROR;
551 if (vk_info->supported[WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE])
552 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
553
554 caps->MaxVolumeExtent = limits->maxImageDimension3D;
555
556 caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP
557 | WINED3DPTEXTURECAPS_MIPCUBEMAP
558 | WINED3DPTEXTURECAPS_CUBEMAP_POW2;
559 caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR
560 | WINED3DPTFILTERCAPS_MAGFPOINT
561 | WINED3DPTFILTERCAPS_MINFLINEAR
562 | WINED3DPTFILTERCAPS_MINFPOINT
563 | WINED3DPTFILTERCAPS_MIPFLINEAR
564 | WINED3DPTFILTERCAPS_MIPFPOINT
565 | WINED3DPTFILTERCAPS_LINEAR
566 | WINED3DPTFILTERCAPS_LINEARMIPLINEAR
567 | WINED3DPTFILTERCAPS_LINEARMIPNEAREST
568 | WINED3DPTFILTERCAPS_MIPLINEAR
569 | WINED3DPTFILTERCAPS_MIPNEAREST
570 | WINED3DPTFILTERCAPS_NEAREST;
571
572 if (sampler_anisotropy)
573 {
574 caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
575 | WINED3DPTFILTERCAPS_MINFANISOTROPIC;
576 }
577
578 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER
579 | WINED3DPTADDRESSCAPS_MIRROR;
580 if (vk_info->supported[WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE])
581 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
582
583 caps->StencilCaps |= WINED3DSTENCILCAPS_DECR
584 | WINED3DSTENCILCAPS_INCR
585 | WINED3DSTENCILCAPS_TWOSIDED;
586
587 caps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 | WINED3DDTCAPS_FLOAT16_4;
588
589 caps->MaxPixelShader30InstructionSlots = WINED3DMAX30SHADERINSTRUCTIONS;
590 caps->MaxVertexShader30InstructionSlots = WINED3DMAX30SHADERINSTRUCTIONS;
591 caps->PS20Caps.temp_count = WINED3DPS20_MAX_NUMTEMPS;
592 caps->VS20Caps.temp_count = WINED3DVS20_MAX_NUMTEMPS;
593}
594
595static BOOL adapter_vk_check_format(const struct wined3d_adapter *adapter,
596 const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format,
597 const struct wined3d_format *ds_format)
598{
599 return TRUE;
600}
601
602static HRESULT adapter_vk_init_3d(struct wined3d_device *device)
603{
604 struct wined3d_context_vk *context_vk;
605 struct wined3d_device_vk *device_vk;
606 HRESULT hr;
607
608 TRACE("device %p.\n", device);
609
610 device_vk = wined3d_device_vk(device);
611 context_vk = &device_vk->context_vk;
612 if (FAILED(hr = wined3d_context_vk_init(context_vk, device->swapchains[0])))
613 {
614 WARN("Failed to initialise context.\n");
615 return hr;
616 }
617
618 if (FAILED(hr = device->shader_backend->shader_alloc_private(device,
619 device->adapter->vertex_pipe, device->adapter->fragment_pipe)))
620 {
621 ERR("Failed to allocate shader private data, hr %#lx.\n", hr);
622 wined3d_context_vk_cleanup(context_vk);
623 return hr;
624 }
625
626 if (!device_context_add(device, &context_vk->c))
627 {
628 ERR("Failed to add the newly created context to the context list.\n");
629 device->shader_backend->shader_free_private(device, NULL);
630 wined3d_context_vk_cleanup(context_vk);
631 return E_FAIL;
632 }
633
634 TRACE("Initialised context %p.\n", context_vk);
635
636 if (!(device_vk->d.blitter = wined3d_cpu_blitter_create()))
637 {
638 ERR("Failed to create CPU blitter.\n");
639 device_context_remove(device, &context_vk->c);
640 device->shader_backend->shader_free_private(device, NULL);
641 wined3d_context_vk_cleanup(context_vk);
642 return E_FAIL;
643 }
644 wined3d_vk_blitter_create(&device_vk->d.blitter);
645
646 wined3d_device_create_default_samplers(device, &context_vk->c);
647 wined3d_device_vk_create_null_resources(device_vk, context_vk);
648 wined3d_device_vk_create_null_views(device_vk, context_vk);
649 if (device->adapter->d3d_info.feature_level >= WINED3D_FEATURE_LEVEL_11)
650 wined3d_device_vk_uav_clear_state_init(device_vk);
651
652 return WINED3D_OK;
653}
654
655static void adapter_vk_uninit_3d_cs(void *object)
656{
657 struct wined3d_device_vk *device_vk = object;
658 struct wined3d_context_vk *context_vk;
659 struct wined3d_device *device;
660 struct wined3d_shader *shader;
661
662 TRACE("device_vk %p.\n", device_vk);
663
664 context_vk = &device_vk->context_vk;
665 device = &device_vk->d;
666
667 LIST_FOR_EACH_ENTRY(shader, &device->shaders, struct wined3d_shader, shader_list_entry)
668 {
669 device->shader_backend->shader_destroy(shader);
670 }
671
672 if (device->adapter->d3d_info.feature_level >= WINED3D_FEATURE_LEVEL_11)
673 wined3d_device_vk_uav_clear_state_cleanup(device_vk);
674 device->blitter->ops->blitter_destroy(device->blitter, NULL);
675 device->shader_backend->shader_free_private(device, &context_vk->c);
676 wined3d_device_vk_destroy_null_views(device_vk, context_vk);
677 wined3d_device_vk_destroy_null_resources(device_vk, context_vk);
678}
679
680static void adapter_vk_uninit_3d(struct wined3d_device *device)
681{
682 struct wined3d_context_vk *context_vk;
683 struct wined3d_device_vk *device_vk;
684
685 TRACE("device %p.\n", device);
686
687 device_vk = wined3d_device_vk(device);
688 context_vk = &device_vk->context_vk;
689
690 wined3d_device_destroy_default_samplers(device);
691 wined3d_cs_destroy_object(device->cs, adapter_vk_uninit_3d_cs, device_vk);
692 wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
693
694 device_context_remove(device, &context_vk->c);
695 wined3d_context_vk_cleanup(context_vk);
696}
697
698static void *wined3d_bo_vk_map(struct wined3d_bo_vk *bo, struct wined3d_context_vk *context_vk)
699{
700 const struct wined3d_vk_info *vk_info;
701 struct wined3d_device_vk *device_vk;
702 struct wined3d_bo_slab_vk *slab;
703 VkResult vr;
704
705 if (bo->b.map_ptr)
706 return bo->b.map_ptr;
707
708 vk_info = context_vk->vk_info;
709 device_vk = wined3d_device_vk(context_vk->c.device);
710
711 if ((slab = bo->slab))
712 {
713 if (!(bo->b.map_ptr = wined3d_bo_slab_vk_map(slab, context_vk)))
714 {
715 ERR("Failed to map slab.\n");
716 return NULL;
717 }
718 }
719 else if (bo->memory)
720 {
721 struct wined3d_allocator_chunk_vk *chunk_vk = wined3d_allocator_chunk_vk(bo->memory->chunk);
722
723 if (!(bo->b.map_ptr = wined3d_allocator_chunk_vk_map(chunk_vk, context_vk)))
724 {
725 ERR("Failed to map chunk.\n");
726 return NULL;
727 }
728 }
729 else
730 {
731 if ((vr = VK_CALL(vkMapMemory(device_vk->vk_device, bo->vk_memory, 0, VK_WHOLE_SIZE, 0, &bo->b.map_ptr))) < 0)
732 {
733 ERR("Failed to map memory, vr %s.\n", wined3d_debug_vkresult(vr));
734 return NULL;
735 }
736
737 adapter_adjust_mapped_memory(device_vk->d.adapter, bo->size);
738 }
739
740 return bo->b.map_ptr;
741}
742
743static void wined3d_bo_vk_unmap(struct wined3d_bo_vk *bo, struct wined3d_context_vk *context_vk)
744{
745 struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
746 const struct wined3d_vk_info *vk_info;
747 struct wined3d_bo_slab_vk *slab;
748
749 /* This may race with the client thread, but it's not a hard limit anyway. */
750 if (device_vk->d.adapter->mapped_size <= MAX_PERSISTENT_MAPPED_BYTES)
751 {
752 TRACE("Not unmapping BO %p.\n", bo);
753 return;
754 }
755
756 wined3d_device_bo_map_lock(context_vk->c.device);
757 /* The mapping is still in use by the client (viz. for an accelerated
758 * NOOVERWRITE map). The client will trigger another unmap request when the
759 * d3d application requests to unmap the BO. */
760 if (bo->b.client_map_count)
761 {
762 wined3d_device_bo_map_unlock(context_vk->c.device);
763 TRACE("BO %p is still in use by a client thread; not unmapping.\n", bo);
764 return;
765 }
766 bo->b.map_ptr = NULL;
767 wined3d_device_bo_map_unlock(context_vk->c.device);
768
769 if ((slab = bo->slab))
770 {
771 wined3d_bo_slab_vk_unmap(slab, context_vk);
772 return;
773 }
774
775 if (bo->memory)
776 {
777 wined3d_allocator_chunk_vk_unmap(wined3d_allocator_chunk_vk(bo->memory->chunk), context_vk);
778 return;
779 }
780
781 vk_info = context_vk->vk_info;
782 VK_CALL(vkUnmapMemory(device_vk->vk_device, bo->vk_memory));
783 adapter_adjust_mapped_memory(device_vk->d.adapter, -bo->size);
784}
785
786static void wined3d_bo_slab_vk_lock(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
787{
788 wined3d_device_vk_allocator_lock(wined3d_device_vk(context_vk->c.device));
789}
790
791static void wined3d_bo_slab_vk_unlock(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
792{
793 wined3d_device_vk_allocator_unlock(wined3d_device_vk(context_vk->c.device));
794}
795
796void *wined3d_bo_slab_vk_map(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
797{
798 void *map_ptr;
799
800 TRACE("slab_vk %p, context_vk %p.\n", slab_vk, context_vk);
801
802 wined3d_bo_slab_vk_lock(slab_vk, context_vk);
803
804 if (!slab_vk->map_ptr && !(slab_vk->map_ptr = wined3d_bo_vk_map(&slab_vk->bo, context_vk)))
805 {
806 wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
807 ERR("Failed to map slab.\n");
808 return NULL;
809 }
810
811 ++slab_vk->map_count;
812 map_ptr = slab_vk->map_ptr;
813
814 wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
815
816 return map_ptr;
817}
818
819void wined3d_bo_slab_vk_unmap(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
820{
821 wined3d_bo_slab_vk_lock(slab_vk, context_vk);
822
823 if (--slab_vk->map_count)
824 {
825 wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
826 return;
827 }
828
829 wined3d_bo_vk_unmap(&slab_vk->bo, context_vk);
830 slab_vk->map_ptr = NULL;
831
832 wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
833}
834
835VkAccessFlags vk_access_mask_from_buffer_usage(VkBufferUsageFlags usage)
836{
837 VkAccessFlags flags = 0;
838
839 if (usage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
840 flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
841 if (usage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
842 flags |= VK_ACCESS_INDEX_READ_BIT;
843 if (usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
844 flags |= VK_ACCESS_UNIFORM_READ_BIT;
845 if (usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
846 flags |= VK_ACCESS_SHADER_READ_BIT;
847 if (usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)
848 flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
849 if (usage & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)
850 flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
851 if (usage & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT)
852 flags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
853 if (usage & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT)
854 flags |= VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
855 | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
856 if (usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
857 flags |= VK_ACCESS_TRANSFER_READ_BIT;
858 if (usage & VK_BUFFER_USAGE_TRANSFER_DST_BIT)
859 flags |= VK_ACCESS_TRANSFER_WRITE_BIT;
860
861 return flags;
862}
863
864VkPipelineStageFlags vk_pipeline_stage_mask_from_buffer_usage(VkBufferUsageFlags usage)
865{
866 VkPipelineStageFlags flags = 0;
867
868 if (usage & (VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT))
869 flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
870 if (usage & (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
871 | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT))
872 flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
873 | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
874 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
875 | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
876 if (usage & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)
877 flags |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
878 if (usage & (VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT
879 | VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT))
880 flags |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
881 if (usage & (VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT))
882 flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;
883
884 return flags;
885}
886
887static void *adapter_vk_map_bo_address(struct wined3d_context *context,
888 const struct wined3d_bo_address *data, size_t size, uint32_t map_flags)
889{
890 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
891 const struct wined3d_vk_info *vk_info;
892 struct wined3d_device_vk *device_vk;
893 VkCommandBuffer vk_command_buffer;
894 VkBufferMemoryBarrier vk_barrier;
895 struct wined3d_bo_user *bo_user;
896 struct wined3d_bo_vk *bo, tmp;
897 VkMappedMemoryRange range;
898 void *map_ptr;
899
900 if (!data->buffer_object)
901 return data->addr;
902 bo = wined3d_bo_vk(data->buffer_object);
903
904 vk_info = context_vk->vk_info;
905 device_vk = wined3d_device_vk(context->device);
906
907 if (map_flags & WINED3D_MAP_NOOVERWRITE)
908 goto map;
909
910 if ((map_flags & WINED3D_MAP_DISCARD) && bo->command_buffer_id > context_vk->completed_command_buffer_id)
911 {
912 if (wined3d_context_vk_create_bo(context_vk, bo->size, bo->usage, bo->memory_type, &tmp))
913 {
914 bool host_synced = bo->host_synced;
915
916 LIST_FOR_EACH_ENTRY(bo_user, &bo->b.users, struct wined3d_bo_user, entry)
917 bo_user->valid = false;
918 list_init(&bo->b.users);
919
920 wined3d_context_vk_destroy_bo(context_vk, bo);
921 *bo = tmp;
922 bo->host_synced = host_synced;
923 list_init(&bo->b.users);
924
925 goto map;
926 }
927
928 ERR("Failed to create new buffer object.\n");
929 }
930
931 if (map_flags & WINED3D_MAP_READ)
932 {
933 if (!bo->host_synced)
934 {
935 if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
936 {
937 ERR("Failed to get command buffer.\n");
938 return NULL;
939 }
940
941 wined3d_context_vk_end_current_render_pass(context_vk);
942
943 vk_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
944 vk_barrier.pNext = NULL;
945 vk_barrier.srcAccessMask = vk_access_mask_from_buffer_usage(bo->usage);
946 vk_barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
947 vk_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
948 vk_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
949 vk_barrier.buffer = bo->vk_buffer;
950 vk_barrier.offset = bo->b.buffer_offset + (uintptr_t)data->addr;
951 vk_barrier.size = size;
952 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
953 VK_PIPELINE_STAGE_HOST_BIT, 0, 0, NULL, 1, &vk_barrier, 0, NULL));
954
955 wined3d_context_vk_reference_bo(context_vk, bo);
956 }
957
958 if (!bo->b.coherent)
959 {
960 range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
961 range.pNext = NULL;
962 range.memory = bo->vk_memory;
963 range.offset = bo->b.memory_offset + (uintptr_t)data->addr;
964 range.size = size;
965 VK_CALL(vkInvalidateMappedMemoryRanges(device_vk->vk_device, 1, &range));
966 }
967 }
968
969 if (bo->command_buffer_id == context_vk->current_command_buffer.id)
970 wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL);
971 wined3d_context_vk_wait_command_buffer(context_vk, bo->command_buffer_id);
972
973map:
974 if (!(map_ptr = wined3d_bo_vk_map(bo, context_vk)))
975 {
976 ERR("Failed to map bo.\n");
977 return NULL;
978 }
979
980 return (uint8_t *)map_ptr + bo->b.memory_offset + (uintptr_t)data->addr;
981}
982
983static void flush_bo_range(struct wined3d_context_vk *context_vk,
984 struct wined3d_bo_vk *bo, unsigned int offset, unsigned int size)
985{
986 struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
987 const struct wined3d_vk_info *vk_info = context_vk->vk_info;
988 VkMappedMemoryRange range;
989
990 range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
991 range.pNext = NULL;
992 range.memory = bo->vk_memory;
993 range.offset = bo->b.memory_offset + offset;
994 range.size = size;
995 VK_CALL(vkFlushMappedMemoryRanges(device_vk->vk_device, 1, &range));
996}
997
998static void adapter_vk_unmap_bo_address(struct wined3d_context *context,
999 const struct wined3d_bo_address *data, unsigned int range_count, const struct wined3d_range *ranges)
1000{
1001 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
1002 struct wined3d_bo_vk *bo;
1003 unsigned int i;
1004
1005 if (!data->buffer_object)
1006 return;
1007 bo = wined3d_bo_vk(data->buffer_object);
1008
1009 assert(bo->b.map_ptr);
1010
1011 if (!bo->b.coherent)
1012 {
1013 for (i = 0; i < range_count; ++i)
1014 flush_bo_range(context_vk, bo, ranges[i].offset, ranges[i].size);
1015 }
1016
1017 wined3d_bo_vk_unmap(bo, context_vk);
1018}
1019
1020void adapter_vk_copy_bo_address(struct wined3d_context *context,
1021 const struct wined3d_bo_address *dst, const struct wined3d_bo_address *src,
1022 unsigned int range_count, const struct wined3d_range *ranges, uint32_t map_flags)
1023{
1024 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
1025 const struct wined3d_vk_info *vk_info = context_vk->vk_info;
1026 struct wined3d_bo_vk staging_bo, *src_bo, *dst_bo;
1027 VkAccessFlags src_access_mask, dst_access_mask;
1028 VkBufferMemoryBarrier vk_barrier[2];
1029 const struct wined3d_range *range;
1030 struct wined3d_bo_address staging;
1031 VkCommandBuffer vk_command_buffer;
1032 uint8_t *dst_ptr, *src_ptr;
1033 VkBufferCopy region;
1034 size_t size = 0;
1035 unsigned int i;
1036
1037 src_bo = src->buffer_object ? wined3d_bo_vk(src->buffer_object) : NULL;
1038 dst_bo = dst->buffer_object ? wined3d_bo_vk(dst->buffer_object) : NULL;
1039
1040 if (src_bo && dst_bo)
1041 {
1042 if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
1043 {
1044 ERR("Failed to get command buffer.\n");
1045 return;
1046 }
1047
1048 wined3d_context_vk_end_current_render_pass(context_vk);
1049
1050 src_access_mask = vk_access_mask_from_buffer_usage(src_bo->usage);
1051 dst_access_mask = vk_access_mask_from_buffer_usage(dst_bo->usage);
1052
1053 vk_barrier[0].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
1054 vk_barrier[0].pNext = NULL;
1055 vk_barrier[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1056 vk_barrier[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1057 vk_barrier[0].buffer = src_bo->vk_buffer;
1058
1059 vk_barrier[1].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
1060 vk_barrier[1].pNext = NULL;
1061 vk_barrier[1].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1062 vk_barrier[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1063 vk_barrier[1].buffer = dst_bo->vk_buffer;
1064
1065 for (i = 0; i < range_count; ++i)
1066 {
1067 range = &ranges[i];
1068
1069 region.srcOffset = src_bo->b.buffer_offset + (uintptr_t)src->addr + range->offset;
1070 region.dstOffset = dst_bo->b.buffer_offset + (uintptr_t)dst->addr + range->offset;
1071 region.size = range->size;
1072
1073 vk_barrier[0].offset = region.srcOffset;
1074 vk_barrier[0].size = region.size;
1075
1076 vk_barrier[1].offset = region.dstOffset;
1077 vk_barrier[1].size = region.size;
1078
1079 vk_barrier[0].srcAccessMask = src_access_mask;
1080 vk_barrier[0].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1081
1082 vk_barrier[1].srcAccessMask = dst_access_mask;
1083 vk_barrier[1].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1084
1085 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
1086 VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL));
1087
1088 VK_CALL(vkCmdCopyBuffer(vk_command_buffer, src_bo->vk_buffer, dst_bo->vk_buffer, 1, &region));
1089
1090 vk_barrier[0].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1091 vk_barrier[0].dstAccessMask = src_access_mask;
1092
1093 vk_barrier[1].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1094 vk_barrier[1].dstAccessMask = dst_access_mask;
1095
1096 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
1097 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL));
1098 }
1099
1100 wined3d_context_vk_reference_bo(context_vk, src_bo);
1101 wined3d_context_vk_reference_bo(context_vk, dst_bo);
1102
1103 return;
1104 }
1105
1106 for (i = 0; i < range_count; ++i)
1107 size = max(size, ranges[i].offset + ranges[i].size);
1108
1109 if (src_bo && !(src_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
1110 {
1111 if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
1112 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)))
1113 {
1114 ERR("Failed to create staging bo.\n");
1115 return;
1116 }
1117
1118 staging.buffer_object = &staging_bo.b;
1119 staging.addr = NULL;
1120 adapter_vk_copy_bo_address(context, &staging, src, range_count, ranges, WINED3D_MAP_WRITE);
1121 adapter_vk_copy_bo_address(context, dst, &staging, range_count, ranges, WINED3D_MAP_WRITE);
1122
1123 wined3d_context_vk_destroy_bo(context_vk, &staging_bo);
1124
1125 return;
1126 }
1127
1128 if (dst_bo && (!(dst_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) || (!(map_flags & WINED3D_MAP_DISCARD)
1129 && dst_bo->command_buffer_id > context_vk->completed_command_buffer_id)))
1130 {
1131 if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
1132 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)))
1133 {
1134 ERR("Failed to create staging bo.\n");
1135 return;
1136 }
1137
1138 staging.buffer_object = &staging_bo.b;
1139 staging.addr = NULL;
1140 adapter_vk_copy_bo_address(context, &staging, src, range_count, ranges, WINED3D_MAP_WRITE);
1141 adapter_vk_copy_bo_address(context, dst, &staging, range_count, ranges, WINED3D_MAP_WRITE);
1142
1143 wined3d_context_vk_destroy_bo(context_vk, &staging_bo);
1144
1145 return;
1146 }
1147
1148 src_ptr = adapter_vk_map_bo_address(context, src, size, WINED3D_MAP_READ);
1149 dst_ptr = adapter_vk_map_bo_address(context, dst, size, map_flags);
1150
1151 for (i = 0; i < range_count; ++i)
1152 memcpy(dst_ptr + ranges[i].offset, src_ptr + ranges[i].offset, ranges[i].size);
1153
1154 adapter_vk_unmap_bo_address(context, dst, range_count, ranges);
1155 adapter_vk_unmap_bo_address(context, src, 0, NULL);
1156}
1157
1158static void adapter_vk_flush_bo_address(struct wined3d_context *context,
1159 const struct wined3d_const_bo_address *data, size_t size)
1160{
1161 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
1162 struct wined3d_bo *bo;
1163
1164 if (!(bo = data->buffer_object))
1165 return;
1166
1167 flush_bo_range(context_vk, wined3d_bo_vk(bo), (uintptr_t)data->addr, size);
1168}
1169
1170static bool adapter_vk_alloc_bo(struct wined3d_device *device, struct wined3d_resource *resource,
1171 unsigned int sub_resource_idx, struct wined3d_bo_address *addr)
1172{
1173 struct wined3d_device_vk *device_vk = wined3d_device_vk(device);
1174 struct wined3d_context_vk *context_vk = &device_vk->context_vk;
1175 VkMemoryPropertyFlags memory_type;
1176 VkBufferUsageFlags buffer_usage;
1177 struct wined3d_bo_vk *bo_vk;
1178 VkDeviceSize size;
1179
1180 wined3d_not_from_cs(device->cs);
1181 assert(device->context_count);
1182
1183 if (resource->type == WINED3D_RTYPE_BUFFER)
1184 {
1185 buffer_usage = vk_buffer_usage_from_bind_flags(resource->bind_flags);
1186 memory_type = vk_memory_type_from_access_flags(resource->access, resource->usage);
1187 size = resource->size;
1188 }
1189 else
1190 {
1191 struct wined3d_texture *texture = texture_from_resource(resource);
1192
1193 buffer_usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
1194 memory_type = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
1195 size = texture->sub_resources[sub_resource_idx].size;
1196 }
1197
1198 if (!(bo_vk = malloc(sizeof(*bo_vk))))
1199 return false;
1200
1201 if (!(wined3d_context_vk_create_bo(context_vk, size, buffer_usage, memory_type, bo_vk)))
1202 {
1203 WARN("Failed to create Vulkan buffer.\n");
1204 free(bo_vk);
1205 return false;
1206 }
1207
1208 if (!bo_vk->b.map_ptr)
1209 {
1210 if (!wined3d_bo_vk_map(bo_vk, context_vk))
1211 ERR("Failed to map bo.\n");
1212 }
1213
1214 addr->buffer_object = &bo_vk->b;
1215 addr->addr = NULL;
1216 return true;
1217}
1218
1219static void adapter_vk_destroy_bo(struct wined3d_context *context, struct wined3d_bo *bo)
1220{
1221 wined3d_context_vk_destroy_bo(wined3d_context_vk(context), wined3d_bo_vk(bo));
1222}
1223
1224static HRESULT adapter_vk_create_swapchain(struct wined3d_device *device,
1225 const struct wined3d_swapchain_desc *desc, struct wined3d_swapchain_state_parent *state_parent,
1226 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_swapchain **swapchain)
1227{
1228 struct wined3d_swapchain_vk *swapchain_vk;
1229 HRESULT hr;
1230
1231 TRACE("device %p, desc %p, state_parent %p, parent %p, parent_ops %p, swapchain %p.\n",
1232 device, desc, state_parent, parent, parent_ops, swapchain);
1233
1234 if (!(swapchain_vk = calloc(1, sizeof(*swapchain_vk))))
1235 return E_OUTOFMEMORY;
1236
1237 if (FAILED(hr = wined3d_swapchain_vk_init(swapchain_vk, device, desc, state_parent, parent,
1238 parent_ops)))
1239 {
1240 WARN("Failed to initialise swapchain, hr %#lx.\n", hr);
1241 free(swapchain_vk);
1242 return hr;
1243 }
1244
1245 TRACE("Created swapchain %p.\n", swapchain_vk);
1246 *swapchain = &swapchain_vk->s;
1247
1248 return hr;
1249}
1250
1251static void adapter_vk_destroy_swapchain(struct wined3d_swapchain *swapchain)
1252{
1253 struct wined3d_swapchain_vk *swapchain_vk = wined3d_swapchain_vk(swapchain);
1254
1255 wined3d_swapchain_vk_cleanup(swapchain_vk);
1256 free(swapchain_vk);
1257}
1258
1259unsigned int wined3d_adapter_vk_get_memory_type_index(const struct wined3d_adapter_vk *adapter_vk,
1260 uint32_t memory_type_mask, VkMemoryPropertyFlags flags)
1261{
1262 const VkPhysicalDeviceMemoryProperties *memory_info = &adapter_vk->memory_properties;
1263 unsigned int i;
1264
1265 for (i = 0; i < memory_info->memoryTypeCount; ++i)
1266 {
1267 if (!(memory_type_mask & (1u << i)))
1268 continue;
1269 if ((memory_info->memoryTypes[i].propertyFlags & flags) == flags)
1270 return i;
1271 }
1272
1273 return ~0u;
1274}
1275
1276static HRESULT adapter_vk_create_buffer(struct wined3d_device *device,
1277 const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data,
1278 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_buffer **buffer)
1279{
1280 struct wined3d_buffer_vk *buffer_vk;
1281 HRESULT hr;
1282
1283 TRACE("device %p, desc %p, data %p, parent %p, parent_ops %p, buffer %p.\n",
1284 device, desc, data, parent, parent_ops, buffer);
1285
1286 if (!(buffer_vk = calloc(1, sizeof(*buffer_vk))))
1287 return E_OUTOFMEMORY;
1288
1289 if (FAILED(hr = wined3d_buffer_vk_init(buffer_vk, device, desc, data, parent, parent_ops)))
1290 {
1291 WARN("Failed to initialise buffer, hr %#lx.\n", hr);
1292 free(buffer_vk);
1293 return hr;
1294 }
1295
1296 TRACE("Created buffer %p.\n", buffer_vk);
1297 *buffer = &buffer_vk->b;
1298
1299 return hr;
1300}
1301
1302static void adapter_vk_destroy_buffer(struct wined3d_buffer *buffer)
1303{
1304 struct wined3d_buffer_vk *buffer_vk = wined3d_buffer_vk(buffer);
1305 struct wined3d_device *device = buffer_vk->b.resource.device;
1306 unsigned int swapchain_count = device->swapchain_count;
1307
1308 TRACE("buffer_vk %p.\n", buffer_vk);
1309
1310 /* Take a reference to the device, in case releasing the buffer would
1311 * cause the device to be destroyed. However, swapchain resources don't
1312 * take a reference to the device, and we wouldn't want to increment the
1313 * refcount on a device that's in the process of being destroyed. */
1314 if (swapchain_count)
1315 wined3d_device_incref(device);
1316 wined3d_buffer_cleanup(&buffer_vk->b);
1317 wined3d_cs_destroy_object(device->cs, free, buffer_vk);
1318 if (swapchain_count)
1319 wined3d_device_decref(device);
1320}
1321
1322static HRESULT adapter_vk_create_texture(struct wined3d_device *device,
1323 const struct wined3d_resource_desc *desc, unsigned int layer_count, unsigned int level_count,
1324 uint32_t flags, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_texture **texture)
1325{
1326 struct wined3d_texture_vk *texture_vk;
1327 HRESULT hr;
1328
1329 TRACE("device %p, desc %p, layer_count %u, level_count %u, flags %#x, parent %p, parent_ops %p, texture %p.\n",
1330 device, desc, layer_count, level_count, flags, parent, parent_ops, texture);
1331
1332 if (!(texture_vk = wined3d_texture_allocate_object_memory(sizeof(*texture_vk), level_count, layer_count)))
1333 return E_OUTOFMEMORY;
1334
1335 if (FAILED(hr = wined3d_texture_vk_init(texture_vk, device, desc,
1336 layer_count, level_count, flags, parent, parent_ops)))
1337 {
1338 WARN("Failed to initialise texture, hr %#lx.\n", hr);
1339 free(texture_vk);
1340 return hr;
1341 }
1342
1343 TRACE("Created texture %p.\n", texture_vk);
1344 *texture = &texture_vk->t;
1345
1346 return hr;
1347}
1348
1349static void adapter_vk_destroy_texture(struct wined3d_texture *texture)
1350{
1351 struct wined3d_texture_vk *texture_vk = wined3d_texture_vk(texture);
1352 struct wined3d_device *device = texture_vk->t.resource.device;
1353 unsigned int swapchain_count = device->swapchain_count;
1354
1355 TRACE("texture_vk %p.\n", texture_vk);
1356
1357 /* Take a reference to the device, in case releasing the texture would
1358 * cause the device to be destroyed. However, swapchain resources don't
1359 * take a reference to the device, and we wouldn't want to increment the
1360 * refcount on a device that's in the process of being destroyed. */
1361 if (swapchain_count)
1362 wined3d_device_incref(device);
1363
1364 wined3d_texture_sub_resources_destroyed(texture);
1365 texture->resource.parent_ops->wined3d_object_destroyed(texture->resource.parent);
1366
1367 wined3d_texture_cleanup(&texture_vk->t);
1368 wined3d_cs_destroy_object(device->cs, free, texture_vk);
1369
1370 if (swapchain_count)
1371 wined3d_device_decref(device);
1372}
1373
1374static HRESULT adapter_vk_create_rendertarget_view(const struct wined3d_view_desc *desc,
1375 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1376 struct wined3d_rendertarget_view **view)
1377{
1378 struct wined3d_rendertarget_view_vk *view_vk;
1379 HRESULT hr;
1380
1381 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
1382 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
1383
1384 if (!(view_vk = calloc(1, sizeof(*view_vk))))
1385 return E_OUTOFMEMORY;
1386
1387 if (FAILED(hr = wined3d_rendertarget_view_vk_init(view_vk, desc, resource, parent, parent_ops)))
1388 {
1389 WARN("Failed to initialise view, hr %#lx.\n", hr);
1390 free(view_vk);
1391 return hr;
1392 }
1393
1394 TRACE("Created render target view %p.\n", view_vk);
1395 *view = &view_vk->v;
1396
1397 return hr;
1398}
1399
1400struct wined3d_view_vk_destroy_ctx
1401{
1402 struct wined3d_device_vk *device_vk;
1403 VkBufferView *vk_buffer_view;
1404 VkImageView *vk_image_view;
1405 struct wined3d_bo_user *bo_user;
1406 struct wined3d_bo_vk *vk_counter_bo;
1407 VkBufferView *vk_counter_view;
1408 uint64_t *command_buffer_id;
1409 void *object;
1410 struct wined3d_view_vk_destroy_ctx *free;
1411};
1412
1413static void wined3d_view_vk_destroy_object(void *object)
1414{
1415 struct wined3d_view_vk_destroy_ctx *ctx = object;
1416 const struct wined3d_vk_info *vk_info;
1417 struct wined3d_device_vk *device_vk;
1418 struct wined3d_context *context;
1419
1420 TRACE("ctx %p.\n", ctx);
1421
1422 device_vk = ctx->device_vk;
1423 vk_info = &wined3d_adapter_vk(device_vk->d.adapter)->vk_info;
1424 context = context_acquire(&device_vk->d, NULL, 0);
1425
1426 if (ctx->vk_buffer_view)
1427 {
1428 if (context)
1429 {
1430 wined3d_context_vk_destroy_vk_buffer_view(wined3d_context_vk(context),
1431 *ctx->vk_buffer_view, *ctx->command_buffer_id);
1432 }
1433 else
1434 {
1435 VK_CALL(vkDestroyBufferView(device_vk->vk_device, *ctx->vk_buffer_view, NULL));
1436 TRACE("Destroyed buffer view 0x%s.\n", wine_dbgstr_longlong(*ctx->vk_buffer_view));
1437 }
1438 }
1439 if (ctx->vk_image_view)
1440 {
1441 if (context)
1442 {
1443 wined3d_context_vk_destroy_vk_image_view(wined3d_context_vk(context),
1444 *ctx->vk_image_view, *ctx->command_buffer_id);
1445 }
1446 else
1447 {
1448 VK_CALL(vkDestroyImageView(device_vk->vk_device, *ctx->vk_image_view, NULL));
1449 TRACE("Destroyed image view 0x%s.\n", wine_dbgstr_longlong(*ctx->vk_image_view));
1450 }
1451 }
1452 if (ctx->bo_user && ctx->bo_user->valid)
1453 list_remove(&ctx->bo_user->entry);
1454 if (ctx->vk_counter_bo && ctx->vk_counter_bo->vk_buffer)
1455 wined3d_context_vk_destroy_bo(wined3d_context_vk(context), ctx->vk_counter_bo);
1456 if (ctx->vk_counter_view)
1457 {
1458 if (context)
1459 {
1460 wined3d_context_vk_destroy_vk_buffer_view(wined3d_context_vk(context),
1461 *ctx->vk_counter_view, *ctx->command_buffer_id);
1462 }
1463 else
1464 {
1465 VK_CALL(vkDestroyBufferView(device_vk->vk_device, *ctx->vk_counter_view, NULL));
1466 TRACE("Destroyed counter buffer view 0x%s.\n", wine_dbgstr_longlong(*ctx->vk_counter_view));
1467 }
1468 }
1469
1470 if (context)
1471 context_release(context);
1472
1473 free(ctx->object);
1474 free(ctx->free);
1475}
1476
1477static void wined3d_view_vk_destroy(struct wined3d_device *device, VkBufferView *vk_buffer_view,
1478 VkImageView *vk_image_view, struct wined3d_bo_user *bo_user, struct wined3d_bo_vk *vk_counter_bo,
1479 VkBufferView *vk_counter_view, uint64_t *command_buffer_id, void *view_vk)
1480{
1481 struct wined3d_view_vk_destroy_ctx *ctx, c;
1482
1483 if (!(ctx = malloc(sizeof(*ctx))))
1484 ctx = &c;
1485 ctx->device_vk = wined3d_device_vk(device);
1486 ctx->vk_buffer_view = vk_buffer_view;
1487 ctx->vk_image_view = vk_image_view;
1488 ctx->bo_user = bo_user;
1489 ctx->vk_counter_bo = vk_counter_bo;
1490 ctx->vk_counter_view = vk_counter_view;
1491 ctx->command_buffer_id = command_buffer_id;
1492 ctx->object = view_vk;
1493 ctx->free = ctx != &c ? ctx : NULL;
1494
1495 wined3d_cs_destroy_object(device->cs, wined3d_view_vk_destroy_object, ctx);
1496 if (ctx == &c)
1497 wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
1498}
1499
1500static void adapter_vk_destroy_rendertarget_view(struct wined3d_rendertarget_view *view)
1501{
1502 struct wined3d_rendertarget_view_vk *view_vk = wined3d_rendertarget_view_vk(view);
1503 struct wined3d_resource *resource = view_vk->v.resource;
1504
1505 TRACE("view_vk %p.\n", view_vk);
1506
1507 wined3d_rendertarget_view_cleanup(&view_vk->v);
1508 wined3d_view_vk_destroy(resource->device, NULL, &view_vk->vk_image_view,
1509 NULL, NULL, NULL, &view_vk->command_buffer_id, view_vk);
1510}
1511
1512static HRESULT adapter_vk_create_shader_resource_view(const struct wined3d_view_desc *desc,
1513 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1514 struct wined3d_shader_resource_view **view)
1515{
1516 struct wined3d_shader_resource_view_vk *view_vk;
1517 HRESULT hr;
1518
1519 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
1520 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
1521
1522 if (!(view_vk = calloc(1, sizeof(*view_vk))))
1523 return E_OUTOFMEMORY;
1524
1525 if (FAILED(hr = wined3d_shader_resource_view_vk_init(view_vk, desc, resource, parent, parent_ops)))
1526 {
1527 WARN("Failed to initialise view, hr %#lx.\n", hr);
1528 free(view_vk);
1529 return hr;
1530 }
1531
1532 TRACE("Created shader resource view %p.\n", view_vk);
1533 *view = &view_vk->v;
1534
1535 return hr;
1536}
1537
1538static void adapter_vk_destroy_shader_resource_view(struct wined3d_shader_resource_view *view)
1539{
1540 struct wined3d_shader_resource_view_vk *srv_vk = wined3d_shader_resource_view_vk(view);
1541 struct wined3d_resource *resource = srv_vk->v.resource;
1542 struct wined3d_view_vk *view_vk = &srv_vk->view_vk;
1543 VkBufferView *vk_buffer_view = NULL;
1544 VkImageView *vk_image_view = NULL;
1545
1546 TRACE("srv_vk %p.\n", srv_vk);
1547
1548 if (resource->type == WINED3D_RTYPE_BUFFER)
1549 vk_buffer_view = &view_vk->u.vk_buffer_view;
1550 else
1551 vk_image_view = &view_vk->u.vk_image_info.imageView;
1552 wined3d_shader_resource_view_cleanup(&srv_vk->v);
1553 wined3d_view_vk_destroy(resource->device, vk_buffer_view, vk_image_view,
1554 &view_vk->bo_user, NULL, NULL, &view_vk->command_buffer_id, srv_vk);
1555}
1556
1557static HRESULT adapter_vk_create_unordered_access_view(const struct wined3d_view_desc *desc,
1558 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1559 struct wined3d_unordered_access_view **view)
1560{
1561 struct wined3d_unordered_access_view_vk *view_vk;
1562 HRESULT hr;
1563
1564 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
1565 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
1566
1567 if (!(view_vk = calloc(1, sizeof(*view_vk))))
1568 return E_OUTOFMEMORY;
1569
1570 if (FAILED(hr = wined3d_unordered_access_view_vk_init(view_vk, desc, resource, parent, parent_ops)))
1571 {
1572 WARN("Failed to initialise view, hr %#lx.\n", hr);
1573 free(view_vk);
1574 return hr;
1575 }
1576
1577 TRACE("Created unordered access view %p.\n", view_vk);
1578 *view = &view_vk->v;
1579
1580 return hr;
1581}
1582
1583static void adapter_vk_destroy_unordered_access_view(struct wined3d_unordered_access_view *view)
1584{
1585 struct wined3d_unordered_access_view_vk *uav_vk = wined3d_unordered_access_view_vk(view);
1586 struct wined3d_resource *resource = uav_vk->v.resource;
1587 struct wined3d_view_vk *view_vk = &uav_vk->view_vk;
1588 VkBufferView *vk_buffer_view = NULL;
1589 VkImageView *vk_image_view = NULL;
1590
1591 TRACE("uav_vk %p.\n", uav_vk);
1592
1593 if (resource->type == WINED3D_RTYPE_BUFFER)
1594 vk_buffer_view = &view_vk->u.vk_buffer_view;
1595 else
1596 vk_image_view = &view_vk->u.vk_image_info.imageView;
1597 wined3d_unordered_access_view_cleanup(&uav_vk->v);
1598 wined3d_view_vk_destroy(resource->device, vk_buffer_view, vk_image_view, &view_vk->bo_user,
1599 &uav_vk->counter_bo, &uav_vk->vk_counter_view, &view_vk->command_buffer_id, uav_vk);
1600}
1601
1602static HRESULT adapter_vk_create_sampler(struct wined3d_device *device, const struct wined3d_sampler_desc *desc,
1603 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_sampler **sampler)
1604{
1605 struct wined3d_sampler_vk *sampler_vk;
1606
1607 TRACE("device %p, desc %p, parent %p, parent_ops %p, sampler %p.\n",
1608 device, desc, parent, parent_ops, sampler);
1609
1610 if (!(sampler_vk = calloc(1, sizeof(*sampler_vk))))
1611 return E_OUTOFMEMORY;
1612
1613 wined3d_sampler_vk_init(sampler_vk, device, desc, parent, parent_ops);
1614
1615 TRACE("Created sampler %p.\n", sampler_vk);
1616 *sampler = &sampler_vk->s;
1617
1618 return WINED3D_OK;
1619}
1620
1621static void wined3d_sampler_vk_destroy_object(void *object)
1622{
1623 struct wined3d_sampler_vk *sampler_vk = object;
1624 struct wined3d_context_vk *context_vk;
1625
1626 TRACE("sampler_vk %p.\n", sampler_vk);
1627
1628 context_vk = wined3d_context_vk(context_acquire(sampler_vk->s.device, NULL, 0));
1629
1630 wined3d_context_vk_destroy_vk_sampler(context_vk, sampler_vk->vk_image_info.sampler, sampler_vk->command_buffer_id);
1631 free(sampler_vk);
1632
1633 context_release(&context_vk->c);
1634}
1635
1636static void adapter_vk_destroy_sampler(struct wined3d_sampler *sampler)
1637{
1638 struct wined3d_sampler_vk *sampler_vk = wined3d_sampler_vk(sampler);
1639
1640 TRACE("sampler_vk %p.\n", sampler_vk);
1641
1642 wined3d_cs_destroy_object(sampler->device->cs, wined3d_sampler_vk_destroy_object, sampler_vk);
1643}
1644
1645static HRESULT adapter_vk_create_query(struct wined3d_device *device, enum wined3d_query_type type,
1646 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
1647{
1648 TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1649 device, type, parent, parent_ops, query);
1650
1651 return wined3d_query_vk_create(device, type, parent, parent_ops, query);
1652}
1653
1654static void wined3d_query_vk_destroy_object(void *object)
1655{
1656 struct wined3d_query_vk *query_vk = object;
1657
1658 TRACE("query_vk %p.\n", query_vk);
1659
1660 query_vk->q.query_ops->query_destroy(&query_vk->q);
1661}
1662
1663static void adapter_vk_destroy_query(struct wined3d_query *query)
1664{
1665 struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1666
1667 TRACE("query_vk %p.\n", query_vk);
1668
1669 wined3d_cs_destroy_object(query->device->cs, wined3d_query_vk_destroy_object, query_vk);
1670}
1671
1672static void adapter_vk_flush_context(struct wined3d_context *context)
1673{
1674 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
1675
1676 TRACE("context_vk %p.\n", context_vk);
1677
1678 wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL);
1679}
1680
1681static void adapter_vk_draw_primitive(struct wined3d_device *device,
1682 const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters)
1683{
1684 struct wined3d_buffer_vk *indirect_vk = NULL;
1685 const struct wined3d_vk_info *vk_info;
1686 struct wined3d_context_vk *context_vk;
1687 VkCommandBuffer vk_command_buffer;
1688 uint32_t instance_count;
1689
1690 TRACE("device %p, state %p, parameters %p.\n", device, state, parameters);
1691
1692 context_vk = wined3d_context_vk(context_acquire(device, NULL, 0));
1693 vk_info = context_vk->vk_info;
1694
1695 if (parameters->indirect)
1696 indirect_vk = wined3d_buffer_vk(parameters->u.indirect.buffer);
1697
1698 if (!(vk_command_buffer = wined3d_context_vk_apply_draw_state(context_vk,
1699 state, indirect_vk, parameters->indexed)))
1700 {
1701 ERR("Failed to apply draw state.\n");
1702 context_release(&context_vk->c);
1703 return;
1704 }
1705
1706 if (context_vk->c.transform_feedback_active)
1707 {
1708 wined3d_context_vk_reference_bo(context_vk, &context_vk->vk_so_counter_bo);
1709 if (context_vk->c.transform_feedback_paused)
1710 VK_CALL(vkCmdBeginTransformFeedbackEXT(vk_command_buffer, 0, ARRAY_SIZE(context_vk->vk_so_counters),
1711 context_vk->vk_so_counters, context_vk->vk_so_offsets));
1712 else
1713 VK_CALL(vkCmdBeginTransformFeedbackEXT(vk_command_buffer, 0, 0, NULL, NULL));
1714 }
1715
1716 if (parameters->indirect)
1717 {
1718 struct wined3d_bo_vk *bo = wined3d_bo_vk(indirect_vk->b.buffer_object);
1719
1720 wined3d_context_vk_reference_bo(context_vk, bo);
1721 if (parameters->indexed)
1722 VK_CALL(vkCmdDrawIndexedIndirect(vk_command_buffer, bo->vk_buffer,
1723 bo->b.buffer_offset + parameters->u.indirect.offset, 1, sizeof(VkDrawIndexedIndirectCommand)));
1724 else
1725 VK_CALL(vkCmdDrawIndirect(vk_command_buffer, bo->vk_buffer,
1726 bo->b.buffer_offset + parameters->u.indirect.offset, 1, sizeof(VkDrawIndirectCommand)));
1727 }
1728 else
1729 {
1730 instance_count = parameters->u.direct.instance_count;
1731 if (!instance_count)
1732 instance_count = 1;
1733
1734 if (parameters->indexed)
1735 VK_CALL(vkCmdDrawIndexed(vk_command_buffer, parameters->u.direct.index_count,
1736 instance_count, parameters->u.direct.start_idx, parameters->u.direct.base_vertex_idx,
1737 parameters->u.direct.start_instance));
1738 else
1739 VK_CALL(vkCmdDraw(vk_command_buffer, parameters->u.direct.index_count, instance_count,
1740 parameters->u.direct.start_idx, parameters->u.direct.start_instance));
1741 }
1742
1743 if (context_vk->c.transform_feedback_active)
1744 {
1745 VK_CALL(vkCmdEndTransformFeedbackEXT(vk_command_buffer, 0, ARRAY_SIZE(context_vk->vk_so_counters),
1746 context_vk->vk_so_counters, context_vk->vk_so_offsets));
1747 context_vk->c.transform_feedback_paused = 1;
1748 context_vk->c.transform_feedback_active = 0;
1749 }
1750
1751 ++context_vk->command_buffer_work_count;
1752
1753 context_release(&context_vk->c);
1754}
1755
1756static void adapter_vk_dispatch_compute(struct wined3d_device *device,
1757 const struct wined3d_state *state, const struct wined3d_dispatch_parameters *parameters)
1758{
1759 struct wined3d_buffer_vk *indirect_vk = NULL;
1760 const struct wined3d_vk_info *vk_info;
1761 struct wined3d_context_vk *context_vk;
1762 VkCommandBuffer vk_command_buffer;
1763
1764 TRACE("device %p, state %p, parameters %p.\n", device, state, parameters);
1765
1766 context_vk = wined3d_context_vk(context_acquire(device, NULL, 0));
1767 vk_info = context_vk->vk_info;
1768
1769 if (parameters->indirect)
1770 indirect_vk = wined3d_buffer_vk(parameters->u.indirect.buffer);
1771
1772 if (!(vk_command_buffer = wined3d_context_vk_apply_compute_state(context_vk, state, indirect_vk)))
1773 {
1774 ERR("Failed to apply compute state.\n");
1775 context_release(&context_vk->c);
1776 return;
1777 }
1778
1779 if (parameters->indirect)
1780 {
1781 struct wined3d_bo_vk *bo = wined3d_bo_vk(indirect_vk->b.buffer_object);
1782
1783 wined3d_context_vk_reference_bo(context_vk, bo);
1784 VK_CALL(vkCmdDispatchIndirect(vk_command_buffer, bo->vk_buffer,
1785 bo->b.buffer_offset + parameters->u.indirect.offset));
1786 }
1787 else
1788 {
1789 const struct wined3d_direct_dispatch_parameters *direct = &parameters->u.direct;
1790
1791 VK_CALL(vkCmdDispatch(vk_command_buffer, direct->group_count_x, direct->group_count_y, direct->group_count_z));
1792 }
1793
1794 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
1795 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, 0, 0, NULL, 0, NULL, 0, NULL));
1796
1797 ++context_vk->command_buffer_work_count;
1798
1799 context_release(&context_vk->c);
1800}
1801
1802static void adapter_vk_clear_uav(struct wined3d_context *context,
1803 struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value, bool fp)
1804{
1805 TRACE("context %p, view %p, clear_value %s.\n", context, view, debug_uvec4(clear_value));
1806
1807 wined3d_unordered_access_view_vk_clear(wined3d_unordered_access_view_vk(view),
1808 clear_value, wined3d_context_vk(context), fp);
1809}
1810
1811static void adapter_vk_generate_mipmap(struct wined3d_context *context, struct wined3d_shader_resource_view *view)
1812{
1813 TRACE("context %p, view %p.\n", context, view);
1814
1815 wined3d_shader_resource_view_vk_generate_mipmap(wined3d_shader_resource_view_vk(view),
1816 wined3d_context_vk(context));
1817}
1818
1819static const struct wined3d_adapter_ops wined3d_adapter_vk_ops =
1820{
1821 .adapter_destroy = adapter_vk_destroy,
1822 .adapter_create_device = adapter_vk_create_device,
1823 .adapter_destroy_device = adapter_vk_destroy_device,
1824 .adapter_acquire_context = adapter_vk_acquire_context,
1825 .adapter_release_context = adapter_vk_release_context,
1826 .adapter_get_wined3d_caps = adapter_vk_get_wined3d_caps,
1827 .adapter_check_format = adapter_vk_check_format,
1828 .adapter_init_3d = adapter_vk_init_3d,
1829 .adapter_uninit_3d = adapter_vk_uninit_3d,
1830 .adapter_map_bo_address = adapter_vk_map_bo_address,
1831 .adapter_unmap_bo_address = adapter_vk_unmap_bo_address,
1832 .adapter_copy_bo_address = adapter_vk_copy_bo_address,
1833 .adapter_flush_bo_address = adapter_vk_flush_bo_address,
1834 .adapter_alloc_bo = adapter_vk_alloc_bo,
1835 .adapter_destroy_bo = adapter_vk_destroy_bo,
1836 .adapter_create_swapchain = adapter_vk_create_swapchain,
1837 .adapter_destroy_swapchain = adapter_vk_destroy_swapchain,
1838 .adapter_create_buffer = adapter_vk_create_buffer,
1839 .adapter_destroy_buffer = adapter_vk_destroy_buffer,
1840 .adapter_create_texture = adapter_vk_create_texture,
1841 .adapter_destroy_texture = adapter_vk_destroy_texture,
1842 .adapter_create_rendertarget_view = adapter_vk_create_rendertarget_view,
1843 .adapter_destroy_rendertarget_view = adapter_vk_destroy_rendertarget_view,
1844 .adapter_create_shader_resource_view = adapter_vk_create_shader_resource_view,
1845 .adapter_destroy_shader_resource_view = adapter_vk_destroy_shader_resource_view,
1846 .adapter_create_unordered_access_view = adapter_vk_create_unordered_access_view,
1847 .adapter_destroy_unordered_access_view = adapter_vk_destroy_unordered_access_view,
1848 .adapter_create_sampler = adapter_vk_create_sampler,
1849 .adapter_destroy_sampler = adapter_vk_destroy_sampler,
1850 .adapter_create_query = adapter_vk_create_query,
1851 .adapter_destroy_query = adapter_vk_destroy_query,
1852 .adapter_flush_context = adapter_vk_flush_context,
1853 .adapter_draw_primitive = adapter_vk_draw_primitive,
1854 .adapter_dispatch_compute = adapter_vk_dispatch_compute,
1855 .adapter_clear_uav = adapter_vk_clear_uav,
1856 .adapter_generate_mipmap = adapter_vk_generate_mipmap,
1857};
1858
1859static unsigned int wined3d_get_wine_vk_version(void)
1860{
1861 const char * (CDECL *wine_get_version)(void) = (void *)GetProcAddress( GetModuleHandleW(L"ntdll.dll"),
1862 "wine_get_version" );
1863 const char *ptr;
1864 int major, minor;
1865
1866 if (!wine_get_version) return VK_MAKE_VERSION(1, 0, 0);
1867
1868 ptr = wine_get_version();
1869 major = atoi(ptr);
1870
1871 while (isdigit(*ptr))
1872 ++ptr;
1873 if (*ptr == '.')
1874 ++ptr;
1875
1876 minor = atoi(ptr);
1877
1878 return VK_MAKE_VERSION(major, minor, 0);
1879}
1880
1881static const struct
1882{
1883 const char *name;
1884 unsigned int core_since_version;
1885 BOOL required;
1886}
1887vulkan_instance_extensions[] =
1888{
1889 {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_API_VERSION_1_1, FALSE},
1890 {VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, VK_API_VERSION_1_1, FALSE},
1891 {VK_KHR_SURFACE_EXTENSION_NAME, ~0u, TRUE},
1892 {VK_KHR_WIN32_SURFACE_EXTENSION_NAME, ~0u, TRUE},
1893};
1894
1895static BOOL enable_vulkan_instance_extensions(uint32_t *extension_count,
1896 const char *enabled_extensions[], const struct wined3d_vk_info *vk_info)
1897{
1898 PFN_vkEnumerateInstanceExtensionProperties pfn_vkEnumerateInstanceExtensionProperties;
1899 VkExtensionProperties *extensions = NULL;
1900 BOOL success = FALSE, found;
1901 unsigned int i, j, count;
1902 VkResult vr;
1903
1904 *extension_count = 0;
1905
1906 if (!(pfn_vkEnumerateInstanceExtensionProperties
1907 = (void *)VK_CALL(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties"))))
1908 {
1909 WARN("Failed to get 'vkEnumerateInstanceExtensionProperties'.\n");
1910 goto done;
1911 }
1912
1913 if ((vr = pfn_vkEnumerateInstanceExtensionProperties(NULL, &count, NULL)) < 0)
1914 {
1915 WARN("Failed to count instance extensions, vr %s.\n", wined3d_debug_vkresult(vr));
1916 goto done;
1917 }
1918 if (!(extensions = calloc(count, sizeof(*extensions))))
1919 {
1920 WARN("Out of memory.\n");
1921 goto done;
1922 }
1923 if ((vr = pfn_vkEnumerateInstanceExtensionProperties(NULL, &count, extensions)) < 0)
1924 {
1925 WARN("Failed to enumerate extensions, vr %s.\n", wined3d_debug_vkresult(vr));
1926 goto done;
1927 }
1928
1929 TRACE("Vulkan instance extensions reported:\n");
1930 for (i = 0; i < count; ++i)
1931 {
1932 TRACE(" - %s.\n", debugstr_a(extensions[i].extensionName));
1933 }
1934
1935 for (i = 0; i < ARRAY_SIZE(vulkan_instance_extensions); ++i)
1936 {
1937 if (vulkan_instance_extensions[i].core_since_version <= vk_info->api_version)
1938 continue;
1939
1940 for (j = 0, found = FALSE; j < count; ++j)
1941 {
1942 if (!strcmp(extensions[j].extensionName, vulkan_instance_extensions[i].name))
1943 {
1944 found = TRUE;
1945 break;
1946 }
1947 }
1948 if (found)
1949 {
1950 TRACE("Enabling instance extension '%s'.\n", vulkan_instance_extensions[i].name);
1951 enabled_extensions[(*extension_count)++] = vulkan_instance_extensions[i].name;
1952 }
1953 else if (!found && vulkan_instance_extensions[i].required)
1954 {
1955 WARN("Required extension '%s' is not available.\n", vulkan_instance_extensions[i].name);
1956 goto done;
1957 }
1958 }
1959 success = TRUE;
1960
1961done:
1962 free(extensions);
1963 return success;
1964}
1965
1966static BOOL wined3d_init_vulkan(struct wined3d_vk_info *vk_info)
1967{
1968 const char *enabled_instance_extensions[ARRAY_SIZE(vulkan_instance_extensions)];
1969 PFN_vkEnumerateInstanceVersion pfn_vkEnumerateInstanceVersion;
1970 struct vulkan_ops *vk_ops = &vk_info->vk_ops;
1971 VkInstance instance = VK_NULL_HANDLE;
1972 VkInstanceCreateInfo instance_info;
1973 VkApplicationInfo app_info;
1974 uint32_t api_version = 0;
1975 char app_name[MAX_PATH];
1976 VkResult vr;
1977
1978 if (!wined3d_load_vulkan(vk_info))
1979 return FALSE;
1980
1981 if (!(vk_ops->vkCreateInstance = (void *)VK_CALL(vkGetInstanceProcAddr(NULL, "vkCreateInstance"))))
1982 {
1983 ERR("Failed to get 'vkCreateInstance'.\n");
1984 goto fail;
1985 }
1986
1987 vk_info->api_version = VK_API_VERSION_1_0;
1988 if ((pfn_vkEnumerateInstanceVersion = (void *)VK_CALL(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion")))
1989 && pfn_vkEnumerateInstanceVersion(&api_version) == VK_SUCCESS)
1990 {
1991 TRACE("Vulkan instance API version %s.\n", debug_vk_version(api_version));
1992
1993 if (api_version >= VK_API_VERSION_1_1)
1994 vk_info->api_version = VK_API_VERSION_1_1;
1995 }
1996
1997 memset(&app_info, 0, sizeof(app_info));
1998 app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
1999 if (wined3d_get_app_name(app_name, ARRAY_SIZE(app_name)))
2000 app_info.pApplicationName = app_name;
2001 app_info.pEngineName = "Damavand";
2002 app_info.engineVersion = wined3d_get_wine_vk_version();
2003 app_info.apiVersion = vk_info->api_version;
2004
2005 memset(&instance_info, 0, sizeof(instance_info));
2006 instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
2007 instance_info.pApplicationInfo = &app_info;
2008 instance_info.ppEnabledExtensionNames = enabled_instance_extensions;
2009 if (!enable_vulkan_instance_extensions(&instance_info.enabledExtensionCount, enabled_instance_extensions, vk_info))
2010 goto fail;
2011
2012 memset(vk_info->supported, 0, sizeof(vk_info->supported));
2013 vk_info->supported[WINED3D_VK_EXT_NONE] = TRUE;
2014
2015 if ((vr = VK_CALL(vkCreateInstance(&instance_info, NULL, &instance))) < 0)
2016 {
2017 WARN("Failed to create Vulkan instance, vr %s.\n", wined3d_debug_vkresult(vr));
2018 goto fail;
2019 }
2020
2021 TRACE("Created Vulkan instance %p.\n", instance);
2022
2023#define LOAD_INSTANCE_PFN(name) \
2024 if (!(vk_ops->name = (void *)VK_CALL(vkGetInstanceProcAddr(instance, #name)))) \
2025 { \
2026 WARN("Could not get instance proc addr for '" #name "'.\n"); \
2027 goto fail; \
2028 }
2029#define LOAD_INSTANCE_OPT_PFN(name) \
2030 vk_ops->name = (void *)VK_CALL(vkGetInstanceProcAddr(instance, #name));
2031#define VK_INSTANCE_PFN LOAD_INSTANCE_PFN
2032#define VK_INSTANCE_EXT_PFN LOAD_INSTANCE_OPT_PFN
2033#define VK_DEVICE_PFN LOAD_INSTANCE_PFN
2034#define VK_DEVICE_EXT_PFN LOAD_INSTANCE_OPT_PFN
2035 VK_INSTANCE_FUNCS()
2036 VK_DEVICE_FUNCS()
2037#undef VK_INSTANCE_PFN
2038#undef VK_INSTANCE_EXT_PFN
2039#undef VK_DEVICE_PFN
2040#undef VK_DEVICE_EXT_PFN
2041
2042#define MAP_INSTANCE_FUNCTION(core_pfn, ext_pfn) \
2043 if (!vk_ops->core_pfn) \
2044 vk_ops->core_pfn = (void *)VK_CALL(vkGetInstanceProcAddr(instance, #ext_pfn));
2045 MAP_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties2, vkGetPhysicalDeviceProperties2KHR)
2046 MAP_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures2, vkGetPhysicalDeviceFeatures2KHR)
2047#undef MAP_INSTANCE_FUNCTION
2048
2049 vk_info->instance = instance;
2050
2051 return TRUE;
2052
2053fail:
2054 if (vk_ops->vkDestroyInstance)
2055 VK_CALL(vkDestroyInstance(instance, NULL));
2056 wined3d_unload_vulkan(vk_info);
2057 return FALSE;
2058}
2059
2060static VkPhysicalDevice get_vulkan_physical_device(struct wined3d_vk_info *vk_info)
2061{
2062 VkPhysicalDevice physical_devices[1];
2063 uint32_t count;
2064 VkResult vr;
2065
2066 if ((vr = VK_CALL(vkEnumeratePhysicalDevices(vk_info->instance, &count, NULL))) < 0)
2067 {
2068 WARN("Failed to enumerate physical devices, vr %s.\n", wined3d_debug_vkresult(vr));
2069 return VK_NULL_HANDLE;
2070 }
2071 if (!count)
2072 {
2073 WARN("No physical device.\n");
2074 return VK_NULL_HANDLE;
2075 }
2076 if (count > 1)
2077 {
2078 /* TODO: Create wined3d_adapter for each device. */
2079 FIXME("Multiple physical devices available.\n");
2080 count = 1;
2081 }
2082
2083 if ((vr = VK_CALL(vkEnumeratePhysicalDevices(vk_info->instance, &count, physical_devices))) < 0)
2084 {
2085 WARN("Failed to get physical devices, vr %s.\n", wined3d_debug_vkresult(vr));
2086 return VK_NULL_HANDLE;
2087 }
2088
2089 return physical_devices[0];
2090}
2091
2092static enum wined3d_display_driver guess_display_driver(enum wined3d_pci_vendor vendor)
2093{
2094 switch (vendor)
2095 {
2096 case HW_VENDOR_AMD: return DRIVER_AMD_RX;
2097 case HW_VENDOR_INTEL: return DRIVER_INTEL_HD4000;
2098 case HW_VENDOR_NVIDIA: return DRIVER_NVIDIA_GEFORCE8;
2099 default: return DRIVER_WINE;
2100 }
2101}
2102
2103static bool adapter_vk_init_driver_info(struct wined3d_adapter_vk *adapter_vk,
2104 const VkPhysicalDeviceProperties *properties)
2105{
2106 const VkPhysicalDeviceMemoryProperties *memory_properties = &adapter_vk->memory_properties;
2107 const struct wined3d_gpu_description *gpu_description;
2108 struct wined3d_gpu_description description;
2109 UINT64 vram_bytes, sysmem_bytes;
2110 const VkMemoryType *type;
2111 const VkMemoryHeap *heap;
2112 unsigned int i;
2113
2114 TRACE("Device name: %s.\n", debugstr_a(properties->deviceName));
2115 TRACE("Vendor ID: 0x%04x, Device ID: 0x%04x.\n", properties->vendorID, properties->deviceID);
2116 TRACE("Driver version: %#x.\n", properties->driverVersion);
2117 TRACE("API version: %s.\n", debug_vk_version(properties->apiVersion));
2118
2119 for (i = 0, vram_bytes = 0, sysmem_bytes = 0; i < memory_properties->memoryHeapCount; ++i)
2120 {
2121 heap = &memory_properties->memoryHeaps[i];
2122 TRACE("Memory heap [%u]: flags %#x, size 0x%s.\n",
2123 i, heap->flags, wine_dbgstr_longlong(heap->size));
2124 if (heap->flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
2125 vram_bytes += heap->size;
2126 else
2127 sysmem_bytes += heap->size;
2128 }
2129 TRACE("Total device memory: 0x%s.\n", wine_dbgstr_longlong(vram_bytes));
2130 TRACE("Total shared system memory: 0x%s.\n", wine_dbgstr_longlong(sysmem_bytes));
2131
2132 for (i = 0; i < memory_properties->memoryTypeCount; ++i)
2133 {
2134 type = &memory_properties->memoryTypes[i];
2135 TRACE("Memory type [%u]: flags %#x, heap %u.\n", i, type->propertyFlags, type->heapIndex);
2136 }
2137
2138 if (!(gpu_description = wined3d_get_user_override_gpu_description(properties->vendorID, properties->deviceID)))
2139 gpu_description = wined3d_get_gpu_description(properties->vendorID, properties->deviceID);
2140
2141 if (!gpu_description)
2142 {
2143 FIXME("Failed to retrieve GPU description for device %s %04x:%04x.\n",
2144 debugstr_a(properties->deviceName), properties->vendorID, properties->deviceID);
2145
2146 description.vendor = properties->vendorID;
2147 description.device = properties->deviceID;
2148 description.description = properties->deviceName;
2149 description.driver = guess_display_driver(properties->vendorID);
2150 description.vidmem = vram_bytes;
2151
2152 gpu_description = &description;
2153 }
2154
2155 return wined3d_driver_info_init(&adapter_vk->a.driver_info, gpu_description,
2156 adapter_vk->a.d3d_info.feature_level, vram_bytes, sysmem_bytes);
2157}
2158
2159static bool feature_level_9_2_supported(const struct wined3d_physical_device_info *info)
2160{
2161 return info->features2.features.occlusionQueryPrecise;
2162}
2163
2164static bool feature_level_9_3_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
2165{
2166 return shader_model >= 3
2167 && info->features2.features.independentBlend;
2168}
2169
2170static bool feature_level_10_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
2171{
2172 return shader_model >= 4
2173 && info->features2.features.multiViewport
2174 && info->features2.features.geometryShader
2175 && info->features2.features.depthClamp
2176 && info->features2.features.depthBiasClamp
2177 && info->features2.features.pipelineStatisticsQuery
2178 && info->features2.features.shaderClipDistance
2179 && info->features2.features.shaderCullDistance
2180 && info->draw_parameters_features.shaderDrawParameters
2181 && info->vertex_divisor_features.vertexAttributeInstanceRateDivisor
2182 && info->vertex_divisor_features.vertexAttributeInstanceRateZeroDivisor;
2183}
2184
2185static bool feature_level_10_1_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
2186{
2187 return info->features2.features.imageCubeArray;
2188}
2189
2190static bool feature_level_11_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
2191{
2192 return shader_model >= 5
2193 && info->features2.features.multiDrawIndirect
2194 && info->features2.features.drawIndirectFirstInstance
2195 && info->features2.features.fragmentStoresAndAtomics
2196 && info->features2.features.shaderImageGatherExtended
2197 && info->features2.features.tessellationShader;
2198}
2199
2200static bool feature_level_11_1_supported(const struct wined3d_physical_device_info *info)
2201{
2202 return info->features2.features.vertexPipelineStoresAndAtomics;
2203}
2204
2205static enum wined3d_feature_level feature_level_from_caps(const struct wined3d_physical_device_info *info,
2206 const struct shader_caps *shader_caps)
2207{
2208 unsigned int shader_model;
2209
2210 shader_model = min(shader_caps->vs_version, shader_caps->ps_version);
2211 shader_model = min(shader_model, max(shader_caps->gs_version, 3));
2212 shader_model = min(shader_model, max(shader_caps->hs_version, 4));
2213 shader_model = min(shader_model, max(shader_caps->ds_version, 4));
2214
2215 if (!shader_model)
2216 return WINED3D_FEATURE_LEVEL_7;
2217
2218 if (shader_model <= 1)
2219 return WINED3D_FEATURE_LEVEL_8;
2220
2221 if (!feature_level_9_2_supported(info))
2222 return WINED3D_FEATURE_LEVEL_9_1;
2223
2224 if (!feature_level_9_3_supported(info, shader_model))
2225 return WINED3D_FEATURE_LEVEL_9_2;
2226
2227 if (!feature_level_10_supported(info, shader_model))
2228 return WINED3D_FEATURE_LEVEL_9_3;
2229
2230 if (!feature_level_10_1_supported(info, shader_model))
2231 return WINED3D_FEATURE_LEVEL_10;
2232
2233 if (!feature_level_11_supported(info, shader_model))
2234 return WINED3D_FEATURE_LEVEL_10_1;
2235
2236 if (!feature_level_11_1_supported(info))
2237 return WINED3D_FEATURE_LEVEL_11;
2238
2239 return WINED3D_FEATURE_LEVEL_11_1;
2240}
2241
2242static void wined3d_adapter_vk_init_d3d_info(struct wined3d_adapter_vk *adapter_vk, uint32_t wined3d_creation_flags)
2243{
2244 const struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *dynamic_state3;
2245 struct wined3d_d3d_info *d3d_info = &adapter_vk->a.d3d_info;
2246 struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
2247 struct wined3d_physical_device_info device_info;
2248 struct wined3d_vertex_caps vertex_caps;
2249 unsigned int sample_counts_mask;
2250 struct shader_caps shader_caps;
2251
2252 get_physical_device_info(adapter_vk, &device_info);
2253
2254 if (!device_info.dynamic_state_features.extendedDynamicState)
2255 adapter_vk->vk_info.supported[WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE] = FALSE;
2256
2257 if (!device_info.host_query_reset_features.hostQueryReset)
2258 adapter_vk->vk_info.supported[WINED3D_VK_EXT_HOST_QUERY_RESET] = FALSE;
2259
2260 if (!device_info.xfb_features.transformFeedback)
2261 adapter_vk->vk_info.supported[WINED3D_VK_EXT_TRANSFORM_FEEDBACK] = FALSE;
2262
2263 adapter_vk->a.shader_backend->shader_get_caps(&adapter_vk->a, &shader_caps);
2264 adapter_vk->a.vertex_pipe->vp_get_caps(&adapter_vk->a, &vertex_caps);
2265 adapter_vk->a.fragment_pipe->get_caps(&adapter_vk->a, &d3d_info->ffp_fragment_caps);
2266
2267 d3d_info->limits.vs_version = shader_caps.vs_version;
2268 d3d_info->limits.hs_version = shader_caps.hs_version;
2269 d3d_info->limits.ds_version = shader_caps.ds_version;
2270 d3d_info->limits.gs_version = shader_caps.gs_version;
2271 d3d_info->limits.ps_version = shader_caps.ps_version;
2272 d3d_info->limits.cs_version = shader_caps.cs_version;
2273 d3d_info->limits.vs_uniform_count = shader_caps.vs_uniform_count;
2274 d3d_info->limits.ps_uniform_count = shader_caps.ps_uniform_count;
2275 d3d_info->limits.varying_count = shader_caps.varying_count;
2276 d3d_info->limits.ffp_vertex_blend_matrices = vertex_caps.max_vertex_blend_matrices;
2277 d3d_info->limits.active_light_count = vertex_caps.max_active_lights;
2278
2279 d3d_info->limits.max_rt_count = WINED3D_MAX_RENDER_TARGETS;
2280 d3d_info->limits.max_clip_distances = WINED3D_MAX_CLIP_DISTANCES;
2281 d3d_info->limits.texture_size = adapter_vk->device_limits.maxImageDimension2D;
2282 d3d_info->limits.pointsize_max = adapter_vk->device_limits.pointSizeRange[1];
2283 sample_counts_mask = adapter_vk->device_limits.framebufferColorSampleCounts
2284 | adapter_vk->device_limits.framebufferDepthSampleCounts
2285 | adapter_vk->device_limits.framebufferStencilSampleCounts
2286 | adapter_vk->device_limits.framebufferNoAttachmentsSampleCounts;
2287 d3d_info->limits.sample_count = (1u << wined3d_log2i(sample_counts_mask));
2288
2289 d3d_info->wined3d_creation_flags = wined3d_creation_flags;
2290
2291 d3d_info->emulated_flatshading = vertex_caps.emulated_flatshading;
2292 d3d_info->ffp_alpha_test = false;
2293 d3d_info->shader_double_precision = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION);
2294 d3d_info->shader_output_interpolation = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_OUTPUT_INTERPOLATION);
2295 d3d_info->viewport_array_index_any_shader = false; /* VK_EXT_shader_viewport_index_layer */
2296 d3d_info->stencil_export = vk_info->supported[WINED3D_VK_EXT_SHADER_STENCIL_EXPORT];
2297 d3d_info->unconditional_npot = true;
2298 d3d_info->draw_base_vertex_offset = true;
2299 d3d_info->vertex_bgra = true;
2300 d3d_info->texture_swizzle = true;
2301 d3d_info->srgb_read_control = false;
2302 d3d_info->srgb_write_control = false;
2303 d3d_info->clip_control = true;
2304 d3d_info->full_ffp_varyings = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_FULL_FFP_VARYINGS);
2305 d3d_info->scaled_resolve = false;
2306 d3d_info->pbo = true;
2307 d3d_info->feature_level = feature_level_from_caps(&device_info, &shader_caps);
2308 d3d_info->subpixel_viewport = true;
2309 d3d_info->fences = true;
2310 d3d_info->persistent_map = true;
2311 d3d_info->gpu_push_constants = true;
2312 d3d_info->ffp_hlsl = true;
2313
2314 /* Like GL, Vulkan doesn't explicitly specify a filling convention and only mandates that a
2315 * shared edge of two adjacent triangles generate a fragment for exactly one of the triangles.
2316 *
2317 * However, every Vulkan implementation we have seen so far uses a top-left rule. Hardware
2318 * that differs either predates Vulkan (d3d9 class HW, GeForce 9xxx) or behaves the way we
2319 * want in Vulkan (MacOS Radeon driver through MoltenVK). */
2320 d3d_info->filling_convention_offset = 0.0f;
2321
2322 d3d_info->multisample_draw_location = WINED3D_LOCATION_TEXTURE_RGB;
2323
2324 vk_info->multiple_viewports = device_info.features2.features.multiViewport;
2325 vk_info->dynamic_state2 = device_info.dynamic_state2_features.extendedDynamicState2;
2326 vk_info->dynamic_patch_vertex_count = device_info.dynamic_state2_features.extendedDynamicState2PatchControlPoints;
2327
2328 dynamic_state3 = &device_info.dynamic_state3_features;
2329 vk_info->dynamic_multisample_state = dynamic_state3->extendedDynamicState3RasterizationSamples
2330 && dynamic_state3->extendedDynamicState3AlphaToCoverageEnable
2331 && dynamic_state3->extendedDynamicState3SampleMask;
2332 vk_info->dynamic_blend_state = dynamic_state3->extendedDynamicState3ColorBlendEnable
2333 && dynamic_state3->extendedDynamicState3ColorBlendEquation
2334 && dynamic_state3->extendedDynamicState3ColorWriteMask;
2335 /* Rasterizer state needs EDS2, for rasterizer discard, and EDS1, for cull mode and front face. */
2336 vk_info->dynamic_rasterizer_state = dynamic_state3->extendedDynamicState3DepthClampEnable
2337 && vk_info->dynamic_state2
2338 && adapter_vk->vk_info.supported[WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE];
2339}
2340
2341static bool wined3d_adapter_vk_init_device_extensions(struct wined3d_adapter_vk *adapter_vk)
2342{
2343 VkPhysicalDevice physical_device = adapter_vk->physical_device;
2344 struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
2345 unsigned int count, enable_count, i, j;
2346 const char **enabled_extensions = NULL;
2347 VkExtensionProperties *extensions;
2348 bool found, success = false;
2349 SIZE_T enable_size = 0;
2350 VkResult vr;
2351
2352 static const struct
2353 {
2354 const char *name;
2355 unsigned int core_since_version;
2356 bool required;
2357 }
2358 info[] =
2359 {
2360 {VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, VK_API_VERSION_1_3},
2361 {VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME, VK_API_VERSION_1_3},
2362 {VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME, ~0u},
2363 {VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_API_VERSION_1_2},
2364 {VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, ~0u},
2365 {VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, ~0u},
2366 {VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, ~0u},
2367 {VK_KHR_MAINTENANCE1_EXTENSION_NAME, VK_API_VERSION_1_1, true},
2368 {VK_KHR_MAINTENANCE2_EXTENSION_NAME, VK_API_VERSION_1_1},
2369 {VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME,VK_API_VERSION_1_2},
2370 {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_API_VERSION_1_1},
2371 {VK_KHR_SWAPCHAIN_EXTENSION_NAME, ~0u, true},
2372 };
2373
2374 static const struct
2375 {
2376 const char *name;
2377 enum wined3d_vk_extension extension;
2378 }
2379 map[] =
2380 {
2381 {VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE},
2382 {VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME, WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE2},
2383 {VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME, WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE3},
2384 {VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, WINED3D_VK_EXT_HOST_QUERY_RESET},
2385 {VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, WINED3D_VK_EXT_SHADER_STENCIL_EXPORT},
2386 {VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, WINED3D_VK_EXT_TRANSFORM_FEEDBACK},
2387 {VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, WINED3D_VK_EXT_VERTEX_ATTRIBUTE_DIVISOR},
2388 {VK_KHR_MAINTENANCE2_EXTENSION_NAME, WINED3D_VK_KHR_MAINTENANCE2},
2389 {VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE},
2390 {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, WINED3D_VK_KHR_SHADER_DRAW_PARAMETERS},
2391 };
2392
2393 if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL))) < 0)
2394 {
2395 ERR("Failed to enumerate device extensions, vr %s.\n", wined3d_debug_vkresult(vr));
2396 return false;
2397 }
2398
2399 if (!(extensions = calloc(count, sizeof(*extensions))))
2400 {
2401 ERR("Failed to allocate extension properties array.\n");
2402 return false;
2403 }
2404
2405 if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, extensions))) < 0)
2406 {
2407 ERR("Failed to enumerate device extensions, vr %s.\n", wined3d_debug_vkresult(vr));
2408 goto done;
2409 }
2410
2411 TRACE("Vulkan device extensions reported:\n");
2412 for (i = 0; i < count; ++i)
2413 {
2414 TRACE(" - %s.\n", debugstr_a(extensions[i].extensionName));
2415 }
2416
2417 for (i = 0, enable_count = 0; i < ARRAY_SIZE(info); ++i)
2418 {
2419 if (info[i].core_since_version <= vk_info->api_version)
2420 continue;
2421
2422 for (j = 0, found = false; j < count; ++j)
2423 {
2424 if (!strcmp(extensions[j].extensionName, info[i].name))
2425 {
2426 found = true;
2427 break;
2428 }
2429 }
2430
2431 if (!found)
2432 {
2433 if (!info[i].required)
2434 continue;
2435 WARN("Required extension '%s' is not available.\n", info[i].name);
2436 goto done;
2437 }
2438
2439 TRACE("Enabling device extension '%s'.\n", info[i].name);
2440 if (!wined3d_array_reserve((void **)&enabled_extensions, &enable_size,
2441 enable_count + 1, sizeof(*enabled_extensions)))
2442 {
2443 ERR("Failed to allocate enabled extensions array.\n");
2444 goto done;
2445 }
2446 enabled_extensions[enable_count++] = info[i].name;
2447 }
2448 success = true;
2449
2450 for (i = 0; i < ARRAY_SIZE(map); ++i)
2451 {
2452 for (j = 0; j < enable_count; ++j)
2453 {
2454 if (!strcmp(enabled_extensions[j], map[i].name))
2455 {
2456 vk_info->supported[map[i].extension] = TRUE;
2457 break;
2458 }
2459 }
2460 }
2461
2462done:
2463 if (success)
2464 {
2465 adapter_vk->device_extension_count = enable_count;
2466 adapter_vk->device_extensions = enabled_extensions;
2467 }
2468 else
2469 {
2470 free(enabled_extensions);
2471 }
2472 free(extensions);
2473 return success;
2474}
2475
2476static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk,
2477 unsigned int ordinal, unsigned int wined3d_creation_flags)
2478{
2479 struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
2480 struct wined3d_adapter *adapter = &adapter_vk->a;
2481 VkPhysicalDeviceIDProperties id_properties;
2482 VkPhysicalDeviceProperties2 properties2;
2483 LUID primary_luid, *luid = NULL;
2484
2485 TRACE("adapter_vk %p, ordinal %u, wined3d_creation_flags %#x.\n",
2486 adapter_vk, ordinal, wined3d_creation_flags);
2487
2488 if (!wined3d_init_vulkan(vk_info))
2489 {
2490 WARN("Failed to initialize Vulkan.\n");
2491 return FALSE;
2492 }
2493
2494 if (!(adapter_vk->physical_device = get_vulkan_physical_device(vk_info)))
2495 goto fail_vulkan;
2496
2497 if (!wined3d_adapter_vk_init_device_extensions(adapter_vk))
2498 goto fail_vulkan;
2499
2500 memset(&id_properties, 0, sizeof(id_properties));
2501 id_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
2502 properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
2503 properties2.pNext = &id_properties;
2504
2505 if (vk_info->vk_ops.vkGetPhysicalDeviceProperties2)
2506 VK_CALL(vkGetPhysicalDeviceProperties2(adapter_vk->physical_device, &properties2));
2507 else
2508 VK_CALL(vkGetPhysicalDeviceProperties(adapter_vk->physical_device, &properties2.properties));
2509 adapter_vk->device_limits = properties2.properties.limits;
2510
2511 VK_CALL(vkGetPhysicalDeviceMemoryProperties(adapter_vk->physical_device, &adapter_vk->memory_properties));
2512
2513 if (id_properties.deviceLUIDValid)
2514 luid = (LUID *)id_properties.deviceLUID;
2515 else if (ordinal == 0 && wined3d_get_primary_adapter_luid(&primary_luid))
2516 luid = &primary_luid;
2517
2518 if (!wined3d_adapter_init(adapter, ordinal, luid, &wined3d_adapter_vk_ops))
2519 {
2520 free(adapter_vk->device_extensions);
2521 goto fail_vulkan;
2522 }
2523
2524 adapter->vertex_pipe = wined3d_spirv_vertex_pipe_init_vk();
2525 adapter->fragment_pipe = wined3d_spirv_fragment_pipe_init_vk();
2526 adapter->misc_state_template = misc_state_template_vk;
2527 adapter->shader_backend = wined3d_spirv_shader_backend_init_vk();
2528
2529 wined3d_adapter_vk_init_d3d_info(adapter_vk, wined3d_creation_flags);
2530
2531 if (!adapter_vk_init_driver_info(adapter_vk, &properties2.properties))
2532 goto fail;
2533 TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n",
2534 adapter_vk->a.driver_info.version_high, adapter_vk->a.driver_info.version_low);
2535 adapter->vram_bytes_used = 0;
2536 TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->driver_info.vram_bytes));
2537
2538 memcpy(&adapter->driver_uuid, id_properties.driverUUID, sizeof(adapter->driver_uuid));
2539 memcpy(&adapter->device_uuid, id_properties.deviceUUID, sizeof(adapter->device_uuid));
2540
2541 if (!wined3d_adapter_vk_init_format_info(adapter_vk, vk_info))
2542 goto fail;
2543
2544 return TRUE;
2545
2546fail:
2547 wined3d_adapter_cleanup(adapter);
2548 free(adapter_vk->device_extensions);
2549fail_vulkan:
2550 VK_CALL(vkDestroyInstance(vk_info->instance, NULL));
2551 wined3d_unload_vulkan(vk_info);
2552 return FALSE;
2553}
2554
2555struct wined3d_adapter *wined3d_adapter_vk_create(unsigned int ordinal,
2556 unsigned int wined3d_creation_flags)
2557{
2558 struct wined3d_adapter_vk *adapter_vk;
2559
2560 if (!(adapter_vk = calloc(1, sizeof(*adapter_vk))))
2561 return NULL;
2562
2563 if (!wined3d_adapter_vk_init(adapter_vk, ordinal, wined3d_creation_flags))
2564 {
2565 free(adapter_vk);
2566 return NULL;
2567 }
2568
2569 TRACE("Created adapter %p.\n", adapter_vk);
2570
2571 return &adapter_vk->a;
2572}
isdigit
#define isdigit(c)
Definition: acclib.h:68
UINT64
COMPILER_DEPENDENT_UINT64 UINT64
Definition: actypes.h:131
get_physical_device_info
static void get_physical_device_info(const struct wined3d_adapter_vk *adapter_vk, struct wined3d_physical_device_info *info)
Definition: adapter_vk.c:302
wined3d_init_vulkan
static BOOL wined3d_init_vulkan(struct wined3d_vk_info *vk_info)
Definition: adapter_vk.c:1966
adapter_vk_dispatch_compute
static void adapter_vk_dispatch_compute(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_dispatch_parameters *parameters)
Definition: adapter_vk.c:1756
adapter_vk_create_query
static HRESULT adapter_vk_create_query(struct wined3d_device *device, enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
Definition: adapter_vk.c:1645
adapter_vk_acquire_context
static struct wined3d_context * adapter_vk_acquire_context(struct wined3d_device *device, struct wined3d_texture *texture, unsigned int sub_resource_idx)
Definition: adapter_vk.c:472
add_structure
static void add_structure(VkPhysicalDeviceFeatures2 *features2, void *s)
Definition: adapter_vk.c:294
adapter_vk_destroy_device
static void adapter_vk_destroy_device(struct wined3d_device *device)
Definition: adapter_vk.c:458
vk_access_mask_from_buffer_usage
VkAccessFlags vk_access_mask_from_buffer_usage(VkBufferUsageFlags usage)
Definition: adapter_vk.c:835
wined3d_adapter_vk_init_device_extensions
static bool wined3d_adapter_vk_init_device_extensions(struct wined3d_adapter_vk *adapter_vk)
Definition: adapter_vk.c:2341
adapter_vk_alloc_bo
static bool adapter_vk_alloc_bo(struct wined3d_device *device, struct wined3d_resource *resource, unsigned int sub_resource_idx, struct wined3d_bo_address *addr)
Definition: adapter_vk.c:1170
adapter_vk_create_buffer
static HRESULT adapter_vk_create_buffer(struct wined3d_device *device, const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_buffer **buffer)
Definition: adapter_vk.c:1276
wined3d_view_vk_destroy
static void wined3d_view_vk_destroy(struct wined3d_device *device, VkBufferView *vk_buffer_view, VkImageView *vk_image_view, struct wined3d_bo_user *bo_user, struct wined3d_bo_vk *vk_counter_bo, VkBufferView *vk_counter_view, uint64_t *command_buffer_id, void *view_vk)
Definition: adapter_vk.c:1477
adapter_vk_check_format
static BOOL adapter_vk_check_format(const struct wined3d_adapter *adapter, const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format, const struct wined3d_format *ds_format)
Definition: adapter_vk.c:595
debug_vk_version
static const char * debug_vk_version(uint32_t version)
Definition: adapter_vk.c:67
wined3d_unload_vulkan
static void wined3d_unload_vulkan(struct wined3d_vk_info *vk_info)
Definition: adapter_vk.c:118
adapter_vk_create_sampler
static HRESULT adapter_vk_create_sampler(struct wined3d_device *device, const struct wined3d_sampler_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_sampler **sampler)
Definition: adapter_vk.c:1602
wined3d_select_vulkan_queue_family
static HRESULT wined3d_select_vulkan_queue_family(const struct wined3d_adapter_vk *adapter_vk, uint32_t *queue_family_index, uint32_t *timestamp_bits)
Definition: adapter_vk.c:139
adapter_vk_destroy_buffer
static void adapter_vk_destroy_buffer(struct wined3d_buffer *buffer)
Definition: adapter_vk.c:1302
adapter_vk_destroy_swapchain
static void adapter_vk_destroy_swapchain(struct wined3d_swapchain *swapchain)
Definition: adapter_vk.c:1251
wined3d_adapter_vk_get_memory_type_index
unsigned int wined3d_adapter_vk_get_memory_type_index(const struct wined3d_adapter_vk *adapter_vk, uint32_t memory_type_mask, VkMemoryPropertyFlags flags)
Definition: adapter_vk.c:1259
adapter_vk_destroy_query
static void adapter_vk_destroy_query(struct wined3d_query *query)
Definition: adapter_vk.c:1663
wined3d_disable_vulkan_features
static void wined3d_disable_vulkan_features(struct wined3d_physical_device_info *info)
Definition: adapter_vk.c:183
adapter_vk_uninit_3d_cs
static void adapter_vk_uninit_3d_cs(void *object)
Definition: adapter_vk.c:655
adapter_vk_map_bo_address
static void * adapter_vk_map_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *data, size_t size, uint32_t map_flags)
Definition: adapter_vk.c:887
flush_bo_range
static void flush_bo_range(struct wined3d_context_vk *context_vk, struct wined3d_bo_vk *bo, unsigned int offset, unsigned int size)
Definition: adapter_vk.c:983
core_since_version
unsigned int core_since_version
Definition: adapter_vk.c:1884
wined3d_adapter_vk_const
static const struct wined3d_adapter_vk * wined3d_adapter_vk_const(const struct wined3d_adapter *adapter)
Definition: adapter_vk.c:62
adapter_vk_get_wined3d_caps
static void adapter_vk_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps)
Definition: adapter_vk.c:490
adapter_vk_destroy_bo
static void adapter_vk_destroy_bo(struct wined3d_context *context, struct wined3d_bo *bo)
Definition: adapter_vk.c:1219
adapter_vk_flush_bo_address
static void adapter_vk_flush_bo_address(struct wined3d_context *context, const struct wined3d_const_bo_address *data, size_t size)
Definition: adapter_vk.c:1158
MAP_INSTANCE_FUNCTION
#define MAP_INSTANCE_FUNCTION(core_pfn, ext_pfn)
feature_level_9_2_supported
static bool feature_level_9_2_supported(const struct wined3d_physical_device_info *info)
Definition: adapter_vk.c:2159
wined3d_bo_slab_vk_map
void * wined3d_bo_slab_vk_map(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
Definition: adapter_vk.c:796
required
BOOL required
Definition: adapter_vk.c:1885
adapter_vk_uninit_3d
static void adapter_vk_uninit_3d(struct wined3d_device *device)
Definition: adapter_vk.c:680
wined3d_bo_slab_vk_unmap
void wined3d_bo_slab_vk_unmap(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
Definition: adapter_vk.c:819
adapter_vk_create_texture
static HRESULT adapter_vk_create_texture(struct wined3d_device *device, const struct wined3d_resource_desc *desc, unsigned int layer_count, unsigned int level_count, uint32_t flags, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_texture **texture)
Definition: adapter_vk.c:1322
adapter_vk_create_device
static HRESULT adapter_vk_create_device(struct wined3d *wined3d, const struct wined3d_adapter *adapter, enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, struct wined3d_device_parent *device_parent, struct wined3d_device **device)
Definition: adapter_vk.c:355
guess_display_driver
static enum wined3d_display_driver guess_display_driver(enum wined3d_pci_vendor vendor)
Definition: adapter_vk.c:2092
feature_level_10_1_supported
static bool feature_level_10_1_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
Definition: adapter_vk.c:2185
wined3d_load_vulkan
static BOOL wined3d_load_vulkan(struct wined3d_vk_info *vk_info)
Definition: adapter_vk.c:97
wined3d_adapter_vk_ops
static const struct wined3d_adapter_ops wined3d_adapter_vk_ops
Definition: adapter_vk.c:1819
wined3d_adapter_vk_create
struct wined3d_adapter * wined3d_adapter_vk_create(unsigned int ordinal, unsigned int wined3d_creation_flags)
Definition: adapter_vk.c:2555
wined3d_sampler_vk_destroy_object
static void wined3d_sampler_vk_destroy_object(void *object)
Definition: adapter_vk.c:1621
feature_level_11_1_supported
static bool feature_level_11_1_supported(const struct wined3d_physical_device_info *info)
Definition: adapter_vk.c:2200
wined3d_bo_vk_map
static void * wined3d_bo_vk_map(struct wined3d_bo_vk *bo, struct wined3d_context_vk *context_vk)
Definition: adapter_vk.c:698
wined3d_adapter_vk_init
static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, unsigned int ordinal, unsigned int wined3d_creation_flags)
Definition: adapter_vk.c:2476
adapter_vk_copy_bo_address
void adapter_vk_copy_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *dst, const struct wined3d_bo_address *src, unsigned int range_count, const struct wined3d_range *ranges, uint32_t map_flags)
Definition: adapter_vk.c:1020
adapter_vk_init_3d
static HRESULT adapter_vk_init_3d(struct wined3d_device *device)
Definition: adapter_vk.c:602
adapter_vk_flush_context
static void adapter_vk_flush_context(struct wined3d_context *context)
Definition: adapter_vk.c:1672
name
const char * name
Definition: adapter_vk.c:1883
get_vulkan_physical_device
static VkPhysicalDevice get_vulkan_physical_device(struct wined3d_vk_info *vk_info)
Definition: adapter_vk.c:2060
enable_vulkan_instance_extensions
static BOOL enable_vulkan_instance_extensions(uint32_t *extension_count, const char *enabled_extensions[], const struct wined3d_vk_info *vk_info)
Definition: adapter_vk.c:1895
adapter_vk_init_driver_info
static bool adapter_vk_init_driver_info(struct wined3d_adapter_vk *adapter_vk, const VkPhysicalDeviceProperties *properties)
Definition: adapter_vk.c:2103
vk_pipeline_stage_mask_from_buffer_usage
VkPipelineStageFlags vk_pipeline_stage_mask_from_buffer_usage(VkBufferUsageFlags usage)
Definition: adapter_vk.c:864
hresult_from_vk_result
static HRESULT hresult_from_vk_result(VkResult vr)
Definition: adapter_vk.c:73
misc_state_template_vk
static const struct wined3d_state_entry_template misc_state_template_vk[]
Definition: adapter_vk.c:24
wined3d_bo_slab_vk_unlock
static void wined3d_bo_slab_vk_unlock(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
Definition: adapter_vk.c:791
wined3d_query_vk_destroy_object
static void wined3d_query_vk_destroy_object(void *object)
Definition: adapter_vk.c:1654
wined3d_bo_vk_unmap
static void wined3d_bo_vk_unmap(struct wined3d_bo_vk *bo, struct wined3d_context_vk *context_vk)
Definition: adapter_vk.c:743
feature_level_from_caps
static enum wined3d_feature_level feature_level_from_caps(const struct wined3d_physical_device_info *info, const struct shader_caps *shader_caps)
Definition: adapter_vk.c:2205
adapter_vk_destroy_rendertarget_view
static void adapter_vk_destroy_rendertarget_view(struct wined3d_rendertarget_view *view)
Definition: adapter_vk.c:1500
feature_level_9_3_supported
static bool feature_level_9_3_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
Definition: adapter_vk.c:2164
adapter_vk_create_rendertarget_view
static HRESULT adapter_vk_create_rendertarget_view(const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_rendertarget_view **view)
Definition: adapter_vk.c:1374
feature_level_10_supported
static bool feature_level_10_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
Definition: adapter_vk.c:2170
wined3d_allocator_vk_ops
static const struct wined3d_allocator_ops wined3d_allocator_vk_ops
Definition: adapter_vk.c:288
feature_level_11_supported
static bool feature_level_11_supported(const struct wined3d_physical_device_info *info, unsigned int shader_model)
Definition: adapter_vk.c:2190
adapter_vk_release_context
static void adapter_vk_release_context(struct wined3d_context *context)
Definition: adapter_vk.c:485
wined3d_view_vk_destroy_object
static void wined3d_view_vk_destroy_object(void *object)
Definition: adapter_vk.c:1413
wined3d_adapter_vk_init_d3d_info
static void wined3d_adapter_vk_init_d3d_info(struct wined3d_adapter_vk *adapter_vk, uint32_t wined3d_creation_flags)
Definition: adapter_vk.c:2242
adapter_vk_generate_mipmap
static void adapter_vk_generate_mipmap(struct wined3d_context *context, struct wined3d_shader_resource_view *view)
Definition: adapter_vk.c:1811
wined3d_allocator_vk_create_chunk
static struct wined3d_allocator_chunk * wined3d_allocator_vk_create_chunk(struct wined3d_allocator *allocator, struct wined3d_context *context, unsigned int memory_type, size_t chunk_size)
Definition: adapter_vk.c:240
adapter_vk_create_swapchain
static HRESULT adapter_vk_create_swapchain(struct wined3d_device *device, const struct wined3d_swapchain_desc *desc, struct wined3d_swapchain_state_parent *state_parent, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_swapchain **swapchain)
Definition: adapter_vk.c:1224
adapter_vk_create_unordered_access_view
static HRESULT adapter_vk_create_unordered_access_view(const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_unordered_access_view **view)
Definition: adapter_vk.c:1557
adapter_vk_draw_primitive
static void adapter_vk_draw_primitive(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters)
Definition: adapter_vk.c:1681
adapter_vk_destroy_shader_resource_view
static void adapter_vk_destroy_shader_resource_view(struct wined3d_shader_resource_view *view)
Definition: adapter_vk.c:1538
wined3d_get_wine_vk_version
static unsigned int wined3d_get_wine_vk_version(void)
Definition: adapter_vk.c:1859
adapter_vk_destroy
static void adapter_vk_destroy(struct wined3d_adapter *adapter)
Definition: adapter_vk.c:127
vulkan_instance_extensions
static const struct @332 vulkan_instance_extensions[]
wined3d_allocator_vk_destroy_chunk
static void wined3d_allocator_vk_destroy_chunk(struct wined3d_allocator_chunk *chunk)
Definition: adapter_vk.c:266
adapter_vk_destroy_texture
static void adapter_vk_destroy_texture(struct wined3d_texture *texture)
Definition: adapter_vk.c:1349
adapter_vk_destroy_sampler
static void adapter_vk_destroy_sampler(struct wined3d_sampler *sampler)
Definition: adapter_vk.c:1636
adapter_vk_destroy_unordered_access_view
static void adapter_vk_destroy_unordered_access_view(struct wined3d_unordered_access_view *view)
Definition: adapter_vk.c:1583
adapter_vk_create_shader_resource_view
static HRESULT adapter_vk_create_shader_resource_view(const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader_resource_view **view)
Definition: adapter_vk.c:1512
adapter_vk_clear_uav
static void adapter_vk_clear_uav(struct wined3d_context *context, struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value, bool fp)
Definition: adapter_vk.c:1802
adapter_vk_unmap_bo_address
static void adapter_vk_unmap_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *data, unsigned int range_count, const struct wined3d_range *ranges)
Definition: adapter_vk.c:998
wined3d_bo_slab_vk_lock
static void wined3d_bo_slab_vk_lock(struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
Definition: adapter_vk.c:786
state
static int state
Definition: maze.c:121
WINE_DEFAULT_DEBUG_CHANNEL
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
list_remove
static void list_remove(struct list_entry *entry)
Definition: list.h:90
list_add_head
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
list_init
static void list_init(struct list_entry *head)
Definition: list.h:51
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
HW_VENDOR_NVIDIA
#define HW_VENDOR_NVIDIA
Definition: builtin.c:4465
HW_VENDOR_AMD
#define HW_VENDOR_AMD
Definition: builtin.c:4464
HW_VENDOR_INTEL
#define HW_VENDOR_INTEL
Definition: builtin.c:4467
map
Definition: _map.h:48
wined3d_context_vk_apply_compute_state
VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk)
Definition: context_vk.c:4080
wined3d_context_vk_create_bo
BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo)
Definition: context_vk.c:528
wined3d_context_vk_destroy_vk_buffer_view
void wined3d_context_vk_destroy_vk_buffer_view(struct wined3d_context_vk *context_vk, VkBufferView vk_view, uint64_t command_buffer_id)
Definition: context_vk.c:931
wined3d_context_vk_end_current_render_pass
void wined3d_context_vk_end_current_render_pass(struct wined3d_context_vk *context_vk)
Definition: context_vk.c:1564
wined3d_context_vk_destroy_vk_image_view
void wined3d_context_vk_destroy_vk_image_view(struct wined3d_context_vk *context_vk, VkImageView vk_view, uint64_t command_buffer_id)
Definition: context_vk.c:956
wined3d_context_vk_destroy_vk_sampler
void wined3d_context_vk_destroy_vk_sampler(struct wined3d_context_vk *context_vk, VkSampler vk_sampler, uint64_t command_buffer_id)
Definition: context_vk.c:1042
wined3d_context_vk_allocate_vram_chunk_memory
VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory(struct wined3d_context_vk *context_vk, unsigned int pool, size_t size)
Definition: context_vk.c:362
wined3d_allocator_chunk_vk_map
void * wined3d_allocator_chunk_vk_map(struct wined3d_allocator_chunk_vk *chunk_vk, struct wined3d_context_vk *context_vk)
Definition: context_vk.c:304
wined3d_context_vk_apply_draw_state
VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk, bool indexed)
Definition: context_vk.c:3722
wined3d_context_vk_get_command_buffer
VkCommandBuffer wined3d_context_vk_get_command_buffer(struct wined3d_context_vk *context_vk)
Definition: context_vk.c:1805
wined3d_context_vk_destroy_bo
void wined3d_context_vk_destroy_bo(struct wined3d_context_vk *context_vk, const struct wined3d_bo_vk *bo)
Definition: context_vk.c:1106
wined3d_context_vk_cleanup
void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk)
Definition: context_vk.c:1725
wined3d_context_vk_submit_command_buffer
void wined3d_context_vk_submit_command_buffer(struct wined3d_context_vk *context_vk, unsigned int wait_semaphore_count, const VkSemaphore *wait_semaphores, const VkPipelineStageFlags *wait_stages, unsigned int signal_semaphore_count, const VkSemaphore *signal_semaphores)
Definition: context_vk.c:1896
wined3d_allocator_chunk_vk_unmap
void wined3d_allocator_chunk_vk_unmap(struct wined3d_allocator_chunk_vk *chunk_vk, struct wined3d_context_vk *context_vk)
Definition: context_vk.c:338
wined3d_context_vk_wait_command_buffer
void wined3d_context_vk_wait_command_buffer(struct wined3d_context_vk *context_vk, uint64_t id)
Definition: context_vk.c:1990
wined3d_context_vk_init
HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wined3d_swapchain *swapchain)
Definition: context_vk.c:4151
wined3d_cs_destroy_object
void wined3d_cs_destroy_object(struct wined3d_cs *cs, void(*callback)(void *object), void *object)
Definition: cs.c:2299
description
void * description
range
range
Definition: d3dx9_private.h:58
vendor
const WCHAR * vendor
Definition: db.cpp:873
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
free
#define free
Definition: debug_ros.c:5
malloc
#define malloc
Definition: debug_ros.c:4
hr
HRESULT hr
Definition: delayimp.cpp:582
device_type
device_type
Definition: devenum_private.h:31
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
uint32_t
UINT32 uint32_t
Definition: types.h:75
uint64_t
UINT64 uint64_t
Definition: types.h:77
instance
static HINSTANCE instance
Definition: main.c:35
vk_memory_type_from_access_flags
VkMemoryPropertyFlags vk_memory_type_from_access_flags(uint32_t access, uint32_t usage)
Definition: buffer.c:1150
wined3d_buffer_vk_init
HRESULT wined3d_buffer_vk_init(struct wined3d_buffer_vk *buffer_vk, struct wined3d_device *device, const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: buffer.c:1258
wined3d_buffer_cleanup
void wined3d_buffer_cleanup(struct wined3d_buffer *buffer)
Definition: buffer.c:453
vk_buffer_usage_from_bind_flags
VkBufferUsageFlags vk_buffer_usage_from_bind_flags(uint32_t bind_flags)
Definition: buffer.c:1126
wined3d_device_vk_create_null_resources
bool wined3d_device_vk_create_null_resources(struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
Definition: device.c:839
wined3d_device_destroy_default_samplers
void wined3d_device_destroy_default_samplers(struct wined3d_device *device)
Definition: device.c:784
wined3d_device_decref
ULONG CDECL wined3d_device_decref(struct wined3d_device *device)
Definition: device.c:251
wined3d_device_init
HRESULT wined3d_device_init(struct wined3d_device *device, struct wined3d *wined3d, unsigned int adapter_idx, enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, const BOOL *supported_extensions, struct wined3d_device_parent *device_parent)
Definition: device.c:5479
device_context_add
BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *context)
Definition: device.c:84
wined3d_device_vk_destroy_null_views
void wined3d_device_vk_destroy_null_views(struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
Definition: device.c:1114
wined3d_device_vk_destroy_null_resources
void wined3d_device_vk_destroy_null_resources(struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
Definition: device.c:910
wined3d_device_cleanup
void wined3d_device_cleanup(struct wined3d_device *device)
Definition: device.c:205
device_context_remove
void device_context_remove(struct wined3d_device *device, struct wined3d_context *context)
Definition: device.c:118
wined3d_device_vk_create_null_views
bool wined3d_device_vk_create_null_views(struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
Definition: device.c:929
wined3d_device_incref
ULONG CDECL wined3d_device_incref(struct wined3d_device *device)
Definition: device.c:161
wined3d_device_create_default_samplers
void wined3d_device_create_default_samplers(struct wined3d_device *device, struct wined3d_context *context)
Definition: device.c:737
wined3d_query_vk_create
HRESULT wined3d_query_vk_create(struct wined3d_device *device, enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
Definition: query.c:1894
wined3d_cpu_blitter_create
struct wined3d_blitter * wined3d_cpu_blitter_create(void)
Definition: surface.c:1300
wined3d_texture_cleanup
void wined3d_texture_cleanup(struct wined3d_texture *texture)
Definition: texture.c:1593
wined3d_texture_sub_resources_destroyed
void wined3d_texture_sub_resources_destroyed(struct wined3d_texture *texture)
Definition: texture.c:1111
wined3d_texture_vk_init
HRESULT wined3d_texture_vk_init(struct wined3d_texture_vk *texture_vk, struct wined3d_device *device, const struct wined3d_resource_desc *desc, unsigned int layer_count, unsigned int level_count, uint32_t flags, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: texture.c:5484
wined3d_vk_blitter_create
void wined3d_vk_blitter_create(struct wined3d_blitter **next)
Definition: texture.c:7048
wined3d_allocator_init
bool wined3d_allocator_init(struct wined3d_allocator *allocator, size_t pool_count, const struct wined3d_allocator_ops *allocator_ops)
Definition: utils.c:7265
wined3d_allocator_cleanup
void wined3d_allocator_cleanup(struct wined3d_allocator *allocator)
Definition: utils.c:7163
wined3d_get_primary_adapter_luid
BOOL wined3d_get_primary_adapter_luid(LUID *luid)
Definition: utils.c:5761
wined3d_adapter_vk_init_format_info
BOOL wined3d_adapter_vk_init_format_info(struct wined3d_adapter_vk *adapter_vk, const struct wined3d_vk_info *vk_info)
Definition: utils.c:4399
wined3d_debug_vkresult
const char * wined3d_debug_vkresult(VkResult vr)
Definition: utils.c:5463
debug_uvec4
const char * debug_uvec4(const struct wined3d_uvec4 *v)
Definition: utils.c:4577
wined3d_allocator_chunk_init
bool wined3d_allocator_chunk_init(struct wined3d_allocator_chunk *chunk, struct wined3d_allocator *allocator)
Definition: utils.c:7141
wined3d_array_reserve
BOOL wined3d_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size)
Definition: utils.c:6740
wined3d_allocator_chunk_cleanup
void wined3d_allocator_chunk_cleanup(struct wined3d_allocator_chunk *chunk)
Definition: utils.c:7117
wined3d_debug_view_desc
const char * wined3d_debug_view_desc(const struct wined3d_view_desc *d, const struct wined3d_resource *resource)
Definition: utils.c:4867
wined3d_rendertarget_view_vk_init
HRESULT wined3d_rendertarget_view_vk_init(struct wined3d_rendertarget_view_vk *view_vk, const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: view.c:916
wined3d_shader_resource_view_vk_init
HRESULT wined3d_shader_resource_view_vk_init(struct wined3d_shader_resource_view_vk *view_vk, const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: view.c:1243
wined3d_shader_resource_view_cleanup
void wined3d_shader_resource_view_cleanup(struct wined3d_shader_resource_view *view)
Definition: view.c:978
wined3d_device_vk_uav_clear_state_init
void wined3d_device_vk_uav_clear_state_init(struct wined3d_device_vk *device_vk)
Definition: view.c:1989
wined3d_shader_resource_view_vk_generate_mipmap
void wined3d_shader_resource_view_vk_generate_mipmap(struct wined3d_shader_resource_view_vk *srv_vk, struct wined3d_context_vk *context_vk)
Definition: view.c:1382
wined3d_unordered_access_view_cleanup
void wined3d_unordered_access_view_cleanup(struct wined3d_unordered_access_view *view)
Definition: view.c:1531
wined3d_unordered_access_view_vk_clear
void wined3d_unordered_access_view_vk_clear(struct wined3d_unordered_access_view_vk *view_vk, const struct wined3d_uvec4 *clear_value, struct wined3d_context_vk *context_vk, bool fp)
Definition: view.c:2077
wined3d_device_vk_uav_clear_state_cleanup
void wined3d_device_vk_uav_clear_state_cleanup(struct wined3d_device_vk *device_vk)
Definition: view.c:2057
wined3d_rendertarget_view_cleanup
void wined3d_rendertarget_view_cleanup(struct wined3d_rendertarget_view *view)
Definition: view.c:374
wined3d_unordered_access_view_vk_init
HRESULT wined3d_unordered_access_view_vk_init(struct wined3d_unordered_access_view_vk *view_vk, const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: view.c:2533
wine_dbg_sprintf
const char * wine_dbg_sprintf(const char *format,...)
Definition: compat.c:296
CDECL
#define CDECL
Definition: compat.h:29
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
FreeLibrary
#define FreeLibrary(x)
Definition: compat.h:748
wine_dbgstr_longlong
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
api_version
static API_VERSION api_version
Definition: dbghelp.c:832
version
static const WCHAR version[]
Definition: asmname.c:66
GetModuleHandleW
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
assert
#define assert(_expr)
Definition: assert.h:32
uintptr_t
unsigned int uintptr_t
Definition: corecrt.h:185
uint8_t
unsigned char uint8_t
Definition: stdint.h:33
atoi
_ACRTIMP int __cdecl atoi(const char *)
Definition: string.c:1720
strcmp
_ACRTIMP int __cdecl strcmp(const char *, const char *)
Definition: string.c:3324
L
#define L(x)
Definition: resources.c:13
parent
r parent
Definition: btrfs.c:3010
state_nop
void state_nop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
Definition: ffp_gl.c:42
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
adapter
return adapter
Definition: fxdmaenablerapi.cpp:445
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
s
GLdouble s
Definition: gl.h:2039
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
texture
GLenum GLuint texture
Definition: glext.h:6295
src
GLenum src
Definition: glext.h:6340
buffer
GLuint buffer
Definition: glext.h:5915
size
GLsizeiptr size
Definition: glext.h:5919
offset
GLintptr offset
Definition: glext.h:5920
c
const GLubyte * c
Definition: glext.h:8905
sampler
GLuint sampler
Definition: glext.h:7283
shader
GLuint shader
Definition: glext.h:6030
dst
GLenum GLenum dst
Definition: glext.h:6340
flags
GLbitfield flags
Definition: glext.h:7161
addr
GLenum const GLvoid * addr
Definition: glext.h:9621
levels
GLsizei levels
Definition: glext.h:7884
priorities
const GLuint const GLclampf * priorities
Definition: glext.h:8103
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
usage
GLsizeiptr const GLvoid GLenum usage
Definition: glext.h:5919
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
u
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
S_OK
#define S_OK
Definition: intsafe.h:52
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
entry
uint32_t entry
Definition: isohybrid.c:63
c
#define c
Definition: ke_i.h:80
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
if
if(dx< 0)
Definition: linetemp.h:194
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ptr
static PVOID ptr
Definition: dispmode.c:27
desc
D3D11_SHADER_VARIABLE_DESC desc
Definition: reflection.c:1683
parameters
static BYTE parameters[]
Definition: asn.c:558
min
#define min(a, b)
Definition: monoChain.cc:55
app_name
LPCWSTR app_name
Definition: notevil.c:34
calloc
#define calloc
Definition: rosglue.h:14
wined3d_sampler_vk_init
void wined3d_sampler_vk_init(struct wined3d_sampler_vk *sampler_vk, struct wined3d_device *device, const struct wined3d_sampler_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: sampler.c:277
LIST_FOR_EACH_ENTRY
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:236
memset
#define memset(x, y, z)
Definition: compat.h:39
wined3d_spirv_fragment_pipe_init_vk
const struct wined3d_fragment_pipe_ops * wined3d_spirv_fragment_pipe_init_vk(void)
Definition: shader_spirv.c:1311
wined3d_spirv_shader_backend_init_vk
const struct wined3d_shader_backend_ops * wined3d_spirv_shader_backend_init_vk(void)
Definition: shader_spirv.c:1161
wined3d_spirv_vertex_pipe_init_vk
const struct wined3d_vertex_pipe_ops * wined3d_spirv_vertex_pipe_init_vk(void)
Definition: shader_spirv.c:1227
minor
#define minor(rdev)
Definition: propsheet.cpp:929
major
#define major(rdev)
Definition: propsheet.cpp:928
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
VkApplicationInfo::engineVersion
uint32_t engineVersion
Definition: vulkan.h:7346
VkApplicationInfo::pApplicationName
const char * pApplicationName
Definition: vulkan.h:7343
VkApplicationInfo::sType
VkStructureType sType
Definition: vulkan.h:7341
VkApplicationInfo::apiVersion
uint32_t apiVersion
Definition: vulkan.h:7347
VkApplicationInfo::pEngineName
const char * pEngineName
Definition: vulkan.h:7345
VkBufferMemoryBarrier::srcAccessMask
VkAccessFlags srcAccessMask
Definition: vulkan.h:7632
VkBufferMemoryBarrier::dstAccessMask
VkAccessFlags dstAccessMask
Definition: vulkan.h:7633
VkBufferMemoryBarrier::srcQueueFamilyIndex
uint32_t srcQueueFamilyIndex
Definition: vulkan.h:7634
VkBufferMemoryBarrier::pNext
const void * pNext
Definition: vulkan.h:7631
VkBufferMemoryBarrier::sType
VkStructureType sType
Definition: vulkan.h:7630
VkBufferMemoryBarrier::dstQueueFamilyIndex
uint32_t dstQueueFamilyIndex
Definition: vulkan.h:7635
VkDeviceQueueCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan.h:8544
VkDeviceQueueCreateInfo::flags
VkDeviceQueueCreateFlags flags
Definition: vulkan.h:8543
VkDeviceQueueCreateInfo::pQueuePriorities
const float * pQueuePriorities
Definition: vulkan.h:8546
VkDeviceQueueCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:8541
VkDeviceQueueCreateInfo::pNext
const void * pNext
Definition: vulkan.h:8542
VkInstanceCreateInfo::ppEnabledExtensionNames
const char *const * ppEnabledExtensionNames
Definition: vulkan.h:9251
VkInstanceCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:9244
VkInstanceCreateInfo::enabledExtensionCount
uint32_t enabledExtensionCount
Definition: vulkan.h:9250
VkInstanceCreateInfo::pApplicationInfo
const VkApplicationInfo * pApplicationInfo
Definition: vulkan.h:9247
VkMemoryType::propertyFlags
VkMemoryPropertyFlags propertyFlags
Definition: vulkan.h:9474
VkPhysicalDeviceFeatures2::sType
VkStructureType sType
Definition: vulkan.h:10622
VkPhysicalDeviceFeatures2::features
VkPhysicalDeviceFeatures features
Definition: vulkan.h:10624
VkPhysicalDeviceFeatures::shaderStorageBufferArrayDynamicIndexing
VkBool32 shaderStorageBufferArrayDynamicIndexing
Definition: vulkan.h:10598
VkPhysicalDeviceFeatures::shaderResourceMinLod
VkBool32 shaderResourceMinLod
Definition: vulkan.h:10606
VkPhysicalDeviceFeatures::sparseResidency2Samples
VkBool32 sparseResidency2Samples
Definition: vulkan.h:10611
VkPhysicalDeviceFeatures::textureCompressionASTC_LDR
VkBool32 textureCompressionASTC_LDR
Definition: vulkan.h:10584
VkPhysicalDeviceFeatures::shaderStorageImageMultisample
VkBool32 shaderStorageImageMultisample
Definition: vulkan.h:10593
VkPhysicalDeviceFeatures::sparseResidency16Samples
VkBool32 sparseResidency16Samples
Definition: vulkan.h:10614
VkPhysicalDeviceFeatures::shaderSampledImageArrayDynamicIndexing
VkBool32 shaderSampledImageArrayDynamicIndexing
Definition: vulkan.h:10597
VkPhysicalDeviceFeatures::shaderResourceResidency
VkBool32 shaderResourceResidency
Definition: vulkan.h:10605
VkPhysicalDeviceFeatures::sparseResidency4Samples
VkBool32 sparseResidency4Samples
Definition: vulkan.h:10612
VkPhysicalDeviceFeatures::shaderStorageImageArrayDynamicIndexing
VkBool32 shaderStorageImageArrayDynamicIndexing
Definition: vulkan.h:10599
VkPhysicalDeviceFeatures::sparseResidencyImage2D
VkBool32 sparseResidencyImage2D
Definition: vulkan.h:10609
VkPhysicalDeviceFeatures::textureCompressionETC2
VkBool32 textureCompressionETC2
Definition: vulkan.h:10583
VkPhysicalDeviceFeatures::sparseResidencyImage3D
VkBool32 sparseResidencyImage3D
Definition: vulkan.h:10610
VkPhysicalDeviceFeatures::shaderTessellationAndGeometryPointSize
VkBool32 shaderTessellationAndGeometryPointSize
Definition: vulkan.h:10590
VkPhysicalDeviceFeatures::shaderUniformBufferArrayDynamicIndexing
VkBool32 shaderUniformBufferArrayDynamicIndexing
Definition: vulkan.h:10596
VkPhysicalDeviceFeatures::sparseResidencyAliased
VkBool32 sparseResidencyAliased
Definition: vulkan.h:10615
VkPhysicalDeviceFeatures::sparseResidency8Samples
VkBool32 sparseResidency8Samples
Definition: vulkan.h:10613
VkPhysicalDeviceFeatures::sparseResidencyBuffer
VkBool32 sparseResidencyBuffer
Definition: vulkan.h:10608
VkPhysicalDeviceIDProperties::driverUUID
uint8_t driverUUID[VK_UUID_SIZE]
Definition: vulkan.h:10863
VkPhysicalDeviceIDProperties::sType
VkStructureType sType
Definition: vulkan.h:10860
VkPhysicalDeviceIDProperties::deviceLUID
uint8_t deviceLUID[VK_LUID_SIZE]
Definition: vulkan.h:10864
VkPhysicalDeviceIDProperties::deviceUUID
uint8_t deviceUUID[VK_UUID_SIZE]
Definition: vulkan.h:10862
VkPhysicalDeviceLimits::maxImageDimension2D
uint32_t maxImageDimension2D
Definition: vulkan.h:11063
VkPhysicalDeviceLimits::framebufferColorSampleCounts
VkSampleCountFlags framebufferColorSampleCounts
Definition: vulkan.h:11142
VkPhysicalDeviceLimits::maxImageDimension3D
uint32_t maxImageDimension3D
Definition: vulkan.h:11064
VkPhysicalDeviceLimits::framebufferStencilSampleCounts
VkSampleCountFlags framebufferStencilSampleCounts
Definition: vulkan.h:11144
VkPhysicalDeviceLimits::pointSizeRange
float pointSizeRange[2]
Definition: vulkan.h:11159
VkPhysicalDeviceLimits::framebufferNoAttachmentsSampleCounts
VkSampleCountFlags framebufferNoAttachmentsSampleCounts
Definition: vulkan.h:11145
VkPhysicalDeviceLimits::framebufferDepthSampleCounts
VkSampleCountFlags framebufferDepthSampleCounts
Definition: vulkan.h:11143
VkPhysicalDeviceMemoryProperties::memoryTypes
VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]
Definition: vulkan.h:11320
VkPhysicalDeviceProperties2::sType
VkStructureType sType
Definition: vulkan.h:16583
VkPhysicalDeviceProperties::deviceName
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]
Definition: vulkan.h:16575
VkQueueFamilyProperties::timestampValidBits
uint32_t timestampValidBits
Definition: vulkan.h:13538
_LUID
Definition: devicetopology.idl:137
context
Definition: http.c:7252
device_info
Definition: monitor.c:321
device
Definition: devices.h:37
heap
Definition: heap.c:86
heap::flags
UINT flags
Definition: heap.c:93
name
Definition: name.c:39
resource::size
size_t size
Definition: utils.c:170
shader_caps
Definition: wined3d_private.h:1411
shader_caps::wined3d_caps
DWORD wined3d_caps
Definition: wined3d_private.h:1424
shader_caps::vs_version
unsigned int vs_version
Definition: wined3d_private.h:1412
shader_caps::varying_count
unsigned int varying_count
Definition: wined3d_private.h:1422
shader_caps::cs_version
unsigned int cs_version
Definition: wined3d_private.h:1417
shader_caps::ps_uniform_count
unsigned int ps_uniform_count
Definition: wined3d_private.h:1420
shader_caps::hs_version
unsigned int hs_version
Definition: wined3d_private.h:1413
shader_caps::gs_version
unsigned int gs_version
Definition: wined3d_private.h:1415
shader_caps::vs_uniform_count
unsigned int vs_uniform_count
Definition: wined3d_private.h:1419
shader_caps::ps_version
unsigned int ps_version
Definition: wined3d_private.h:1416
shader_caps::ds_version
unsigned int ds_version
Definition: wined3d_private.h:1414
vulkan_ops
Definition: wined3d_vk.h:220
vulkan_ops::vkGetInstanceProcAddr
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: wined3d_vk.h:233
vulkan_ops::vkCreateInstance
PFN_vkCreateInstance vkCreateInstance
Definition: wined3d_vk.h:232
wined3d_adapter_ops
Definition: wined3d_private.h:2508
wined3d_adapter_vk
Definition: wined3d_vk.h:725
wined3d_adapter_vk::device_extension_count
unsigned int device_extension_count
Definition: wined3d_vk.h:729
wined3d_adapter_vk::memory_properties
VkPhysicalDeviceMemoryProperties memory_properties
Definition: wined3d_vk.h:734
wined3d_adapter_vk::device_extensions
const char ** device_extensions
Definition: wined3d_vk.h:730
wined3d_adapter_vk::a
struct wined3d_adapter a
Definition: wined3d_vk.h:726
wined3d_adapter_vk::vk_info
struct wined3d_vk_info vk_info
Definition: wined3d_vk.h:728
wined3d_adapter_vk::physical_device
VkPhysicalDevice physical_device
Definition: wined3d_vk.h:731
wined3d_adapter_vk::device_limits
VkPhysicalDeviceLimits device_limits
Definition: wined3d_vk.h:733
wined3d_adapter
Definition: wined3d_private.h:2602
wined3d_adapter::luid
LUID luid
Definition: wined3d_private.h:2613
wined3d_adapter::ordinal
unsigned int ordinal
Definition: wined3d_private.h:2603
wined3d_allocator_chunk_vk
Definition: wined3d_vk.h:778
wined3d_allocator_chunk_vk::vk_memory
VkDeviceMemory vk_memory
Definition: wined3d_vk.h:780
wined3d_allocator_chunk_vk::c
struct wined3d_allocator_chunk c
Definition: wined3d_vk.h:779
wined3d_allocator_chunk
Definition: wined3d_private.h:3129
wined3d_allocator_ops
Definition: wined3d_private.h:3159
wined3d_allocator
Definition: wined3d_private.h:3166
wined3d_bo_address
Definition: wined3d_private.h:1617
wined3d_bo_address::buffer_object
struct wined3d_bo * buffer_object
Definition: wined3d_private.h:1618
wined3d_bo_address::addr
BYTE * addr
Definition: wined3d_private.h:1619
wined3d_bo_slab_vk
Definition: wined3d_vk.h:339
wined3d_bo_slab_vk::map_ptr
void * map_ptr
Definition: wined3d_vk.h:345
wined3d_bo_slab_vk::map_count
unsigned int map_count
Definition: wined3d_vk.h:344
wined3d_bo_slab_vk::bo
struct wined3d_bo_vk bo
Definition: wined3d_vk.h:343
wined3d_bo_user
Definition: wined3d_private.h:1611
wined3d_bo_user::valid
bool valid
Definition: wined3d_private.h:1613
wined3d_bo_vk
Definition: wined3d_vk.h:309
wined3d_bo_vk::memory
struct wined3d_allocator_block * memory
Definition: wined3d_vk.h:313
wined3d_bo_vk::b
struct wined3d_bo b
Definition: wined3d_vk.h:310
wined3d_bo_vk::usage
VkBufferUsageFlags usage
Definition: wined3d_vk.h:319
wined3d_bo_vk::vk_buffer
VkBuffer vk_buffer
Definition: wined3d_vk.h:312
wined3d_bo_vk::size
VkDeviceSize size
Definition: wined3d_vk.h:318
wined3d_bo_vk::command_buffer_id
uint64_t command_buffer_id
Definition: wined3d_vk.h:322
wined3d_bo_vk::host_synced
bool host_synced
Definition: wined3d_vk.h:323
wined3d_bo_vk::memory_type
VkMemoryPropertyFlags memory_type
Definition: wined3d_vk.h:320
wined3d_bo_vk::vk_memory
VkDeviceMemory vk_memory
Definition: wined3d_vk.h:316
wined3d_bo
Definition: wined3d_private.h:1594
wined3d_buffer_desc
Definition: wined3d.h:2025
wined3d_buffer_vk
Definition: wined3d_vk.h:919
wined3d_buffer_vk::b
struct wined3d_buffer b
Definition: wined3d_vk.h:920
wined3d_buffer
Definition: wined3d_private.h:3875
wined3d_caps
Definition: wined3d.h:1919
wined3d_caps::MaxVertexShader30InstructionSlots
DWORD MaxVertexShader30InstructionSlots
Definition: wined3d.h:1996
wined3d_caps::VS20Caps
struct wined3d_vertex_shader_caps VS20Caps
Definition: wined3d.h:1991
wined3d_caps::VolumeTextureAddressCaps
DWORD VolumeTextureAddressCaps
Definition: wined3d.h:1940
wined3d_caps::PrimitiveMiscCaps
DWORD PrimitiveMiscCaps
Definition: wined3d.h:1928
wined3d_caps::TextureAddressCaps
DWORD TextureAddressCaps
Definition: wined3d.h:1939
wined3d_caps::TextureCaps
DWORD TextureCaps
Definition: wined3d.h:1935
wined3d_caps::MaxAnisotropy
DWORD MaxAnisotropy
Definition: wined3d.h:1948
wined3d_caps::MaxPixelShader30InstructionSlots
DWORD MaxPixelShader30InstructionSlots
Definition: wined3d.h:1997
wined3d_caps::MaxVolumeExtent
DWORD MaxVolumeExtent
Definition: wined3d.h:1945
wined3d_caps::VolumeTextureFilterCaps
DWORD VolumeTextureFilterCaps
Definition: wined3d.h:1938
wined3d_caps::DestBlendCaps
DWORD DestBlendCaps
Definition: wined3d.h:1932
wined3d_caps::RasterCaps
DWORD RasterCaps
Definition: wined3d.h:1929
wined3d_caps::PS20Caps
struct wined3d_pixel_shader_caps PS20Caps
Definition: wined3d.h:1992
wined3d_caps::Caps2
DWORD Caps2
Definition: wined3d.h:1923
wined3d_caps::CubeTextureFilterCaps
DWORD CubeTextureFilterCaps
Definition: wined3d.h:1937
wined3d_caps::StencilCaps
DWORD StencilCaps
Definition: wined3d.h:1957
wined3d_caps::SrcBlendCaps
DWORD SrcBlendCaps
Definition: wined3d.h:1931
wined3d_caps::DeclTypes
DWORD DeclTypes
Definition: wined3d.h:1988
wined3d_caps::TextureFilterCaps
DWORD TextureFilterCaps
Definition: wined3d.h:1936
wined3d_caps::ddraw_caps
struct wined3d_ddraw_caps ddraw_caps
Definition: wined3d.h:1999
wined3d_const_bo_address
Definition: wined3d_private.h:1623
wined3d_context_vk
Definition: wined3d_vk.h:587
wined3d_context_vk::vk_so_offsets
VkDeviceSize vk_so_offsets[WINED3D_MAX_STREAM_OUTPUT_BUFFERS]
Definition: wined3d_vk.h:644
wined3d_context_vk::current_command_buffer
struct wined3d_command_buffer_vk current_command_buffer
Definition: wined3d_vk.h:617
wined3d_context_vk::vk_so_counter_bo
struct wined3d_bo_vk vk_so_counter_bo
Definition: wined3d_vk.h:645
wined3d_context_vk::completed_command_buffer_id
uint64_t completed_command_buffer_id
Definition: wined3d_vk.h:618
wined3d_context_vk::vk_info
const struct wined3d_vk_info * vk_info
Definition: wined3d_vk.h:590
wined3d_context_vk::command_buffer_work_count
unsigned int command_buffer_work_count
Definition: wined3d_vk.h:622
wined3d_context_vk::vk_so_counters
VkBuffer vk_so_counters[WINED3D_MAX_STREAM_OUTPUT_BUFFERS]
Definition: wined3d_vk.h:643
wined3d_context_vk::c
struct wined3d_context c
Definition: wined3d_vk.h:588
wined3d_context
Definition: wined3d_private.h:1871
wined3d_context::sub_resource_idx
unsigned int sub_resource_idx
Definition: wined3d_private.h:1882
wined3d_d3d_info
Definition: wined3d_private.h:219
wined3d_d3d_info::subpixel_viewport
uint32_t subpixel_viewport
Definition: wined3d_private.h:241
wined3d_d3d_info::stencil_export
uint32_t stencil_export
Definition: wined3d_private.h:228
wined3d_d3d_info::gpu_push_constants
uint32_t gpu_push_constants
Definition: wined3d_private.h:244
wined3d_d3d_info::ffp_fragment_caps
struct fragment_caps ffp_fragment_caps
Definition: wined3d_private.h:220
wined3d_d3d_info::viewport_array_index_any_shader
uint32_t viewport_array_index_any_shader
Definition: wined3d_private.h:227
wined3d_d3d_info::full_ffp_varyings
uint32_t full_ffp_varyings
Definition: wined3d_private.h:238
wined3d_d3d_info::srgb_read_control
uint32_t srgb_read_control
Definition: wined3d_private.h:235
wined3d_d3d_info::feature_level
enum wined3d_feature_level feature_level
Definition: wined3d_private.h:246
wined3d_d3d_info::vertex_bgra
uint32_t vertex_bgra
Definition: wined3d_private.h:233
wined3d_d3d_info::ffp_alpha_test
uint32_t ffp_alpha_test
Definition: wined3d_private.h:224
wined3d_d3d_info::texture_swizzle
uint32_t texture_swizzle
Definition: wined3d_private.h:234
wined3d_d3d_info::limits
struct wined3d_d3d_limits limits
Definition: wined3d_private.h:221
wined3d_d3d_info::shader_double_precision
uint32_t shader_double_precision
Definition: wined3d_private.h:225
wined3d_d3d_info::pbo
uint32_t pbo
Definition: wined3d_private.h:240
wined3d_d3d_info::wined3d_creation_flags
uint32_t wined3d_creation_flags
Definition: wined3d_private.h:222
wined3d_d3d_info::emulated_flatshading
uint32_t emulated_flatshading
Definition: wined3d_private.h:223
wined3d_d3d_info::draw_base_vertex_offset
uint32_t draw_base_vertex_offset
Definition: wined3d_private.h:232
wined3d_d3d_info::shader_output_interpolation
uint32_t shader_output_interpolation
Definition: wined3d_private.h:226
wined3d_d3d_info::fences
uint32_t fences
Definition: wined3d_private.h:242
wined3d_d3d_info::filling_convention_offset
float filling_convention_offset
Definition: wined3d_private.h:250
wined3d_d3d_info::persistent_map
uint32_t persistent_map
Definition: wined3d_private.h:243
wined3d_d3d_info::multisample_draw_location
DWORD multisample_draw_location
Definition: wined3d_private.h:248
wined3d_d3d_info::srgb_write_control
uint32_t srgb_write_control
Definition: wined3d_private.h:236
wined3d_d3d_info::clip_control
uint32_t clip_control
Definition: wined3d_private.h:237
wined3d_d3d_info::ffp_hlsl
uint32_t ffp_hlsl
Definition: wined3d_private.h:245
wined3d_d3d_info::unconditional_npot
uint32_t unconditional_npot
Definition: wined3d_private.h:231
wined3d_d3d_info::scaled_resolve
uint32_t scaled_resolve
Definition: wined3d_private.h:239
wined3d_device_parent
Definition: wined3d.h:2245
wined3d_device_vk
Definition: wined3d_vk.h:820
wined3d_device_vk::vk_queue
VkQueue vk_queue
Definition: wined3d_vk.h:826
wined3d_device_vk::d
struct wined3d_device d
Definition: wined3d_vk.h:821
wined3d_device_vk::vk_device
VkDevice vk_device
Definition: wined3d_vk.h:825
wined3d_device_vk::allocator_cs
CRITICAL_SECTION allocator_cs
Definition: wined3d_vk.h:835
wined3d_device_vk::vk_queue_family_index
uint32_t vk_queue_family_index
Definition: wined3d_vk.h:827
wined3d_device_vk::vk_info
struct wined3d_vk_info vk_info
Definition: wined3d_vk.h:830
wined3d_device_vk::context_vk
struct wined3d_context_vk context_vk
Definition: wined3d_vk.h:823
wined3d_device_vk::timestamp_bits
uint32_t timestamp_bits
Definition: wined3d_vk.h:828
wined3d_device_vk::allocator
struct wined3d_allocator allocator
Definition: wined3d_vk.h:836
wined3d_device
Definition: wined3d_private.h:3007
wined3d_device::swapchain_count
UINT swapchain_count
Definition: wined3d_private.h:3041
wined3d_direct_dispatch_parameters
Definition: wined3d_private.h:1656
wined3d_direct_dispatch_parameters::group_count_y
unsigned int group_count_y
Definition: wined3d_private.h:1658
wined3d_direct_dispatch_parameters::group_count_x
unsigned int group_count_x
Definition: wined3d_private.h:1657
wined3d_direct_dispatch_parameters::group_count_z
unsigned int group_count_z
Definition: wined3d_private.h:1659
wined3d_dispatch_parameters
Definition: wined3d_private.h:1669
wined3d_draw_parameters
Definition: wined3d_private.h:1694
wined3d_format
Definition: wined3d_private.h:4528
wined3d_gpu_description
Definition: wined3d_private.h:2463
wined3d_parent_ops
Definition: wined3d.h:2215
wined3d_physical_device_info
Definition: adapter_vk.c:171
wined3d_physical_device_info::dynamic_state2_features
VkPhysicalDeviceExtendedDynamicState2FeaturesEXT dynamic_state2_features
Definition: adapter_vk.c:173
wined3d_physical_device_info::draw_parameters_features
VkPhysicalDeviceShaderDrawParametersFeatures draw_parameters_features
Definition: adapter_vk.c:176
wined3d_physical_device_info::dynamic_state_features
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state_features
Definition: adapter_vk.c:172
wined3d_physical_device_info::dynamic_state3_features
VkPhysicalDeviceExtendedDynamicState3FeaturesEXT dynamic_state3_features
Definition: adapter_vk.c:174
wined3d_physical_device_info::xfb_features
VkPhysicalDeviceTransformFeedbackFeaturesEXT xfb_features
Definition: adapter_vk.c:177
wined3d_physical_device_info::vertex_divisor_features
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT vertex_divisor_features
Definition: adapter_vk.c:178
wined3d_physical_device_info::host_query_reset_features
VkPhysicalDeviceHostQueryResetFeatures host_query_reset_features
Definition: adapter_vk.c:175
wined3d_physical_device_info::features2
VkPhysicalDeviceFeatures2 features2
Definition: adapter_vk.c:180
wined3d_query_vk
Definition: wined3d_vk.h:394
wined3d_query_vk::q
struct wined3d_query q
Definition: wined3d_vk.h:395
wined3d_query
Definition: wined3d_private.h:1835
wined3d_range
Definition: wined3d_private.h:1859
wined3d_rendertarget_view_vk
Definition: wined3d_vk.h:948
wined3d_rendertarget_view_vk::command_buffer_id
uint64_t command_buffer_id
Definition: wined3d_vk.h:952
wined3d_rendertarget_view_vk::v
struct wined3d_rendertarget_view v
Definition: wined3d_vk.h:949
wined3d_rendertarget_view_vk::vk_image_view
VkImageView vk_image_view
Definition: wined3d_vk.h:951
wined3d_rendertarget_view
Definition: wined3d_private.h:3932
wined3d_resource_desc
Definition: wined3d.h:1790
wined3d_resource
Definition: wined3d_private.h:3238
wined3d_resource::parent_ops
const struct wined3d_parent_ops * parent_ops
Definition: wined3d_private.h:3269
wined3d_sampler_desc
Definition: wined3d.h:2085
wined3d_sampler_vk
Definition: wined3d_vk.h:902
wined3d_sampler_vk::s
struct wined3d_sampler s
Definition: wined3d_vk.h:903
wined3d_sampler_vk::vk_image_info
VkDescriptorImageInfo vk_image_info
Definition: wined3d_vk.h:905
wined3d_sampler_vk::command_buffer_id
uint64_t command_buffer_id
Definition: wined3d_vk.h:906
wined3d_sampler
Definition: wined3d_private.h:3557
wined3d_shader_resource_view_vk
Definition: wined3d_vk.h:995
wined3d_shader_resource_view_vk::view_vk
struct wined3d_view_vk view_vk
Definition: wined3d_vk.h:997
wined3d_shader_resource_view_vk::v
struct wined3d_shader_resource_view v
Definition: wined3d_vk.h:996
wined3d_shader_resource_view
Definition: wined3d_private.h:3972
wined3d_shader
Definition: wined3d_private.h:4256
wined3d_shader::shader_list_entry
struct list shader_list_entry
Definition: wined3d_private.h:4290
wined3d_state_entry_template
Definition: wined3d_private.h:1943
wined3d_state
Definition: wined3d_private.h:2925
wined3d_sub_resource_data
Definition: wined3d.h:1865
wined3d_swapchain_desc
Definition: wined3d.h:1770
wined3d_swapchain_state_parent
Definition: wined3d.h:2260
wined3d_swapchain_vk
Definition: wined3d_vk.h:1052
wined3d_swapchain_vk::s
struct wined3d_swapchain s
Definition: wined3d_vk.h:1053
wined3d_swapchain
Definition: wined3d_private.h:4047
wined3d_texture_vk
Definition: wined3d_vk.h:874
wined3d_texture_vk::t
struct wined3d_texture t
Definition: wined3d_vk.h:875
wined3d_texture
Definition: wined3d_private.h:3375
wined3d_texture::swapchain
struct wined3d_swapchain * swapchain
Definition: wined3d_private.h:3378
wined3d_unordered_access_view_vk
Definition: wined3d_vk.h:1023
wined3d_unordered_access_view_vk::vk_counter_view
VkBufferView vk_counter_view
Definition: wined3d_vk.h:1027
wined3d_unordered_access_view_vk::counter_bo
struct wined3d_bo_vk counter_bo
Definition: wined3d_vk.h:1028
wined3d_unordered_access_view_vk::v
struct wined3d_unordered_access_view v
Definition: wined3d_vk.h:1024
wined3d_unordered_access_view_vk::view_vk
struct wined3d_view_vk view_vk
Definition: wined3d_vk.h:1025
wined3d_unordered_access_view
Definition: wined3d_private.h:3996
wined3d_uvec4
Definition: wined3d.h:1658
wined3d_vertex_caps
Definition: wined3d_private.h:1967
wined3d_vertex_caps::emulated_flatshading
BOOL emulated_flatshading
Definition: wined3d_private.h:1968
wined3d_vertex_caps::max_vertex_blend_matrices
DWORD max_vertex_blend_matrices
Definition: wined3d_private.h:1970
wined3d_vertex_caps::max_active_lights
DWORD max_active_lights
Definition: wined3d_private.h:1969
wined3d_view_desc
Definition: wined3d.h:2129
wined3d_view_vk_destroy_ctx
Definition: adapter_vk.c:1401
wined3d_view_vk_destroy_ctx::free
struct wined3d_view_vk_destroy_ctx * free
Definition: adapter_vk.c:1410
wined3d_view_vk_destroy_ctx::vk_counter_view
VkBufferView * vk_counter_view
Definition: adapter_vk.c:1407
wined3d_view_vk_destroy_ctx::vk_buffer_view
VkBufferView * vk_buffer_view
Definition: adapter_vk.c:1403
wined3d_view_vk_destroy_ctx::vk_counter_bo
struct wined3d_bo_vk * vk_counter_bo
Definition: adapter_vk.c:1406
wined3d_view_vk_destroy_ctx::vk_image_view
VkImageView * vk_image_view
Definition: adapter_vk.c:1404
wined3d_view_vk_destroy_ctx::device_vk
struct wined3d_device_vk * device_vk
Definition: adapter_vk.c:1402
wined3d_view_vk_destroy_ctx::object
void * object
Definition: adapter_vk.c:1409
wined3d_view_vk_destroy_ctx::command_buffer_id
uint64_t * command_buffer_id
Definition: adapter_vk.c:1408
wined3d_view_vk_destroy_ctx::bo_user
struct wined3d_bo_user * bo_user
Definition: adapter_vk.c:1405
wined3d_view_vk
Definition: wined3d_vk.h:984
wined3d_view_vk::bo_user
struct wined3d_bo_user bo_user
Definition: wined3d_vk.h:985
wined3d_view_vk::vk_buffer_view
VkBufferView vk_buffer_view
Definition: wined3d_vk.h:988
wined3d_view_vk::vk_image_info
VkDescriptorImageInfo vk_image_info
Definition: wined3d_vk.h:989
wined3d_view_vk::u
union wined3d_view_vk::@365 u
wined3d_view_vk::command_buffer_id
uint64_t command_buffer_id
Definition: wined3d_vk.h:991
wined3d_vk_info
Definition: wined3d_vk.h:255
wined3d_vk_info::dynamic_blend_state
bool dynamic_blend_state
Definition: wined3d_vk.h:268
wined3d_vk_info::dynamic_state2
bool dynamic_state2
Definition: wined3d_vk.h:265
wined3d_vk_info::multiple_viewports
bool multiple_viewports
Definition: wined3d_vk.h:264
wined3d_vk_info::dynamic_patch_vertex_count
bool dynamic_patch_vertex_count
Definition: wined3d_vk.h:266
wined3d_vk_info::vk_ops
struct vulkan_ops vk_ops
Definition: wined3d_vk.h:256
wined3d_vk_info::api_version
unsigned int api_version
Definition: wined3d_vk.h:259
wined3d_vk_info::dynamic_multisample_state
bool dynamic_multisample_state
Definition: wined3d_vk.h:267
wined3d_vk_info::supported
BOOL supported[WINED3D_VK_EXT_COUNT]
Definition: wined3d_vk.h:261
wined3d_vk_info::dynamic_rasterizer_state
bool dynamic_rasterizer_state
Definition: wined3d_vk.h:269
wined3d_vk_info::vulkan_lib
HMODULE vulkan_lib
Definition: wined3d_vk.h:262
wined3d_vk_info::instance
VkInstance instance
Definition: wined3d_vk.h:258
max
#define max(a, b)
Definition: svc.c:63
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
vkGetPhysicalDeviceMemoryProperties
void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
VK_API_VERSION_1_0
#define VK_API_VERSION_1_0
Definition: vulkan.h:842
VK_API_VERSION_1_3
#define VK_API_VERSION_1_3
Definition: vulkan.h:845
vkEnumerateDeviceExtensionProperties
VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
VkMemoryPropertyFlags
VkFlags VkMemoryPropertyFlags
Definition: vulkan.h:1063
VkPipelineStageFlags
VkFlags VkPipelineStageFlags
Definition: vulkan.h:1101
vkDestroyDevice
void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
vkGetPhysicalDeviceFeatures2KHR
void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
VK_VERSION_MAJOR
#define VK_VERSION_MAJOR(version)
Definition: vulkan.h:832
vkCmdCopyBuffer
void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
@ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
Definition: vulkan.h:3771
VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME
#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME
Definition: vulkan.h:323
vkGetPhysicalDeviceQueueFamilyProperties
void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
vkGetPhysicalDeviceProperties2KHR
void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
VkAccessFlags
VkFlags VkAccessFlags
Definition: vulkan.h:957
VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME
#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME
Definition: vulkan.h:144
VK_API_VERSION_1_2
#define VK_API_VERSION_1_2
Definition: vulkan.h:844
vkDestroyImageView
void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
VK_VERSION_PATCH
#define VK_VERSION_PATCH(version)
Definition: vulkan.h:834
vkGetPhysicalDeviceFeatures
void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME
#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME
Definition: vulkan.h:84
VkDeviceSize
uint64_t VkDeviceSize
Definition: vulkan.h:948
PFN_vkEnumerateInstanceVersion
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceVersion)(uint32_t *)
Definition: vulkan.h:18063
vkCreateDevice
VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
VK_KHR_SURFACE_EXTENSION_NAME
#define VK_KHR_SURFACE_EXTENSION_NAME
Definition: vulkan.h:72
vkFreeMemory
void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
vkInvalidateMappedMemoryRanges
VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
vkCmdDrawIndirect
void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME
#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME
Definition: vulkan.h:167
vkDestroyBufferView
void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
VK_VERSION_MINOR
#define VK_VERSION_MINOR(version)
Definition: vulkan.h:833
vkCmdDrawIndexed
void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME
#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME
Definition: vulkan.h:425
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
@ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
Definition: vulkan.h:3748
vkGetInstanceProcAddr
PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName)
vkCmdDraw
void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME
#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME
Definition: vulkan.h:104
vkGetPhysicalDeviceFeatures2
void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
vkCmdDispatchIndirect
void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
VK_FALSE
#define VK_FALSE
Definition: vulkan.h:56
VK_MAKE_VERSION
#define VK_MAKE_VERSION(major, minor, patch)
Definition: vulkan.h:830
vkGetDeviceQueue
void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME
#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME
Definition: vulkan.h:247
VK_KHR_MAINTENANCE1_EXTENSION_NAME
#define VK_KHR_MAINTENANCE1_EXTENSION_NAME
Definition: vulkan.h:156
VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME
#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME
Definition: vulkan.h:555
vkGetPhysicalDeviceProperties2
void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
VK_WHOLE_SIZE
#define VK_WHOLE_SIZE
Definition: vulkan.h:53
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME
#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME
Definition: vulkan.h:138
VK_KHR_WIN32_SURFACE_EXTENSION_NAME
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME
Definition: vulkan.h:76
VkBufferUsageFlags
VkFlags VkBufferUsageFlags
Definition: vulkan.h:965
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
@ VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
Definition: vulkan.h:1918
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
@ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
Definition: vulkan.h:1917
VK_BUFFER_USAGE_TRANSFER_DST_BIT
@ VK_BUFFER_USAGE_TRANSFER_DST_BIT
Definition: vulkan.h:1916
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
@ VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
Definition: vulkan.h:1923
VK_BUFFER_USAGE_INDEX_BUFFER_BIT
@ VK_BUFFER_USAGE_INDEX_BUFFER_BIT
Definition: vulkan.h:1921
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT
@ VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT
Definition: vulkan.h:1926
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
@ VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
Definition: vulkan.h:1919
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT
@ VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT
Definition: vulkan.h:1927
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
@ VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
Definition: vulkan.h:1922
VK_BUFFER_USAGE_TRANSFER_SRC_BIT
@ VK_BUFFER_USAGE_TRANSFER_SRC_BIT
Definition: vulkan.h:1915
vkDestroyInstance
void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
vkCmdDispatch
void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
PFN_vkEnumerateInstanceExtensionProperties
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceExtensionProperties)(const char *, uint32_t *, VkExtensionProperties *)
Definition: vulkan.h:18061
VK_QUEUE_GRAPHICS_BIT
@ VK_QUEUE_GRAPHICS_BIT
Definition: vulkan.h:4531
vkMapMemory
VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
VkResult
VkResult
Definition: vulkan.h:4639
VK_ERROR_EXTENSION_NOT_PRESENT
@ VK_ERROR_EXTENSION_NOT_PRESENT
Definition: vulkan.h:4665
VK_ERROR_DEVICE_LOST
@ VK_ERROR_DEVICE_LOST
Definition: vulkan.h:4668
VK_SUCCESS
@ VK_SUCCESS
Definition: vulkan.h:4672
VK_ERROR_OUT_OF_HOST_MEMORY
@ VK_ERROR_OUT_OF_HOST_MEMORY
Definition: vulkan.h:4671
VK_ERROR_OUT_OF_DEVICE_MEMORY
@ VK_ERROR_OUT_OF_DEVICE_MEMORY
Definition: vulkan.h:4670
VK_ACCESS_HOST_READ_BIT
@ VK_ACCESS_HOST_READ_BIT
Definition: vulkan.h:1642
VK_ACCESS_TRANSFER_WRITE_BIT
@ VK_ACCESS_TRANSFER_WRITE_BIT
Definition: vulkan.h:1641
VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
@ VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
Definition: vulkan.h:1631
VK_ACCESS_INDIRECT_COMMAND_READ_BIT
@ VK_ACCESS_INDIRECT_COMMAND_READ_BIT
Definition: vulkan.h:1629
VK_ACCESS_TRANSFER_READ_BIT
@ VK_ACCESS_TRANSFER_READ_BIT
Definition: vulkan.h:1640
VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
@ VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
Definition: vulkan.h:1655
VK_ACCESS_SHADER_WRITE_BIT
@ VK_ACCESS_SHADER_WRITE_BIT
Definition: vulkan.h:1635
VK_ACCESS_SHADER_READ_BIT
@ VK_ACCESS_SHADER_READ_BIT
Definition: vulkan.h:1634
VK_ACCESS_UNIFORM_READ_BIT
@ VK_ACCESS_UNIFORM_READ_BIT
Definition: vulkan.h:1632
VK_ACCESS_INDEX_READ_BIT
@ VK_ACCESS_INDEX_READ_BIT
Definition: vulkan.h:1630
VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT
@ VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT
Definition: vulkan.h:1656
VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT
@ VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT
Definition: vulkan.h:1654
vkEnumeratePhysicalDevices
VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
vkFlushMappedMemoryRanges
VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME
#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME
Definition: vulkan.h:429
vkCmdEndTransformFeedbackEXT
void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
vkGetPhysicalDeviceProperties
void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME
#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME
Definition: vulkan.h:626
VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition: vulkan.h:861
vkCmdDrawIndexedIndirect
void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VK_KHR_SWAPCHAIN_EXTENSION_NAME
#define VK_KHR_SWAPCHAIN_EXTENSION_NAME
Definition: vulkan.h:74
VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
@ VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
Definition: vulkan.h:4278
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
@ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
Definition: vulkan.h:4274
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT
@ VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT
Definition: vulkan.h:4287
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
@ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
Definition: vulkan.h:4283
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
@ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
Definition: vulkan.h:4279
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
@ VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
Definition: vulkan.h:4277
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
@ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
Definition: vulkan.h:4288
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
@ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
Definition: vulkan.h:4273
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
@ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
Definition: vulkan.h:4275
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
@ VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
Definition: vulkan.h:4276
VK_PIPELINE_STAGE_HOST_BIT
@ VK_PIPELINE_STAGE_HOST_BIT
Definition: vulkan.h:4286
VK_PIPELINE_STAGE_TRANSFER_BIT
@ VK_PIPELINE_STAGE_TRANSFER_BIT
Definition: vulkan.h:4284
VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT
@ VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT
Definition: vulkan.h:4296
vkCmdPipelineBarrier
void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
vkCmdBeginTransformFeedbackEXT
void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
vkUnmapMemory
void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
VK_API_VERSION_1_1
#define VK_API_VERSION_1_1
Definition: vulkan.h:843
vkCreateInstance
VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
VK_KHR_MAINTENANCE2_EXTENSION_NAME
#define VK_KHR_MAINTENANCE2_EXTENSION_NAME
Definition: vulkan.h:221
VK_QUEUE_FAMILY_IGNORED
#define VK_QUEUE_FAMILY_IGNORED
Definition: vulkan.h:57
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT
Definition: vulkan.h:5939
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT
Definition: vulkan.h:5399
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES
Definition: vulkan.h:5397
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
Definition: vulkan.h:5109
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT
Definition: vulkan.h:5052
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
@ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
Definition: vulkan.h:4966
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT
Definition: vulkan.h:5651
VK_STRUCTURE_TYPE_APPLICATION_INFO
@ VK_STRUCTURE_TYPE_APPLICATION_INFO
Definition: vulkan.h:4964
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT
Definition: vulkan.h:5578
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
@ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
Definition: vulkan.h:4965
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2
Definition: vulkan.h:5108
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
@ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
Definition: vulkan.h:4967
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES
Definition: vulkan.h:5144
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES
Definition: vulkan.h:5131
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
@ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
Definition: vulkan.h:5008
VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
@ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
Definition: vulkan.h:4970
success
#define success(from, fromstr, to, tostr)
Definition: win_iconv_test.c:158
wined3d_get_gpu_description
const struct wined3d_gpu_description * wined3d_get_gpu_description(enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
Definition: directx.c:688
wined3d_adapter_cleanup
void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
Definition: directx.c:176
adapter_adjust_mapped_memory
ssize_t adapter_adjust_mapped_memory(struct wined3d_adapter *adapter, ssize_t size)
Definition: directx.c:167
wined3d_adapter_init
BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, unsigned int ordinal, const LUID *luid, const struct wined3d_adapter_ops *adapter_ops)
Definition: directx.c:3383
wined3d_driver_info_init
bool wined3d_driver_info_init(struct wined3d_driver_info *driver_info, const struct wined3d_gpu_description *gpu_desc, enum wined3d_feature_level feature_level, UINT64 vram_bytes, UINT64 sysmem_bytes)
Definition: directx.c:740
wined3d_get_user_override_gpu_description
const struct wined3d_gpu_description * wined3d_get_user_override_gpu_description(enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
Definition: directx.c:702
wined3d_swapchain_vk_init
HRESULT wined3d_swapchain_vk_init(struct wined3d_swapchain_vk *swapchain_vk, struct wined3d_device *device, const struct wined3d_swapchain_desc *desc, struct wined3d_swapchain_state_parent *state_parent, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: swapchain.c:1707
wined3d_swapchain_vk_cleanup
void wined3d_swapchain_vk_cleanup(struct wined3d_swapchain_vk *swapchain_vk)
Definition: swapchain.c:125
WINED3DPTEXTURECAPS_MIPCUBEMAP
#define WINED3DPTEXTURECAPS_MIPCUBEMAP
Definition: wined3d.h:1262
WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT
#define WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT
Definition: wined3d.h:1120
WINED3DPRASTERCAPS_ANISOTROPY
#define WINED3DPRASTERCAPS_ANISOTROPY
Definition: wined3d.h:1214
WINED3DPTADDRESSCAPS_WRAP
#define WINED3DPTADDRESSCAPS_WRAP
Definition: wined3d.h:1137
wined3d_log2i
static unsigned int wined3d_log2i(unsigned int x)
Definition: wined3d.h:2952
WINEDDSCAPS_NONLOCALVIDMEM
#define WINEDDSCAPS_NONLOCALVIDMEM
Definition: wined3d.h:1447
WINED3DPS20_MAX_NUMTEMPS
#define WINED3DPS20_MAX_NUMTEMPS
Definition: wined3d.h:1124
WINED3D_RS_DITHERENABLE
@ WINED3D_RS_DITHERENABLE
Definition: wined3d.h:309
WINED3D_RS_MULTISAMPLEANTIALIAS
@ WINED3D_RS_MULTISAMPLEANTIALIAS
Definition: wined3d.h:369
WINED3D_RS_LINEPATTERN
@ WINED3D_RS_LINEPATTERN
Definition: wined3d.h:296
WINEDDSCAPS_OWNDC
#define WINEDDSCAPS_OWNDC
Definition: wined3d.h:1438
WINED3DSTENCILCAPS_DECR
#define WINED3DSTENCILCAPS_DECR
Definition: wined3d.h:1151
WINED3D_OK
#define WINED3D_OK
Definition: wined3d.h:33
WINED3DVS20_MAX_NUMTEMPS
#define WINED3DVS20_MAX_NUMTEMPS
Definition: wined3d.h:1183
WINED3DPTFILTERCAPS_LINEARMIPNEAREST
#define WINED3DPTFILTERCAPS_LINEARMIPNEAREST
Definition: wined3d.h:1271
WINEDDSCAPS_VIDEOMEMORY
#define WINEDDSCAPS_VIDEOMEMORY
Definition: wined3d.h:1434
WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
#define WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
Definition: wined3d.h:1113
WINED3DPTFILTERCAPS_MAGFLINEAR
#define WINED3DPTFILTERCAPS_MAGFLINEAR
Definition: wined3d.h:1279
WINED3DPTEXTURECAPS_CUBEMAP_POW2
#define WINED3DPTEXTURECAPS_CUBEMAP_POW2
Definition: wined3d.h:1263
WINED3DPTADDRESSCAPS_INDEPENDENTUV
#define WINED3DPTADDRESSCAPS_INDEPENDENTUV
Definition: wined3d.h:1141
WINED3DPTFILTERCAPS_MIPNEAREST
#define WINED3DPTFILTERCAPS_MIPNEAREST
Definition: wined3d.h:1269
WINED3DPTEXTURECAPS_MIPVOLUMEMAP
#define WINED3DPTEXTURECAPS_MIPVOLUMEMAP
Definition: wined3d.h:1261
WINED3DPTADDRESSCAPS_CLAMP
#define WINED3DPTADDRESSCAPS_CLAMP
Definition: wined3d.h:1139
WINED3D_RTYPE_BUFFER
@ WINED3D_RTYPE_BUFFER
Definition: wined3d.h:718
WINED3DPBLENDCAPS_SRCALPHASAT
#define WINED3DPBLENDCAPS_SRCALPHASAT
Definition: wined3d.h:1088
WINED3DCAPS2_CANGENMIPMAP
#define WINED3DCAPS2_CANGENMIPMAP
Definition: wined3d.h:1197
WINED3DPRASTERCAPS_MIPMAPLODBIAS
#define WINED3DPRASTERCAPS_MIPMAPLODBIAS
Definition: wined3d.h:1211
WINED3D_MAX_RENDER_TARGETS
#define WINED3D_MAX_RENDER_TARGETS
Definition: wined3d.h:1606
WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
#define WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
Definition: wined3d.h:1117
WINED3DPTFILTERCAPS_MINFANISOTROPIC
#define WINED3DPTFILTERCAPS_MINFANISOTROPIC
Definition: wined3d.h:1275
WINED3DPTEXTURECAPS_VOLUMEMAP
#define WINED3DPTEXTURECAPS_VOLUMEMAP
Definition: wined3d.h:1259
WINED3DPTFILTERCAPS_MIPFLINEAR
#define WINED3DPTFILTERCAPS_MIPFLINEAR
Definition: wined3d.h:1277
WINED3DPMISCCAPS_SEPARATEALPHABLEND
#define WINED3DPMISCCAPS_SEPARATEALPHABLEND
Definition: wined3d.h:1116
WINEDDCAPS_3D
#define WINEDDCAPS_3D
Definition: wined3d.h:1500
wined3d_query_type
wined3d_query_type
Definition: wined3d.h:725
WINED3D_MAP_READ
#define WINED3D_MAP_READ
Definition: wined3d.h:957
WINEDDSCAPS_LOCALVIDMEM
#define WINEDDSCAPS_LOCALVIDMEM
Definition: wined3d.h:1446
WINED3DDTCAPS_FLOAT16_2
#define WINED3DDTCAPS_FLOAT16_2
Definition: wined3d.h:1061
WINED3DPTADDRESSCAPS_MIRRORONCE
#define WINED3DPTADDRESSCAPS_MIRRORONCE
Definition: wined3d.h:1142
WINED3DPTFILTERCAPS_LINEARMIPLINEAR
#define WINED3DPTFILTERCAPS_LINEARMIPLINEAR
Definition: wined3d.h:1272
WINED3DPTADDRESSCAPS_BORDER
#define WINED3DPTADDRESSCAPS_BORDER
Definition: wined3d.h:1140
WINED3DDTCAPS_FLOAT16_4
#define WINED3DDTCAPS_FLOAT16_4
Definition: wined3d.h:1062
WINED3DPTADDRESSCAPS_MIRROR
#define WINED3DPTADDRESSCAPS_MIRROR
Definition: wined3d.h:1138
WINED3DPTFILTERCAPS_NEAREST
#define WINED3DPTFILTERCAPS_NEAREST
Definition: wined3d.h:1267
WINED3DPTFILTERCAPS_MAGFPOINT
#define WINED3DPTFILTERCAPS_MAGFPOINT
Definition: wined3d.h:1278
WINED3D_MAP_DISCARD
#define WINED3D_MAP_DISCARD
Definition: wined3d.h:953
WINED3D_MAP_WRITE
#define WINED3D_MAP_WRITE
Definition: wined3d.h:956
WINED3DPTFILTERCAPS_LINEAR
#define WINED3DPTFILTERCAPS_LINEAR
Definition: wined3d.h:1268
WINED3DPTFILTERCAPS_MAGFANISOTROPIC
#define WINED3DPTFILTERCAPS_MAGFANISOTROPIC
Definition: wined3d.h:1280
WINEDDSCAPS_FRONTBUFFER
#define WINEDDSCAPS_FRONTBUFFER
Definition: wined3d.h:1425
WINEDDSCAPS_COMPLEX
#define WINEDDSCAPS_COMPLEX
Definition: wined3d.h:1423
wined3d_feature_level
wined3d_feature_level
Definition: wined3d.h:98
WINED3D_FEATURE_LEVEL_11
@ WINED3D_FEATURE_LEVEL_11
Definition: wined3d.h:109
WINED3D_FEATURE_LEVEL_10_1
@ WINED3D_FEATURE_LEVEL_10_1
Definition: wined3d.h:108
WINED3D_FEATURE_LEVEL_8
@ WINED3D_FEATURE_LEVEL_8
Definition: wined3d.h:103
WINED3D_FEATURE_LEVEL_7
@ WINED3D_FEATURE_LEVEL_7
Definition: wined3d.h:102
WINED3D_FEATURE_LEVEL_9_3
@ WINED3D_FEATURE_LEVEL_9_3
Definition: wined3d.h:106
WINED3D_FEATURE_LEVEL_10
@ WINED3D_FEATURE_LEVEL_10
Definition: wined3d.h:107
WINED3D_FEATURE_LEVEL_11_1
@ WINED3D_FEATURE_LEVEL_11_1
Definition: wined3d.h:110
WINED3D_FEATURE_LEVEL_9_1
@ WINED3D_FEATURE_LEVEL_9_1
Definition: wined3d.h:104
WINED3D_FEATURE_LEVEL_9_2
@ WINED3D_FEATURE_LEVEL_9_2
Definition: wined3d.h:105
WINED3D_MAX_CLIP_DISTANCES
#define WINED3D_MAX_CLIP_DISTANCES
Definition: wined3d.h:1601
WINED3D_SHADER_TYPE_HULL
@ WINED3D_SHADER_TYPE_HULL
Definition: wined3d.h:844
WINED3D_SHADER_TYPE_PIXEL
@ WINED3D_SHADER_TYPE_PIXEL
Definition: wined3d.h:841
WINED3D_SHADER_TYPE_GEOMETRY
@ WINED3D_SHADER_TYPE_GEOMETRY
Definition: wined3d.h:843
WINED3D_SHADER_TYPE_DOMAIN
@ WINED3D_SHADER_TYPE_DOMAIN
Definition: wined3d.h:845
WINED3D_SHADER_TYPE_COMPUTE
@ WINED3D_SHADER_TYPE_COMPUTE
Definition: wined3d.h:848
WINED3D_SHADER_TYPE_VERTEX
@ WINED3D_SHADER_TYPE_VERTEX
Definition: wined3d.h:842
WINED3DPMISCCAPS_BLENDOP
#define WINED3DPMISCCAPS_BLENDOP
Definition: wined3d.h:1111
WINED3DPTFILTERCAPS_MIPLINEAR
#define WINED3DPTFILTERCAPS_MIPLINEAR
Definition: wined3d.h:1270
WINED3D_MAP_NOOVERWRITE
#define WINED3D_MAP_NOOVERWRITE
Definition: wined3d.h:952
WINED3DPTFILTERCAPS_MINFPOINT
#define WINED3DPTFILTERCAPS_MINFPOINT
Definition: wined3d.h:1273
WINED3DPTEXTURECAPS_VOLUMEMAP_POW2
#define WINED3DPTEXTURECAPS_VOLUMEMAP_POW2
Definition: wined3d.h:1264
WINED3DPBLENDCAPS_BLENDFACTOR
#define WINED3DPBLENDCAPS_BLENDFACTOR
Definition: wined3d.h:1091
WINED3DSTENCILCAPS_INCR
#define WINED3DSTENCILCAPS_INCR
Definition: wined3d.h:1150
WINED3DPTEXTURECAPS_CUBEMAP
#define WINED3DPTEXTURECAPS_CUBEMAP
Definition: wined3d.h:1257
WINED3DPTFILTERCAPS_MIPFPOINT
#define WINED3DPTFILTERCAPS_MIPFPOINT
Definition: wined3d.h:1276
wined3d_device_type
wined3d_device_type
Definition: wined3d.h:90
WINED3DMAX30SHADERINSTRUCTIONS
#define WINED3DMAX30SHADERINSTRUCTIONS
Definition: wined3d.h:1075
WINED3DPTFILTERCAPS_MINFLINEAR
#define WINED3DPTFILTERCAPS_MINFLINEAR
Definition: wined3d.h:1274
WINEDDSCAPS_3DDEVICE
#define WINEDDSCAPS_3DDEVICE
Definition: wined3d.h:1433
WINEDDSCAPS_BACKBUFFER
#define WINEDDSCAPS_BACKBUFFER
Definition: wined3d.h:1422
WINED3DSTENCILCAPS_TWOSIDED
#define WINED3DSTENCILCAPS_TWOSIDED
Definition: wined3d.h:1152
wined3d_get_app_name
BOOL wined3d_get_app_name(char *app_name, unsigned int app_name_size)
Definition: wined3d_main.c:241
wined3d_private.h
STATE_BASEVERTEXINDEX
#define STATE_BASEVERTEXINDEX
Definition: wined3d_private.h:1762
STATE_DEPTH_STENCIL
#define STATE_DEPTH_STENCIL
Definition: wined3d_private.h:1780
STATE_STENCIL_REF
#define STATE_STENCIL_REF
Definition: wined3d_private.h:1783
STATE_CONSTANT_BUFFER
#define STATE_CONSTANT_BUFFER(a)
Definition: wined3d_private.h:1807
wined3d_texture_allocate_object_memory
static void * wined3d_texture_allocate_object_memory(SIZE_T s, SIZE_T level_count, SIZE_T layer_count)
Definition: wined3d_private.h:3459
STATE_GRAPHICS_SHADER_RESOURCE_BINDING
#define STATE_GRAPHICS_SHADER_RESOURCE_BINDING
Definition: wined3d_private.h:1733
wined3d_device_bo_map_lock
static void wined3d_device_bo_map_lock(struct wined3d_device *device)
Definition: wined3d_private.h:3100
WINED3D_SHADER_CAP_DOUBLE_PRECISION
#define WINED3D_SHADER_CAP_DOUBLE_PRECISION
Definition: wined3d_private.h:1406
wined3d_cs_finish
static void wined3d_cs_finish(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
Definition: wined3d_private.h:3714
STATE_STREAM_OUTPUT
#define STATE_STREAM_OUTPUT
Definition: wined3d_private.h:1768
wined3d_pci_vendor
wined3d_pci_vendor
Definition: wined3d_private.h:2097
wined3d_device_bo_map_unlock
static void wined3d_device_bo_map_unlock(struct wined3d_device *device)
Definition: wined3d_private.h:3105
wined3d_not_from_cs
static void wined3d_not_from_cs(const struct wined3d_cs *cs)
Definition: wined3d_private.h:4721
WINED3D_SHADER_CAP_OUTPUT_INTERPOLATION
#define WINED3D_SHADER_CAP_OUTPUT_INTERPOLATION
Definition: wined3d_private.h:1407
STATE_DEPTH_BOUNDS
#define STATE_DEPTH_BOUNDS
Definition: wined3d_private.h:1759
MAX_PERSISTENT_MAPPED_BYTES
#define MAX_PERSISTENT_MAPPED_BYTES
Definition: wined3d_private.h:2597
STATE_SHADER
#define STATE_SHADER(a)
Definition: wined3d_private.h:1806
context_release
static void context_release(struct wined3d_context *context)
Definition: wined3d_private.h:4790
STATE_BLEND_FACTOR
#define STATE_BLEND_FACTOR
Definition: wined3d_private.h:1774
WINED3D_SHADER_CAP_FULL_FFP_VARYINGS
#define WINED3D_SHADER_CAP_FULL_FFP_VARYINGS
Definition: wined3d_private.h:1408
WINED3D_ALLOCATOR_CHUNK_SIZE
#define WINED3D_ALLOCATOR_CHUNK_SIZE
Definition: wined3d_private.h:3122
STATE_SAMPLE_MASK
#define STATE_SAMPLE_MASK
Definition: wined3d_private.h:1777
STATE_SCISSORRECT
#define STATE_SCISSORRECT
Definition: wined3d_private.h:1750
STATE_STREAMSRC
#define STATE_STREAMSRC
Definition: wined3d_private.h:1739
STATE_COMPUTE_SHADER_RESOURCE_BINDING
#define STATE_COMPUTE_SHADER_RESOURCE_BINDING
Definition: wined3d_private.h:1794
wined3d_lock_init
#define wined3d_lock_init(lock, name)
Definition: wined3d_private.h:4153
WINED3D_LOCATION_TEXTURE_RGB
#define WINED3D_LOCATION_TEXTURE_RGB
Definition: wined3d_private.h:3331
wined3d_display_driver
wined3d_display_driver
Definition: wined3d_private.h:2438
DRIVER_INTEL_HD4000
@ DRIVER_INTEL_HD4000
Definition: wined3d_private.h:2448
DRIVER_NVIDIA_GEFORCE8
@ DRIVER_NVIDIA_GEFORCE8
Definition: wined3d_private.h:2453
DRIVER_WINE
@ DRIVER_WINE
Definition: wined3d_private.h:2458
DRIVER_AMD_RX
@ DRIVER_AMD_RX
Definition: wined3d_private.h:2443
STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING
#define STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING
Definition: wined3d_private.h:1797
STATE_RASTERIZER
#define STATE_RASTERIZER
Definition: wined3d_private.h:1756
wined3d_from_cs
static void wined3d_from_cs(const struct wined3d_cs *cs)
Definition: wined3d_private.h:4715
wined3d_lock_cleanup
static void wined3d_lock_cleanup(CRITICAL_SECTION *lock)
Definition: wined3d_private.h:4161
STATE_INDEXBUFFER
#define STATE_INDEXBUFFER
Definition: wined3d_private.h:1741
STATE_VDECL
#define STATE_VDECL
Definition: wined3d_private.h:1744
STATE_VIEWPORT
#define STATE_VIEWPORT
Definition: wined3d_private.h:1747
context_acquire
static struct wined3d_context * context_acquire(struct wined3d_device *device, struct wined3d_texture *texture, unsigned int sub_resource_idx)
Definition: wined3d_private.h:4782
WINED3D_CS_QUEUE_DEFAULT
@ WINED3D_CS_QUEUE_DEFAULT
Definition: wined3d_private.h:3605
STATE_FRAMEBUFFER
#define STATE_FRAMEBUFFER
Definition: wined3d_private.h:1765
STATE_RENDER
#define STATE_RENDER(a)
Definition: wined3d_private.h:1716
STATE_BLEND
#define STATE_BLEND
Definition: wined3d_private.h:1771
STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING
#define STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING
Definition: wined3d_private.h:1736
texture_from_resource
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
Definition: wined3d_private.h:3469
wined3d_vk.h
wined3d_device_vk_allocator_unlock
static void wined3d_device_vk_allocator_unlock(struct wined3d_device_vk *device_vk)
Definition: wined3d_vk.h:856
VK_CALL
#define VK_CALL(f)
Definition: wined3d_vk.h:272
wined3d_device_vk_allocator_lock
static void wined3d_device_vk_allocator_lock(struct wined3d_device_vk *device_vk)
Definition: wined3d_vk.h:851
VK_DEVICE_FUNCS
#define VK_DEVICE_FUNCS()
Definition: wined3d_vk.h:61
wined3d_vk_extension
wined3d_vk_extension
Definition: wined3d_vk.h:237
WINED3D_VK_KHR_SHADER_DRAW_PARAMETERS
@ WINED3D_VK_KHR_SHADER_DRAW_PARAMETERS
Definition: wined3d_vk.h:249
WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE
@ WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE
Definition: wined3d_vk.h:240
WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE2
@ WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE2
Definition: wined3d_vk.h:241
WINED3D_VK_EXT_SHADER_STENCIL_EXPORT
@ WINED3D_VK_EXT_SHADER_STENCIL_EXPORT
Definition: wined3d_vk.h:244
WINED3D_VK_KHR_MAINTENANCE2
@ WINED3D_VK_KHR_MAINTENANCE2
Definition: wined3d_vk.h:247
WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE
@ WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE
Definition: wined3d_vk.h:248
WINED3D_VK_EXT_VERTEX_ATTRIBUTE_DIVISOR
@ WINED3D_VK_EXT_VERTEX_ATTRIBUTE_DIVISOR
Definition: wined3d_vk.h:246
WINED3D_VK_EXT_HOST_QUERY_RESET
@ WINED3D_VK_EXT_HOST_QUERY_RESET
Definition: wined3d_vk.h:243
WINED3D_VK_EXT_TRANSFORM_FEEDBACK
@ WINED3D_VK_EXT_TRANSFORM_FEEDBACK
Definition: wined3d_vk.h:245
WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE3
@ WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE3
Definition: wined3d_vk.h:242
WINED3D_VK_EXT_NONE
@ WINED3D_VK_EXT_NONE
Definition: wined3d_vk.h:238
wined3d_device_vk_from_allocator
static struct wined3d_device_vk * wined3d_device_vk_from_allocator(struct wined3d_allocator *allocator)
Definition: wined3d_vk.h:846
wined3d_context_vk_reference_bo
static void wined3d_context_vk_reference_bo(const struct wined3d_context_vk *context_vk, struct wined3d_bo_vk *bo)
Definition: wined3d_vk.h:1091
VK_INSTANCE_FUNCS
#define VK_INSTANCE_FUNCS()
Definition: wined3d_vk.h:33
BYTE
unsigned char BYTE
Definition: xxhash.c:193