?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mscoree/tests: Test querying interfaces with generated GUID.
[wine.git] / dlls / wined3d / adapter_vk.c
blob3fb9e4ce4b410a2dce7df31dc993f595b6e98f0e
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 "config.h"
20 #include "wine/port.h"
21 #include "wined3d_private.h"
22
23 #include "wine/vulkan_driver.h"
24
25 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
26
27 static const struct wined3d_state_entry_template misc_state_template_vk[] =
28 {
29 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX), state_nop}},
30 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL), state_nop}},
31 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN), state_nop}},
32 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY), state_nop}},
33 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL), state_nop}},
34 {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE), {STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE), state_nop}},
35 {STATE_GRAPHICS_SHADER_RESOURCE_BINDING, {STATE_GRAPHICS_SHADER_RESOURCE_BINDING, state_nop}},
36 {STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING, {STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING, state_nop}},
37 {STATE_COMPUTE_SHADER_RESOURCE_BINDING, {STATE_COMPUTE_SHADER_RESOURCE_BINDING, state_nop}},
38 {STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING, {STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING, state_nop}},
39 {STATE_STREAM_OUTPUT, {STATE_STREAM_OUTPUT, state_nop}},
40 {STATE_BLEND, {STATE_BLEND, state_nop}},
41 {STATE_BLEND_FACTOR, {STATE_BLEND_FACTOR, state_nop}},
42 {STATE_SAMPLE_MASK, {STATE_SAMPLE_MASK, state_nop}},
43 {STATE_STREAMSRC, {STATE_STREAMSRC, state_nop}},
44 {STATE_VDECL, {STATE_VDECL, state_nop}},
45 {STATE_DEPTH_STENCIL, {STATE_DEPTH_STENCIL, state_nop}},
46 {STATE_RASTERIZER, {STATE_RASTERIZER, state_nop}},
47 {STATE_SCISSORRECT, {STATE_SCISSORRECT, state_nop}},
48 {STATE_POINTSPRITECOORDORIGIN, {STATE_POINTSPRITECOORDORIGIN, state_nop}},
49
50 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
51 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00)}},
52 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00)}},
53 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00)}},
54 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
55 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00)}},
56 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00)}},
57 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00)}},
58 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
59 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00)}},
60 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00)}},
61 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00)}},
62 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
63 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00)}},
64 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00)}},
65 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00)}},
66 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
67 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00)}},
68 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00)}},
69 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00)}},
70 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
71 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00)}},
72 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00)}},
73 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00)}},
74 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
75 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00)}},
76 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00)}},
77 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00)}},
78 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), state_nop}},
79 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01), {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00)}},
80 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10), {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00)}},
81 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11), {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00)}},
82 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
83 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE)}},
84 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
85 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE)}},
86 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
87 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE)}},
88 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
89 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE)}},
90 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
91 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE)}},
92 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
93 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE)}},
94 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
95 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE)}},
96 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE), {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE), state_nop}},
97 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LOFFSET), {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE)}},
98
99 {STATE_VIEWPORT, {STATE_VIEWPORT, state_nop}},
100 {STATE_INDEXBUFFER, {STATE_INDEXBUFFER, state_nop}},
101 {STATE_RENDER(WINED3D_RS_ANTIALIAS), {STATE_RENDER(WINED3D_RS_ANTIALIAS), state_nop}},
102 {STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), {STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), state_nop}},
103 {STATE_RENDER(WINED3D_RS_WRAPU), {STATE_RENDER(WINED3D_RS_WRAPU), state_nop}},
104 {STATE_RENDER(WINED3D_RS_WRAPV), {STATE_RENDER(WINED3D_RS_WRAPV), state_nop}},
105 {STATE_RENDER(WINED3D_RS_LINEPATTERN), {STATE_RENDER(WINED3D_RS_LINEPATTERN), state_nop}},
106 {STATE_RENDER(WINED3D_RS_MONOENABLE), {STATE_RENDER(WINED3D_RS_MONOENABLE), state_nop}},
107 {STATE_RENDER(WINED3D_RS_ROP2), {STATE_RENDER(WINED3D_RS_ROP2), state_nop}},
108 {STATE_RENDER(WINED3D_RS_PLANEMASK), {STATE_RENDER(WINED3D_RS_PLANEMASK), state_nop}},
109 {STATE_RENDER(WINED3D_RS_LASTPIXEL), {STATE_RENDER(WINED3D_RS_LASTPIXEL), state_nop}},
110 {STATE_RENDER(WINED3D_RS_DITHERENABLE), {STATE_RENDER(WINED3D_RS_DITHERENABLE), state_nop}},
111 {STATE_RENDER(WINED3D_RS_SUBPIXEL), {STATE_RENDER(WINED3D_RS_SUBPIXEL), state_nop}},
112 {STATE_RENDER(WINED3D_RS_SUBPIXELX), {STATE_RENDER(WINED3D_RS_SUBPIXELX), state_nop}},
113 {STATE_RENDER(WINED3D_RS_STIPPLEDALPHA), {STATE_RENDER(WINED3D_RS_STIPPLEDALPHA), state_nop}},
114 {STATE_RENDER(WINED3D_RS_STIPPLEENABLE), {STATE_RENDER(WINED3D_RS_STIPPLEENABLE), state_nop}},
115 {STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS), {STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS), state_nop}},
116 {STATE_RENDER(WINED3D_RS_ANISOTROPY), {STATE_RENDER(WINED3D_RS_ANISOTROPY), state_nop}},
117 {STATE_RENDER(WINED3D_RS_FLUSHBATCH), {STATE_RENDER(WINED3D_RS_FLUSHBATCH), state_nop}},
118 {STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT), {STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT), state_nop}},
119 {STATE_RENDER(WINED3D_RS_STENCILREF), {STATE_RENDER(WINED3D_RS_STENCILREF), state_nop}},
120 {STATE_RENDER(WINED3D_RS_WRAP0), {STATE_RENDER(WINED3D_RS_WRAP0), state_nop}},
121 {STATE_RENDER(WINED3D_RS_WRAP1), {STATE_RENDER(WINED3D_RS_WRAP0)}},
122 {STATE_RENDER(WINED3D_RS_WRAP2), {STATE_RENDER(WINED3D_RS_WRAP0)}},
123 {STATE_RENDER(WINED3D_RS_WRAP3), {STATE_RENDER(WINED3D_RS_WRAP0)}},
124 {STATE_RENDER(WINED3D_RS_WRAP4), {STATE_RENDER(WINED3D_RS_WRAP0)}},
125 {STATE_RENDER(WINED3D_RS_WRAP5), {STATE_RENDER(WINED3D_RS_WRAP0)}},
126 {STATE_RENDER(WINED3D_RS_WRAP6), {STATE_RENDER(WINED3D_RS_WRAP0)}},
127 {STATE_RENDER(WINED3D_RS_WRAP7), {STATE_RENDER(WINED3D_RS_WRAP0)}},
128 {STATE_RENDER(WINED3D_RS_WRAP8), {STATE_RENDER(WINED3D_RS_WRAP0)}},
129 {STATE_RENDER(WINED3D_RS_WRAP9), {STATE_RENDER(WINED3D_RS_WRAP0)}},
130 {STATE_RENDER(WINED3D_RS_WRAP10), {STATE_RENDER(WINED3D_RS_WRAP0)}},
131 {STATE_RENDER(WINED3D_RS_WRAP11), {STATE_RENDER(WINED3D_RS_WRAP0)}},
132 {STATE_RENDER(WINED3D_RS_WRAP12), {STATE_RENDER(WINED3D_RS_WRAP0)}},
133 {STATE_RENDER(WINED3D_RS_WRAP13), {STATE_RENDER(WINED3D_RS_WRAP0)}},
134 {STATE_RENDER(WINED3D_RS_WRAP14), {STATE_RENDER(WINED3D_RS_WRAP0)}},
135 {STATE_RENDER(WINED3D_RS_WRAP15), {STATE_RENDER(WINED3D_RS_WRAP0)}},
136 {STATE_RENDER(WINED3D_RS_EXTENTS), {STATE_RENDER(WINED3D_RS_EXTENTS), state_nop}},
137 {STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE), {STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE), state_nop}},
138 {STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING), {STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING), state_nop}},
139 {STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE), {STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE), state_nop}},
140 {STATE_RENDER(WINED3D_RS_PATCHSEGMENTS), {STATE_RENDER(WINED3D_RS_PATCHSEGMENTS), state_nop}},
141 {STATE_RENDER(WINED3D_RS_POSITIONDEGREE), {STATE_RENDER(WINED3D_RS_POSITIONDEGREE), state_nop}},
142 {STATE_RENDER(WINED3D_RS_NORMALDEGREE), {STATE_RENDER(WINED3D_RS_NORMALDEGREE), state_nop}},
143 {STATE_RENDER(WINED3D_RS_MINTESSELLATIONLEVEL), {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION)}},
144 {STATE_RENDER(WINED3D_RS_MAXTESSELLATIONLEVEL), {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION)}},
145 {STATE_RENDER(WINED3D_RS_ADAPTIVETESS_X), {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION)}},
146 {STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Y), {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION)}},
147 {STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Z), {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION)}},
148 {STATE_RENDER(WINED3D_RS_ADAPTIVETESS_W), {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION)}},
149 {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION), {STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION), state_nop}},
150 {STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), {STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), state_nop}},
151 {STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN), {STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN), state_nop}},
152 {STATE_RENDER(WINED3D_RS_ZVISIBLE), {STATE_RENDER(WINED3D_RS_ZVISIBLE), state_nop}},
153 /* Samplers */
154 {STATE_SAMPLER(0), {STATE_SAMPLER(0), state_nop}},
155 {STATE_SAMPLER(1), {STATE_SAMPLER(1), state_nop}},
156 {STATE_SAMPLER(2), {STATE_SAMPLER(2), state_nop}},
157 {STATE_SAMPLER(3), {STATE_SAMPLER(3), state_nop}},
158 {STATE_SAMPLER(4), {STATE_SAMPLER(4), state_nop}},
159 {STATE_SAMPLER(5), {STATE_SAMPLER(5), state_nop}},
160 {STATE_SAMPLER(6), {STATE_SAMPLER(6), state_nop}},
161 {STATE_SAMPLER(7), {STATE_SAMPLER(7), state_nop}},
162 {STATE_SAMPLER(8), {STATE_SAMPLER(8), state_nop}},
163 {STATE_SAMPLER(9), {STATE_SAMPLER(9), state_nop}},
164 {STATE_SAMPLER(10), {STATE_SAMPLER(10), state_nop}},
165 {STATE_SAMPLER(11), {STATE_SAMPLER(11), state_nop}},
166 {STATE_SAMPLER(12), {STATE_SAMPLER(12), state_nop}},
167 {STATE_SAMPLER(13), {STATE_SAMPLER(13), state_nop}},
168 {STATE_SAMPLER(14), {STATE_SAMPLER(14), state_nop}},
169 {STATE_SAMPLER(15), {STATE_SAMPLER(15), state_nop}},
170 {STATE_SAMPLER(16), /* Vertex sampler 0 */ {STATE_SAMPLER(16), state_nop}},
171 {STATE_SAMPLER(17), /* Vertex sampler 1 */ {STATE_SAMPLER(17), state_nop}},
172 {STATE_SAMPLER(18), /* Vertex sampler 2 */ {STATE_SAMPLER(18), state_nop}},
173 {STATE_SAMPLER(19), /* Vertex sampler 3 */ {STATE_SAMPLER(19), state_nop}},
174 {STATE_BASEVERTEXINDEX, {STATE_STREAMSRC}},
175 {STATE_FRAMEBUFFER, {STATE_FRAMEBUFFER, state_nop}},
176 {STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL), {STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL), state_nop}},
177 {STATE_SHADER(WINED3D_SHADER_TYPE_HULL), {STATE_SHADER(WINED3D_SHADER_TYPE_HULL), state_nop}},
178 {STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN), {STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN), state_nop}},
179 {STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY), {STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY), state_nop}},
180 {STATE_SHADER(WINED3D_SHADER_TYPE_COMPUTE), {STATE_SHADER(WINED3D_SHADER_TYPE_COMPUTE), state_nop}},
181 {0}, /* Terminate */
182 };
183
184 static inline const struct wined3d_adapter_vk *wined3d_adapter_vk_const(const struct wined3d_adapter *adapter)
185 {
186 return CONTAINING_RECORD(adapter, struct wined3d_adapter_vk, a);
187 }
188
189 static const char *debug_vk_version(uint32_t version)
190 {
191 return wine_dbg_sprintf("%u.%u.%u",
192 VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version), VK_VERSION_PATCH(version));
193 }
194
195 static HRESULT hresult_from_vk_result(VkResult vr)
196 {
197 switch (vr)
198 {
199 case VK_SUCCESS:
200 return S_OK;
201 case VK_ERROR_OUT_OF_HOST_MEMORY:
202 WARN("Out of host memory.\n");
203 return E_OUTOFMEMORY;
204 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
205 WARN("Out of device memory.\n");
206 return E_OUTOFMEMORY;
207 case VK_ERROR_DEVICE_LOST:
208 WARN("Device lost.\n");
209 return E_FAIL;
210 case VK_ERROR_EXTENSION_NOT_PRESENT:
211 WARN("Extension not present.\n");
212 return E_FAIL;
213 default:
214 FIXME("Unhandled VkResult %d.\n", vr);
215 return E_FAIL;
216 }
217 }
218
219 #ifdef USE_WIN32_VULKAN
220 static BOOL wined3d_load_vulkan(struct wined3d_vk_info *vk_info)
221 {
222 struct vulkan_ops *vk_ops = &vk_info->vk_ops;
223
224 if (!(vk_info->vulkan_lib = LoadLibraryA("vulkan-1.dll")))
225 {
226 WARN("Failed to load vulkan-1.dll.\n");
227 return FALSE;
228 }
229
230 vk_ops->vkGetInstanceProcAddr = (void *)GetProcAddress(vk_info->vulkan_lib, "vkGetInstanceProcAddr");
231 if (!vk_ops->vkGetInstanceProcAddr)
232 {
233 FreeLibrary(vk_info->vulkan_lib);
234 return FALSE;
235 }
236
237 return TRUE;
238 }
239
240 static void wined3d_unload_vulkan(struct wined3d_vk_info *vk_info)
241 {
242 if (vk_info->vulkan_lib)
243 {
244 FreeLibrary(vk_info->vulkan_lib);
245 vk_info->vulkan_lib = NULL;
246 }
247 }
248 #else
249 static BOOL wined3d_load_vulkan(struct wined3d_vk_info *vk_info)
250 {
251 struct vulkan_ops *vk_ops = &vk_info->vk_ops;
252 const struct vulkan_funcs *vk_funcs;
253 HDC dc;
254
255 dc = GetDC(0);
256 vk_funcs = __wine_get_vulkan_driver(dc, WINE_VULKAN_DRIVER_VERSION);
257 ReleaseDC(0, dc);
258
259 if (!vk_funcs)
260 return FALSE;
261
262 vk_ops->vkGetInstanceProcAddr = (void *)vk_funcs->p_vkGetInstanceProcAddr;
263 return TRUE;
264 }
265
266 static void wined3d_unload_vulkan(struct wined3d_vk_info *vk_info) {}
267 #endif
268
269 static void adapter_vk_destroy(struct wined3d_adapter *adapter)
270 {
271 struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk(adapter);
272 struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
273
274 VK_CALL(vkDestroyInstance(vk_info->instance, NULL));
275 wined3d_unload_vulkan(vk_info);
276 wined3d_adapter_cleanup(&adapter_vk->a);
277 heap_free(adapter_vk->device_extensions);
278 heap_free(adapter_vk);
279 }
280
281 static HRESULT wined3d_select_vulkan_queue_family(const struct wined3d_adapter_vk *adapter_vk,
282 uint32_t *queue_family_index, uint32_t *timestamp_bits)
283 {
284 VkPhysicalDevice physical_device = adapter_vk->physical_device;
285 const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
286 VkQueueFamilyProperties *queue_properties;
287 uint32_t count, i;
288
289 VK_CALL(vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, NULL));
290
291 if (!(queue_properties = heap_calloc(count, sizeof(*queue_properties))))
292 return E_OUTOFMEMORY;
293
294 VK_CALL(vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, queue_properties));
295
296 for (i = 0; i < count; ++i)
297 {
298 if (queue_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
299 {
300 *queue_family_index = i;
301 *timestamp_bits = queue_properties[i].timestampValidBits;
302 heap_free(queue_properties);
303 return WINED3D_OK;
304 }
305 }
306 heap_free(queue_properties);
307
308 WARN("Failed to find graphics queue.\n");
309 return E_FAIL;
310 }
311
312 struct wined3d_physical_device_info
313 {
314 VkPhysicalDeviceTransformFeedbackFeaturesEXT xfb_features;
315 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT vertex_divisor_features;
316
317 VkPhysicalDeviceFeatures2 features2;
318 };
319
320 static void wined3d_disable_vulkan_features(struct wined3d_physical_device_info *info)
321 {
322 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *vertex_divisor_features = &info->vertex_divisor_features;
323 VkPhysicalDeviceFeatures *features = &info->features2.features;
324
325 vertex_divisor_features->vertexAttributeInstanceRateZeroDivisor = VK_FALSE;
326
327 features->depthBounds = VK_FALSE;
328 features->alphaToOne = VK_FALSE;
329 features->textureCompressionETC2 = VK_FALSE;
330 features->textureCompressionASTC_LDR = VK_FALSE;
331 features->shaderStorageImageMultisample = VK_FALSE;
332 features->shaderUniformBufferArrayDynamicIndexing = VK_FALSE;
333 features->shaderSampledImageArrayDynamicIndexing = VK_FALSE;
334 features->shaderStorageBufferArrayDynamicIndexing = VK_FALSE;
335 features->shaderStorageImageArrayDynamicIndexing = VK_FALSE;
336 features->shaderInt16 = VK_FALSE;
337 features->shaderResourceResidency = VK_FALSE;
338 features->shaderResourceMinLod = VK_FALSE;
339 features->sparseBinding = VK_FALSE;
340 features->sparseResidencyBuffer = VK_FALSE;
341 features->sparseResidencyImage2D = VK_FALSE;
342 features->sparseResidencyImage3D = VK_FALSE;
343 features->sparseResidency2Samples = VK_FALSE;
344 features->sparseResidency4Samples = VK_FALSE;
345 features->sparseResidency8Samples = VK_FALSE;
346 features->sparseResidency16Samples = VK_FALSE;
347 features->sparseResidencyAliased = VK_FALSE;
348 features->inheritedQueries = VK_FALSE;
349 }
350
351 static struct wined3d_allocator_chunk *wined3d_allocator_vk_create_chunk(struct wined3d_allocator *allocator,
352 struct wined3d_context *context, unsigned int memory_type, size_t chunk_size)
353 {
354 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
355 struct wined3d_allocator_chunk_vk *chunk_vk;
356
357 if (!(chunk_vk = heap_alloc(sizeof(*chunk_vk))))
358 return NULL;
359
360 if (!wined3d_allocator_chunk_init(&chunk_vk->c, allocator))
361 {
362 heap_free(chunk_vk);
363 return NULL;
364 }
365
366 if (!(chunk_vk->vk_memory = wined3d_context_vk_allocate_vram_chunk_memory(context_vk, memory_type, chunk_size)))
367 {
368 wined3d_allocator_chunk_cleanup(&chunk_vk->c);
369 heap_free(chunk_vk);
370 return NULL;
371 }
372 list_add_head(&allocator->pools[memory_type].chunks, &chunk_vk->c.entry);
373
374 return &chunk_vk->c;
375 }
376
377 static void wined3d_allocator_vk_destroy_chunk(struct wined3d_allocator_chunk *chunk)
378 {
379 struct wined3d_allocator_chunk_vk *chunk_vk = wined3d_allocator_chunk_vk(chunk);
380 const struct wined3d_vk_info *vk_info;
381 struct wined3d_device_vk *device_vk;
382
383 TRACE("chunk %p.\n", chunk);
384
385 device_vk = CONTAINING_RECORD(chunk_vk->c.allocator, struct wined3d_device_vk, allocator);
386 vk_info = &device_vk->vk_info;
387
388 if (chunk_vk->c.map_ptr)
389 VK_CALL(vkUnmapMemory(device_vk->vk_device, chunk_vk->vk_memory));
390 VK_CALL(vkFreeMemory(device_vk->vk_device, chunk_vk->vk_memory, NULL));
391 TRACE("Freed memory 0x%s.\n", wine_dbgstr_longlong(chunk_vk->vk_memory));
392 wined3d_allocator_chunk_cleanup(&chunk_vk->c);
393 heap_free(chunk_vk);
394 }
395
396 static const struct wined3d_allocator_ops wined3d_allocator_vk_ops =
397 {
398 .allocator_create_chunk = wined3d_allocator_vk_create_chunk,
399 .allocator_destroy_chunk = wined3d_allocator_vk_destroy_chunk,
400 };
401
402 static HRESULT adapter_vk_create_device(struct wined3d *wined3d, const struct wined3d_adapter *adapter,
403 enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment,
404 const enum wined3d_feature_level *levels, unsigned int level_count,
405 struct wined3d_device_parent *device_parent, struct wined3d_device **device)
406 {
407 const struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk_const(adapter);
408 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *vertex_divisor_features;
409 const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
410 VkPhysicalDeviceTransformFeedbackFeaturesEXT *xfb_features;
411 struct wined3d_physical_device_info physical_device_info;
412 static const float priorities[] = {1.0f};
413 VkPhysicalDeviceFeatures2 *features2;
414 struct wined3d_device_vk *device_vk;
415 VkDevice vk_device = VK_NULL_HANDLE;
416 VkDeviceQueueCreateInfo queue_info;
417 VkPhysicalDevice physical_device;
418 VkDeviceCreateInfo device_info;
419 uint32_t queue_family_index;
420 uint32_t timestamp_bits;
421 VkResult vr;
422 HRESULT hr;
423
424 if (!(device_vk = heap_alloc_zero(sizeof(*device_vk))))
425 return E_OUTOFMEMORY;
426
427 if (FAILED(hr = wined3d_select_vulkan_queue_family(adapter_vk, &queue_family_index, &timestamp_bits)))
428 goto fail;
429
430 physical_device = adapter_vk->physical_device;
431
432 memset(&physical_device_info, 0, sizeof(physical_device_info));
433
434 xfb_features = &physical_device_info.xfb_features;
435 xfb_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
436
437 vertex_divisor_features = &physical_device_info.vertex_divisor_features;
438 vertex_divisor_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
439 vertex_divisor_features->pNext = xfb_features;
440
441 features2 = &physical_device_info.features2;
442 features2->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
443 features2->pNext = vertex_divisor_features;
444
445 if (vk_info->vk_ops.vkGetPhysicalDeviceFeatures2)
446 VK_CALL(vkGetPhysicalDeviceFeatures2(physical_device, features2));
447 else
448 VK_CALL(vkGetPhysicalDeviceFeatures(physical_device, &features2->features));
449
450 if (!vertex_divisor_features->vertexAttributeInstanceRateDivisor)
451 {
452 WARN("Vertex attribute divisors not supported.\n");
453 hr = E_FAIL;
454 goto fail;
455 }
456
457 wined3d_disable_vulkan_features(&physical_device_info);
458
459 queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
460 queue_info.pNext = NULL;
461 queue_info.flags = 0;
462 queue_info.queueFamilyIndex = queue_family_index;
463 queue_info.queueCount = ARRAY_SIZE(priorities);
464 queue_info.pQueuePriorities = priorities;
465
466 device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
467 device_info.pNext = features2->pNext;
468 device_info.flags = 0;
469 device_info.queueCreateInfoCount = 1;
470 device_info.pQueueCreateInfos = &queue_info;
471 device_info.enabledLayerCount = 0;
472 device_info.ppEnabledLayerNames = NULL;
473 device_info.enabledExtensionCount = adapter_vk->device_extension_count;
474 device_info.ppEnabledExtensionNames = adapter_vk->device_extensions;
475 device_info.pEnabledFeatures = &features2->features;
476
477 if ((vr = VK_CALL(vkCreateDevice(physical_device, &device_info, NULL, &vk_device))) < 0)
478 {
479 WARN("Failed to create Vulkan device, vr %s.\n", wined3d_debug_vkresult(vr));
480 vk_device = VK_NULL_HANDLE;
481 hr = hresult_from_vk_result(vr);
482 goto fail;
483 }
484
485 device_vk->vk_device = vk_device;
486 VK_CALL(vkGetDeviceQueue(vk_device, queue_family_index, 0, &device_vk->vk_queue));
487 device_vk->vk_queue_family_index = queue_family_index;
488 device_vk->timestamp_bits = timestamp_bits;
489
490 device_vk->vk_info = *vk_info;
491 #define VK_DEVICE_PFN(name) \
492 if (!(device_vk->vk_info.vk_ops.name = (void *)VK_CALL(vkGetDeviceProcAddr(vk_device, #name)))) \
493 { \
494 WARN("Could not get device proc addr for '" #name "'.\n"); \
495 hr = E_FAIL; \
496 goto fail; \
497 }
498 #define VK_DEVICE_EXT_PFN(name) \
499 device_vk->vk_info.vk_ops.name = (void *)VK_CALL(vkGetDeviceProcAddr(vk_device, #name));
500 VK_DEVICE_FUNCS()
501 #undef VK_DEVICE_EXT_PFN
502 #undef VK_DEVICE_PFN
503
504 if (!wined3d_allocator_init(&device_vk->allocator,
505 adapter_vk->memory_properties.memoryTypeCount, &wined3d_allocator_vk_ops))
506 {
507 WARN("Failed to initialise allocator.\n");
508 hr = E_FAIL;
509 goto fail;
510 }
511
512 if (FAILED(hr = wined3d_device_init(&device_vk->d, wined3d, adapter->ordinal, device_type, focus_window,
513 flags, surface_alignment, levels, level_count, vk_info->supported, device_parent)))
514 {
515 WARN("Failed to initialize device, hr %#x.\n", hr);
516 wined3d_allocator_cleanup(&device_vk->allocator);
517 goto fail;
518 }
519
520 *device = &device_vk->d;
521
522 return WINED3D_OK;
523
524 fail:
525 VK_CALL(vkDestroyDevice(vk_device, NULL));
526 heap_free(device_vk);
527 return hr;
528 }
529
530 static void adapter_vk_destroy_device(struct wined3d_device *device)
531 {
532 struct wined3d_device_vk *device_vk = wined3d_device_vk(device);
533 const struct wined3d_vk_info *vk_info = &device_vk->vk_info;
534
535 wined3d_device_cleanup(&device_vk->d);
536 wined3d_allocator_cleanup(&device_vk->allocator);
537 VK_CALL(vkDestroyDevice(device_vk->vk_device, NULL));
538 heap_free(device_vk);
539 }
540
541 struct wined3d_context *adapter_vk_acquire_context(struct wined3d_device *device,
542 struct wined3d_texture *texture, unsigned int sub_resource_idx)
543 {
544 TRACE("device %p, texture %p, sub_resource_idx %u.\n", device, texture, sub_resource_idx);
545
546 wined3d_from_cs(device->cs);
547
548 if (!device->context_count)
549 return NULL;
550
551 return &wined3d_device_vk(device)->context_vk.c;
552 }
553
554 void adapter_vk_release_context(struct wined3d_context *context)
555 {
556 TRACE("context %p.\n", context);
557 }
558
559 static void adapter_vk_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps)
560 {
561 const struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk_const(adapter);
562 const VkPhysicalDeviceLimits *limits = &adapter_vk->device_limits;
563 BOOL sampler_anisotropy = limits->maxSamplerAnisotropy > 1.0f;
564
565 caps->ddraw_caps.dds_caps |= WINEDDSCAPS_BACKBUFFER
566 | WINEDDSCAPS_COMPLEX
567 | WINEDDSCAPS_FRONTBUFFER
568 | WINEDDSCAPS_3DDEVICE
569 | WINEDDSCAPS_VIDEOMEMORY
570 | WINEDDSCAPS_OWNDC
571 | WINEDDSCAPS_LOCALVIDMEM
572 | WINEDDSCAPS_NONLOCALVIDMEM;
573 caps->ddraw_caps.caps |= WINEDDCAPS_3D;
574
575 caps->Caps2 |= WINED3DCAPS2_CANGENMIPMAP;
576
577 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_BLENDOP
578 | WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
579 | WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
580 | WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT
581 | WINED3DPMISCCAPS_SEPARATEALPHABLEND;
582
583 caps->RasterCaps |= WINED3DPRASTERCAPS_MIPMAPLODBIAS;
584
585 if (sampler_anisotropy)
586 {
587 caps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY;
588
589 caps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
590 | WINED3DPTFILTERCAPS_MINFANISOTROPIC;
591
592 caps->MaxAnisotropy = limits->maxSamplerAnisotropy;
593 }
594
595 caps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
596 caps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR
597 | WINED3DPBLENDCAPS_SRCALPHASAT;
598
599 caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP
600 | WINED3DPTEXTURECAPS_MIPVOLUMEMAP
601 | WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
602 caps->VolumeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR
603 | WINED3DPTFILTERCAPS_MAGFPOINT
604 | WINED3DPTFILTERCAPS_MINFLINEAR
605 | WINED3DPTFILTERCAPS_MINFPOINT
606 | WINED3DPTFILTERCAPS_MIPFLINEAR
607 | WINED3DPTFILTERCAPS_MIPFPOINT
608 | WINED3DPTFILTERCAPS_LINEAR
609 | WINED3DPTFILTERCAPS_LINEARMIPLINEAR
610 | WINED3DPTFILTERCAPS_LINEARMIPNEAREST
611 | WINED3DPTFILTERCAPS_MIPLINEAR
612 | WINED3DPTFILTERCAPS_MIPNEAREST
613 | WINED3DPTFILTERCAPS_NEAREST;
614 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_INDEPENDENTUV
615 | WINED3DPTADDRESSCAPS_CLAMP
616 | WINED3DPTADDRESSCAPS_WRAP;
617 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER
618 | WINED3DPTADDRESSCAPS_MIRROR
619 | WINED3DPTADDRESSCAPS_MIRRORONCE;
620
621 caps->MaxVolumeExtent = limits->maxImageDimension3D;
622
623 caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP
624 | WINED3DPTEXTURECAPS_MIPCUBEMAP
625 | WINED3DPTEXTURECAPS_CUBEMAP_POW2;
626 caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR
627 | WINED3DPTFILTERCAPS_MAGFPOINT
628 | WINED3DPTFILTERCAPS_MINFLINEAR
629 | WINED3DPTFILTERCAPS_MINFPOINT
630 | WINED3DPTFILTERCAPS_MIPFLINEAR
631 | WINED3DPTFILTERCAPS_MIPFPOINT
632 | WINED3DPTFILTERCAPS_LINEAR
633 | WINED3DPTFILTERCAPS_LINEARMIPLINEAR
634 | WINED3DPTFILTERCAPS_LINEARMIPNEAREST
635 | WINED3DPTFILTERCAPS_MIPLINEAR
636 | WINED3DPTFILTERCAPS_MIPNEAREST
637 | WINED3DPTFILTERCAPS_NEAREST;
638
639 if (sampler_anisotropy)
640 {
641 caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
642 | WINED3DPTFILTERCAPS_MINFANISOTROPIC;
643 }
644
645 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER
646 | WINED3DPTADDRESSCAPS_MIRROR
647 | WINED3DPTADDRESSCAPS_MIRRORONCE;
648
649 caps->StencilCaps |= WINED3DSTENCILCAPS_DECR
650 | WINED3DSTENCILCAPS_INCR
651 | WINED3DSTENCILCAPS_TWOSIDED;
652
653 caps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 | WINED3DDTCAPS_FLOAT16_4;
654
655 caps->MaxPixelShader30InstructionSlots = WINED3DMAX30SHADERINSTRUCTIONS;
656 caps->MaxVertexShader30InstructionSlots = WINED3DMAX30SHADERINSTRUCTIONS;
657 caps->PS20Caps.temp_count = WINED3DPS20_MAX_NUMTEMPS;
658 caps->VS20Caps.temp_count = WINED3DVS20_MAX_NUMTEMPS;
659 }
660
661 static BOOL adapter_vk_check_format(const struct wined3d_adapter *adapter,
662 const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format,
663 const struct wined3d_format *ds_format)
664 {
665 return TRUE;
666 }
667
668 static HRESULT adapter_vk_init_3d(struct wined3d_device *device)
669 {
670 struct wined3d_context_vk *context_vk;
671 struct wined3d_device_vk *device_vk;
672 HRESULT hr;
673
674 TRACE("device %p.\n", device);
675
676 device_vk = wined3d_device_vk(device);
677 context_vk = &device_vk->context_vk;
678 if (FAILED(hr = wined3d_context_vk_init(context_vk, device->swapchains[0])))
679 {
680 WARN("Failed to initialise context.\n");
681 return hr;
682 }
683
684 if (FAILED(hr = device->shader_backend->shader_alloc_private(device,
685 device->adapter->vertex_pipe, device->adapter->fragment_pipe)))
686 {
687 ERR("Failed to allocate shader private data, hr %#x.\n", hr);
688 wined3d_context_vk_cleanup(context_vk);
689 return hr;
690 }
691
692 if (!device_context_add(device, &context_vk->c))
693 {
694 ERR("Failed to add the newly created context to the context list.\n");
695 device->shader_backend->shader_free_private(device, NULL);
696 wined3d_context_vk_cleanup(context_vk);
697 return E_FAIL;
698 }
699
700 TRACE("Initialised context %p.\n", context_vk);
701
702 if (!(device_vk->d.blitter = wined3d_cpu_blitter_create()))
703 {
704 ERR("Failed to create CPU blitter.\n");
705 device_context_remove(device, &context_vk->c);
706 device->shader_backend->shader_free_private(device, NULL);
707 wined3d_context_vk_cleanup(context_vk);
708 return E_FAIL;
709 }
710 wined3d_vk_blitter_create(&device_vk->d.blitter);
711
712 wined3d_device_create_default_samplers(device, &context_vk->c);
713 wined3d_device_vk_create_null_resources(device_vk, context_vk);
714 wined3d_device_vk_create_null_views(device_vk, context_vk);
715
716 return WINED3D_OK;
717 }
718
719 static void adapter_vk_uninit_3d_cs(void *object)
720 {
721 struct wined3d_device_vk *device_vk = object;
722 struct wined3d_context_vk *context_vk;
723 struct wined3d_device *device;
724 struct wined3d_shader *shader;
725
726 TRACE("device_vk %p.\n", device_vk);
727
728 context_vk = &device_vk->context_vk;
729 device = &device_vk->d;
730
731 LIST_FOR_EACH_ENTRY(shader, &device->shaders, struct wined3d_shader, shader_list_entry)
732 {
733 device->shader_backend->shader_destroy(shader);
734 }
735
736 device->blitter->ops->blitter_destroy(device->blitter, NULL);
737 device->shader_backend->shader_free_private(device, &context_vk->c);
738 wined3d_device_vk_destroy_null_views(device_vk, context_vk);
739 wined3d_device_vk_destroy_null_resources(device_vk, context_vk);
740 wined3d_device_destroy_default_samplers(device, &context_vk->c);
741 }
742
743 static void adapter_vk_uninit_3d(struct wined3d_device *device)
744 {
745 struct wined3d_context_vk *context_vk;
746 struct wined3d_device_vk *device_vk;
747
748 TRACE("device %p.\n", device);
749
750 device_vk = wined3d_device_vk(device);
751 context_vk = &device_vk->context_vk;
752
753 wined3d_cs_destroy_object(device->cs, adapter_vk_uninit_3d_cs, device_vk);
754 wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
755
756 device_context_remove(device, &context_vk->c);
757 wined3d_context_vk_cleanup(context_vk);
758 }
759
760 static void *wined3d_bo_vk_map(struct wined3d_bo_vk *bo, struct wined3d_context_vk *context_vk)
761 {
762 const struct wined3d_vk_info *vk_info;
763 struct wined3d_device_vk *device_vk;
764 struct wined3d_bo_slab_vk *slab;
765 void *map_ptr;
766 VkResult vr;
767
768 if (bo->map_ptr)
769 return bo->map_ptr;
770
771 vk_info = context_vk->vk_info;
772 device_vk = wined3d_device_vk(context_vk->c.device);
773
774 if ((slab = bo->slab))
775 {
776 if (!(map_ptr = slab->map_ptr) && !(map_ptr = wined3d_bo_vk_map(&slab->bo, context_vk)))
777 {
778 ERR("Failed to map slab.\n");
779 return NULL;
780 }
781 ++slab->map_count;
782 }
783 else if (bo->memory)
784 {
785 struct wined3d_allocator_chunk_vk *chunk_vk = wined3d_allocator_chunk_vk(bo->memory->chunk);
786
787 if (!(map_ptr = wined3d_allocator_chunk_vk_map(chunk_vk, context_vk)))
788 {
789 ERR("Failed to map chunk.\n");
790 return NULL;
791 }
792 }
793 else if ((vr = VK_CALL(vkMapMemory(device_vk->vk_device, bo->vk_memory, 0, VK_WHOLE_SIZE, 0, &map_ptr))) < 0)
794 {
795 ERR("Failed to map memory, vr %s.\n", wined3d_debug_vkresult(vr));
796 return NULL;
797 }
798
799 if (sizeof(map_ptr) >= sizeof(uint64_t))
800 bo->map_ptr = map_ptr;
801
802 return map_ptr;
803 }
804
805 static void wined3d_bo_vk_unmap(struct wined3d_bo_vk *bo, struct wined3d_context_vk *context_vk)
806 {
807 const struct wined3d_vk_info *vk_info;
808 struct wined3d_device_vk *device_vk;
809 struct wined3d_bo_slab_vk *slab;
810
811 if (bo->map_ptr)
812 return;
813
814 if ((slab = bo->slab))
815 {
816 if (--slab->map_count)
817 return;
818
819 wined3d_bo_vk_unmap(&slab->bo, context_vk);
820 slab->map_ptr = NULL;
821 return;
822 }
823
824 vk_info = context_vk->vk_info;
825 device_vk = wined3d_device_vk(context_vk->c.device);
826
827 if (bo->memory)
828 wined3d_allocator_chunk_vk_unmap(wined3d_allocator_chunk_vk(bo->memory->chunk), context_vk);
829 else
830 VK_CALL(vkUnmapMemory(device_vk->vk_device, bo->vk_memory));
831 }
832
833 static VkAccessFlags vk_access_mask_from_buffer_usage(VkBufferUsageFlags usage)
834 {
835 VkAccessFlags flags = 0;
836
837 if (usage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
838 flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
839 if (usage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
840 flags |= VK_ACCESS_INDEX_READ_BIT;
841 if (usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
842 flags |= VK_ACCESS_UNIFORM_READ_BIT;
843 if (usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
844 flags |= VK_ACCESS_SHADER_READ_BIT;
845 if (usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)
846 flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
847 if (usage & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)
848 flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
849 if (usage & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT)
850 flags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
851 if (usage & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT)
852 flags |= VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
853 | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
854
855 return flags;
856 }
857
858 static void *adapter_vk_map_bo_address(struct wined3d_context *context,
859 const struct wined3d_bo_address *data, size_t size, uint32_t map_flags)
860 {
861 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
862 const struct wined3d_vk_info *vk_info;
863 struct wined3d_bo_user_vk *bo_user_vk;
864 struct wined3d_device_vk *device_vk;
865 VkCommandBuffer vk_command_buffer;
866 VkBufferMemoryBarrier vk_barrier;
867 struct wined3d_bo_vk *bo, tmp;
868 VkMappedMemoryRange range;
869 void *map_ptr;
870
871 if (!(bo = (struct wined3d_bo_vk *)data->buffer_object))
872 return data->addr;
873
874 vk_info = context_vk->vk_info;
875 device_vk = wined3d_device_vk(context->device);
876
877 if (map_flags & WINED3D_MAP_NOOVERWRITE)
878 goto map;
879
880 if ((map_flags & WINED3D_MAP_DISCARD) && bo->command_buffer_id > context_vk->completed_command_buffer_id)
881 {
882 if (wined3d_context_vk_create_bo(context_vk, bo->size, bo->usage, bo->memory_type, &tmp))
883 {
884 list_move_head(&tmp.users, &bo->users);
885 wined3d_context_vk_destroy_bo(context_vk, bo);
886 *bo = tmp;
887 list_init(&bo->users);
888 list_move_head(&bo->users, &tmp.users);
889 LIST_FOR_EACH_ENTRY(bo_user_vk, &bo->users, struct wined3d_bo_user_vk, entry)
890 {
891 bo_user_vk->valid = false;
892 }
893
894 goto map;
895 }
896
897 ERR("Failed to create new buffer object.\n");
898 }
899
900 if (map_flags & WINED3D_MAP_READ)
901 {
902 if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
903 {
904 ERR("Failed to get command buffer.\n");
905 return NULL;
906 }
907
908 wined3d_context_vk_end_current_render_pass(context_vk);
909
910 vk_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
911 vk_barrier.pNext = NULL;
912 vk_barrier.srcAccessMask = vk_access_mask_from_buffer_usage(bo->usage);
913 vk_barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
914 vk_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
915 vk_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
916 vk_barrier.buffer = bo->vk_buffer;
917 vk_barrier.offset = bo->buffer_offset + (uintptr_t)data->addr;
918 vk_barrier.size = size;
919 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
920 VK_PIPELINE_STAGE_HOST_BIT, 0, 0, NULL, 1, &vk_barrier, 0, NULL));
921
922 if (!(bo->memory_type & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
923 {
924 range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
925 range.pNext = NULL;
926 range.memory = bo->vk_memory;
927 range.offset = bo->memory_offset + (uintptr_t)data->addr;
928 range.size = size;
929 VK_CALL(vkInvalidateMappedMemoryRanges(device_vk->vk_device, 1, &range));
930 }
931
932 wined3d_context_vk_reference_bo(context_vk, bo);
933 }
934
935 if (bo->command_buffer_id == context_vk->current_command_buffer.id)
936 wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL);
937 wined3d_context_vk_wait_command_buffer(context_vk, bo->command_buffer_id);
938
939 map:
940 if (!(map_ptr = wined3d_bo_vk_map(bo, context_vk)))
941 {
942 ERR("Failed to map bo.\n");
943 return NULL;
944 }
945
946 return (uint8_t *)map_ptr + bo->memory_offset + (uintptr_t)data->addr;
947 }
948
949 static void adapter_vk_unmap_bo_address(struct wined3d_context *context,
950 const struct wined3d_bo_address *data, unsigned int range_count, const struct wined3d_range *ranges)
951 {
952 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
953 const struct wined3d_vk_info *vk_info;
954 struct wined3d_device_vk *device_vk;
955 VkMappedMemoryRange range;
956 struct wined3d_bo_vk *bo;
957 unsigned int i;
958
959 if (!(bo = (struct wined3d_bo_vk *)data->buffer_object))
960 return;
961
962 vk_info = context_vk->vk_info;
963 device_vk = wined3d_device_vk(context->device);
964
965 if (!(bo->memory_type & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
966 {
967 range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
968 range.pNext = NULL;
969 range.memory = bo->vk_memory;
970
971 for (i = 0; i < range_count; ++i)
972 {
973 range.offset = bo->memory_offset + ranges[i].offset;
974 range.size = ranges[i].size;
975 VK_CALL(vkFlushMappedMemoryRanges(device_vk->vk_device, 1, &range));
976 }
977 }
978
979 wined3d_bo_vk_unmap(bo, context_vk);
980 }
981
982 static void adapter_vk_copy_bo_address(struct wined3d_context *context,
983 const struct wined3d_bo_address *dst, const struct wined3d_bo_address *src, size_t size)
984 {
985 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
986 const struct wined3d_vk_info *vk_info = context_vk->vk_info;
987 struct wined3d_bo_vk staging_bo, *src_bo, *dst_bo;
988 VkAccessFlags src_access_mask, dst_access_mask;
989 VkBufferMemoryBarrier vk_barrier[2];
990 struct wined3d_bo_address staging;
991 VkCommandBuffer vk_command_buffer;
992 struct wined3d_range range;
993 void *dst_ptr, *src_ptr;
994 VkBufferCopy region;
995
996 src_bo = (struct wined3d_bo_vk *)src->buffer_object;
997 dst_bo = (struct wined3d_bo_vk *)dst->buffer_object;
998
999 if (src_bo && dst_bo)
1000 {
1001 if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
1002 {
1003 ERR("Failed to get command buffer.\n");
1004 return;
1005 }
1006
1007 wined3d_context_vk_end_current_render_pass(context_vk);
1008
1009 src_access_mask = vk_access_mask_from_buffer_usage(src_bo->usage);
1010 dst_access_mask = vk_access_mask_from_buffer_usage(dst_bo->usage);
1011
1012 region.srcOffset = src_bo->buffer_offset + (uintptr_t)src->addr;
1013 region.dstOffset = dst_bo->buffer_offset + (uintptr_t)dst->addr;
1014 region.size = size;
1015
1016 vk_barrier[0].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
1017 vk_barrier[0].pNext = NULL;
1018 vk_barrier[0].srcAccessMask = src_access_mask;
1019 vk_barrier[0].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1020 vk_barrier[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1021 vk_barrier[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1022 vk_barrier[0].buffer = src_bo->vk_buffer;
1023 vk_barrier[0].offset = region.srcOffset;
1024 vk_barrier[0].size = region.size;
1025
1026 vk_barrier[1].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
1027 vk_barrier[1].pNext = NULL;
1028 vk_barrier[1].srcAccessMask = dst_access_mask;
1029 vk_barrier[1].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1030 vk_barrier[1].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1031 vk_barrier[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1032 vk_barrier[1].buffer = dst_bo->vk_buffer;
1033 vk_barrier[1].offset = region.dstOffset;
1034 vk_barrier[1].size = region.size;
1035
1036 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
1037 VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL));
1038
1039 VK_CALL(vkCmdCopyBuffer(vk_command_buffer, src_bo->vk_buffer, dst_bo->vk_buffer, 1, &region));
1040
1041 vk_barrier[0].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1042 vk_barrier[0].dstAccessMask = src_access_mask;
1043
1044 vk_barrier[1].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1045 vk_barrier[1].dstAccessMask = dst_access_mask;
1046
1047 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
1048 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL));
1049
1050 wined3d_context_vk_reference_bo(context_vk, src_bo);
1051 wined3d_context_vk_reference_bo(context_vk, dst_bo);
1052
1053 return;
1054 }
1055
1056 if (src_bo && !(src_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
1057 {
1058 if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
1059 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)))
1060 {
1061 ERR("Failed to create staging bo.\n");
1062 return;
1063 }
1064
1065 staging.buffer_object = (uintptr_t)&staging_bo;
1066 staging.addr = NULL;
1067 adapter_vk_copy_bo_address(context, &staging, src, size);
1068 adapter_vk_copy_bo_address(context, dst, &staging, size);
1069
1070 wined3d_context_vk_destroy_bo(context_vk, &staging_bo);
1071
1072 return;
1073 }
1074
1075 if (dst_bo && (dst_bo->command_buffer_id > context_vk->completed_command_buffer_id
1076 || !(dst_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)))
1077 {
1078 if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
1079 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)))
1080 {
1081 ERR("Failed to create staging bo.\n");
1082 return;
1083 }
1084
1085 staging.buffer_object = (uintptr_t)&staging_bo;
1086 staging.addr = NULL;
1087 adapter_vk_copy_bo_address(context, &staging, src, size);
1088 adapter_vk_copy_bo_address(context, dst, &staging, size);
1089
1090 wined3d_context_vk_destroy_bo(context_vk, &staging_bo);
1091
1092 return;
1093 }
1094
1095 src_ptr = adapter_vk_map_bo_address(context, src, size, WINED3D_MAP_READ);
1096 dst_ptr = adapter_vk_map_bo_address(context, dst, size, WINED3D_MAP_WRITE);
1097
1098 memcpy(dst_ptr, src_ptr, size);
1099
1100 range.offset = 0;
1101 range.size = size;
1102 adapter_vk_unmap_bo_address(context, dst, 1, &range);
1103 adapter_vk_unmap_bo_address(context, src, 0, NULL);
1104 }
1105
1106 static HRESULT adapter_vk_create_swapchain(struct wined3d_device *device,
1107 struct wined3d_swapchain_desc *desc, struct wined3d_swapchain_state_parent *state_parent,
1108 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_swapchain **swapchain)
1109 {
1110 struct wined3d_swapchain_vk *swapchain_vk;
1111 HRESULT hr;
1112
1113 TRACE("device %p, desc %p, state_parent %p, parent %p, parent_ops %p, swapchain %p.\n",
1114 device, desc, state_parent, parent, parent_ops, swapchain);
1115
1116 if (!(swapchain_vk = heap_alloc_zero(sizeof(*swapchain_vk))))
1117 return E_OUTOFMEMORY;
1118
1119 if (FAILED(hr = wined3d_swapchain_vk_init(swapchain_vk, device, desc, state_parent, parent,
1120 parent_ops)))
1121 {
1122 WARN("Failed to initialise swapchain, hr %#x.\n", hr);
1123 heap_free(swapchain_vk);
1124 return hr;
1125 }
1126
1127 TRACE("Created swapchain %p.\n", swapchain_vk);
1128 *swapchain = &swapchain_vk->s;
1129
1130 return hr;
1131 }
1132
1133 static void adapter_vk_destroy_swapchain(struct wined3d_swapchain *swapchain)
1134 {
1135 struct wined3d_swapchain_vk *swapchain_vk = wined3d_swapchain_vk(swapchain);
1136
1137 wined3d_swapchain_vk_cleanup(swapchain_vk);
1138 heap_free(swapchain_vk);
1139 }
1140
1141 unsigned int wined3d_adapter_vk_get_memory_type_index(const struct wined3d_adapter_vk *adapter_vk,
1142 uint32_t memory_type_mask, VkMemoryPropertyFlags flags)
1143 {
1144 const VkPhysicalDeviceMemoryProperties *memory_info = &adapter_vk->memory_properties;
1145 unsigned int i;
1146
1147 for (i = 0; i < memory_info->memoryTypeCount; ++i)
1148 {
1149 if (!(memory_type_mask & (1u << i)))
1150 continue;
1151 if ((memory_info->memoryTypes[i].propertyFlags & flags) == flags)
1152 return i;
1153 }
1154
1155 return ~0u;
1156 }
1157
1158 static HRESULT adapter_vk_create_buffer(struct wined3d_device *device,
1159 const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data,
1160 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_buffer **buffer)
1161 {
1162 struct wined3d_buffer_vk *buffer_vk;
1163 HRESULT hr;
1164
1165 TRACE("device %p, desc %p, data %p, parent %p, parent_ops %p, buffer %p.\n",
1166 device, desc, data, parent, parent_ops, buffer);
1167
1168 if (!(buffer_vk = heap_alloc_zero(sizeof(*buffer_vk))))
1169 return E_OUTOFMEMORY;
1170
1171 if (FAILED(hr = wined3d_buffer_vk_init(buffer_vk, device, desc, data, parent, parent_ops)))
1172 {
1173 WARN("Failed to initialise buffer, hr %#x.\n", hr);
1174 heap_free(buffer_vk);
1175 return hr;
1176 }
1177
1178 TRACE("Created buffer %p.\n", buffer_vk);
1179 *buffer = &buffer_vk->b;
1180
1181 return hr;
1182 }
1183
1184 static void adapter_vk_destroy_buffer(struct wined3d_buffer *buffer)
1185 {
1186 struct wined3d_buffer_vk *buffer_vk = wined3d_buffer_vk(buffer);
1187 struct wined3d_device *device = buffer_vk->b.resource.device;
1188 unsigned int swapchain_count = device->swapchain_count;
1189
1190 TRACE("buffer_vk %p.\n", buffer_vk);
1191
1192 /* Take a reference to the device, in case releasing the buffer would
1193 * cause the device to be destroyed. However, swapchain resources don't
1194 * take a reference to the device, and we wouldn't want to increment the
1195 * refcount on a device that's in the process of being destroyed. */
1196 if (swapchain_count)
1197 wined3d_device_incref(device);
1198 wined3d_buffer_cleanup(&buffer_vk->b);
1199 wined3d_cs_destroy_object(device->cs, heap_free, buffer_vk);
1200 if (swapchain_count)
1201 wined3d_device_decref(device);
1202 }
1203
1204 static HRESULT adapter_vk_create_texture(struct wined3d_device *device,
1205 const struct wined3d_resource_desc *desc, unsigned int layer_count, unsigned int level_count,
1206 uint32_t flags, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_texture **texture)
1207 {
1208 struct wined3d_texture_vk *texture_vk;
1209 HRESULT hr;
1210
1211 TRACE("device %p, desc %p, layer_count %u, level_count %u, flags %#x, parent %p, parent_ops %p, texture %p.\n",
1212 device, desc, layer_count, level_count, flags, parent, parent_ops, texture);
1213
1214 if (!(texture_vk = wined3d_texture_allocate_object_memory(sizeof(*texture_vk), level_count, layer_count)))
1215 return E_OUTOFMEMORY;
1216
1217 if (FAILED(hr = wined3d_texture_vk_init(texture_vk, device, desc,
1218 layer_count, level_count, flags, parent, parent_ops)))
1219 {
1220 WARN("Failed to initialise texture, hr %#x.\n", hr);
1221 heap_free(texture_vk);
1222 return hr;
1223 }
1224
1225 TRACE("Created texture %p.\n", texture_vk);
1226 *texture = &texture_vk->t;
1227
1228 return hr;
1229 }
1230
1231 static void adapter_vk_destroy_texture(struct wined3d_texture *texture)
1232 {
1233 struct wined3d_texture_vk *texture_vk = wined3d_texture_vk(texture);
1234 struct wined3d_device *device = texture_vk->t.resource.device;
1235 unsigned int swapchain_count = device->swapchain_count;
1236
1237 TRACE("texture_vk %p.\n", texture_vk);
1238
1239 /* Take a reference to the device, in case releasing the texture would
1240 * cause the device to be destroyed. However, swapchain resources don't
1241 * take a reference to the device, and we wouldn't want to increment the
1242 * refcount on a device that's in the process of being destroyed. */
1243 if (swapchain_count)
1244 wined3d_device_incref(device);
1245
1246 wined3d_texture_sub_resources_destroyed(texture);
1247 texture->resource.parent_ops->wined3d_object_destroyed(texture->resource.parent);
1248
1249 wined3d_texture_cleanup(&texture_vk->t);
1250 wined3d_cs_destroy_object(device->cs, heap_free, texture_vk);
1251
1252 if (swapchain_count)
1253 wined3d_device_decref(device);
1254 }
1255
1256 static HRESULT adapter_vk_create_rendertarget_view(const struct wined3d_view_desc *desc,
1257 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1258 struct wined3d_rendertarget_view **view)
1259 {
1260 struct wined3d_rendertarget_view_vk *view_vk;
1261 HRESULT hr;
1262
1263 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
1264 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
1265
1266 if (!(view_vk = heap_alloc_zero(sizeof(*view_vk))))
1267 return E_OUTOFMEMORY;
1268
1269 if (FAILED(hr = wined3d_rendertarget_view_vk_init(view_vk, desc, resource, parent, parent_ops)))
1270 {
1271 WARN("Failed to initialise view, hr %#x.\n", hr);
1272 heap_free(view_vk);
1273 return hr;
1274 }
1275
1276 TRACE("Created render target view %p.\n", view_vk);
1277 *view = &view_vk->v;
1278
1279 return hr;
1280 }
1281
1282 struct wined3d_view_vk_destroy_ctx
1283 {
1284 struct wined3d_device_vk *device_vk;
1285 VkBufferView *vk_buffer_view;
1286 VkImageView *vk_image_view;
1287 struct wined3d_bo_vk *vk_counter_bo;
1288 VkBufferView *vk_counter_view;
1289 uint64_t *command_buffer_id;
1290 void *object;
1291 struct wined3d_view_vk_destroy_ctx *free;
1292 };
1293
1294 static void wined3d_view_vk_destroy_object(void *object)
1295 {
1296 struct wined3d_view_vk_destroy_ctx *ctx = object;
1297 const struct wined3d_vk_info *vk_info;
1298 struct wined3d_device_vk *device_vk;
1299 struct wined3d_context *context;
1300
1301 device_vk = ctx->device_vk;
1302 vk_info = &wined3d_adapter_vk(device_vk->d.adapter)->vk_info;
1303 context = context_acquire(&device_vk->d, NULL, 0);
1304
1305 if (ctx->vk_buffer_view)
1306 {
1307 if (context)
1308 {
1309 wined3d_context_vk_destroy_buffer_view(wined3d_context_vk(context),
1310 *ctx->vk_buffer_view, *ctx->command_buffer_id);
1311 }
1312 else
1313 {
1314 VK_CALL(vkDestroyBufferView(device_vk->vk_device, *ctx->vk_buffer_view, NULL));
1315 TRACE("Destroyed buffer view 0x%s.\n", wine_dbgstr_longlong(*ctx->vk_buffer_view));
1316 }
1317 }
1318 if (ctx->vk_image_view)
1319 {
1320 if (context)
1321 {
1322 wined3d_context_vk_destroy_image_view(wined3d_context_vk(context),
1323 *ctx->vk_image_view, *ctx->command_buffer_id);
1324 }
1325 else
1326 {
1327 VK_CALL(vkDestroyImageView(device_vk->vk_device, *ctx->vk_image_view, NULL));
1328 TRACE("Destroyed image view 0x%s.\n", wine_dbgstr_longlong(*ctx->vk_image_view));
1329 }
1330 }
1331 if (ctx->vk_counter_bo && ctx->vk_counter_bo->vk_buffer)
1332 wined3d_context_vk_destroy_bo(wined3d_context_vk(context), ctx->vk_counter_bo);
1333 if (ctx->vk_counter_view)
1334 {
1335 if (context)
1336 {
1337 wined3d_context_vk_destroy_buffer_view(wined3d_context_vk(context),
1338 *ctx->vk_counter_view, *ctx->command_buffer_id);
1339 }
1340 else
1341 {
1342 VK_CALL(vkDestroyBufferView(device_vk->vk_device, *ctx->vk_counter_view, NULL));
1343 TRACE("Destroyed counter buffer view 0x%s.\n", wine_dbgstr_longlong(*ctx->vk_counter_view));
1344 }
1345 }
1346
1347 if (context)
1348 context_release(context);
1349
1350 heap_free(ctx->object);
1351 heap_free(ctx->free);
1352 }
1353
1354 static void wined3d_view_vk_destroy(struct wined3d_device *device, VkBufferView *vk_buffer_view,
1355 VkImageView *vk_image_view, struct wined3d_bo_vk *vk_counter_bo,
1356 VkBufferView *vk_counter_view, uint64_t *command_buffer_id, void *view_vk)
1357 {
1358 struct wined3d_view_vk_destroy_ctx *ctx, c;
1359
1360 if (!(ctx = heap_alloc(sizeof(*ctx))))
1361 ctx = &c;
1362 ctx->device_vk = wined3d_device_vk(device);
1363 ctx->vk_buffer_view = vk_buffer_view;
1364 ctx->vk_image_view = vk_image_view;
1365 ctx->vk_counter_bo = vk_counter_bo;
1366 ctx->vk_counter_view = vk_counter_view;
1367 ctx->command_buffer_id = command_buffer_id;
1368 ctx->object = view_vk;
1369 ctx->free = ctx != &c ? ctx : NULL;
1370
1371 wined3d_cs_destroy_object(device->cs, wined3d_view_vk_destroy_object, ctx);
1372 if (ctx == &c)
1373 device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
1374 }
1375
1376 static void adapter_vk_destroy_rendertarget_view(struct wined3d_rendertarget_view *view)
1377 {
1378 struct wined3d_rendertarget_view_vk *view_vk = wined3d_rendertarget_view_vk(view);
1379 struct wined3d_device *device = view_vk->v.resource->device;
1380 unsigned int swapchain_count = device->swapchain_count;
1381
1382 TRACE("view_vk %p.\n", view_vk);
1383
1384 /* Take a reference to the device, in case releasing the view's resource
1385 * would cause the device to be destroyed. However, swapchain resources
1386 * don't take a reference to the device, and we wouldn't want to increment
1387 * the refcount on a device that's in the process of being destroyed. */
1388 if (swapchain_count)
1389 wined3d_device_incref(device);
1390 wined3d_rendertarget_view_cleanup(&view_vk->v);
1391 wined3d_view_vk_destroy(device, NULL, &view_vk->vk_image_view,
1392 NULL, NULL, &view_vk->command_buffer_id, view_vk);
1393 if (swapchain_count)
1394 wined3d_device_decref(device);
1395 }
1396
1397 static HRESULT adapter_vk_create_shader_resource_view(const struct wined3d_view_desc *desc,
1398 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1399 struct wined3d_shader_resource_view **view)
1400 {
1401 struct wined3d_shader_resource_view_vk *view_vk;
1402 HRESULT hr;
1403
1404 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
1405 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
1406
1407 if (!(view_vk = heap_alloc_zero(sizeof(*view_vk))))
1408 return E_OUTOFMEMORY;
1409
1410 if (FAILED(hr = wined3d_shader_resource_view_vk_init(view_vk, desc, resource, parent, parent_ops)))
1411 {
1412 WARN("Failed to initialise view, hr %#x.\n", hr);
1413 heap_free(view_vk);
1414 return hr;
1415 }
1416
1417 TRACE("Created shader resource view %p.\n", view_vk);
1418 *view = &view_vk->v;
1419
1420 return hr;
1421 }
1422
1423 static void adapter_vk_destroy_shader_resource_view(struct wined3d_shader_resource_view *view)
1424 {
1425 struct wined3d_shader_resource_view_vk *srv_vk = wined3d_shader_resource_view_vk(view);
1426 struct wined3d_device *device = srv_vk->v.resource->device;
1427 unsigned int swapchain_count = device->swapchain_count;
1428 struct wined3d_view_vk *view_vk = &srv_vk->view_vk;
1429 VkBufferView *vk_buffer_view = NULL;
1430 VkImageView *vk_image_view = NULL;
1431
1432 TRACE("srv_vk %p.\n", srv_vk);
1433
1434 /* Take a reference to the device, in case releasing the view's resource
1435 * would cause the device to be destroyed. However, swapchain resources
1436 * don't take a reference to the device, and we wouldn't want to increment
1437 * the refcount on a device that's in the process of being destroyed. */
1438 if (swapchain_count)
1439 wined3d_device_incref(device);
1440 if (srv_vk->v.resource->type == WINED3D_RTYPE_BUFFER)
1441 vk_buffer_view = &view_vk->u.vk_buffer_view;
1442 else
1443 vk_image_view = &view_vk->u.vk_image_info.imageView;
1444 list_remove(&view_vk->bo_user.entry);
1445 wined3d_shader_resource_view_cleanup(&srv_vk->v);
1446 wined3d_view_vk_destroy(device, vk_buffer_view, vk_image_view,
1447 NULL, NULL, &view_vk->command_buffer_id, srv_vk);
1448 if (swapchain_count)
1449 wined3d_device_decref(device);
1450 }
1451
1452 static HRESULT adapter_vk_create_unordered_access_view(const struct wined3d_view_desc *desc,
1453 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1454 struct wined3d_unordered_access_view **view)
1455 {
1456 struct wined3d_unordered_access_view_vk *view_vk;
1457 HRESULT hr;
1458
1459 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
1460 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
1461
1462 if (!(view_vk = heap_alloc_zero(sizeof(*view_vk))))
1463 return E_OUTOFMEMORY;
1464
1465 if (FAILED(hr = wined3d_unordered_access_view_vk_init(view_vk, desc, resource, parent, parent_ops)))
1466 {
1467 WARN("Failed to initialise view, hr %#x.\n", hr);
1468 heap_free(view_vk);
1469 return hr;
1470 }
1471
1472 TRACE("Created unordered access view %p.\n", view_vk);
1473 *view = &view_vk->v;
1474
1475 return hr;
1476 }
1477
1478 static void adapter_vk_destroy_unordered_access_view(struct wined3d_unordered_access_view *view)
1479 {
1480 struct wined3d_unordered_access_view_vk *uav_vk = wined3d_unordered_access_view_vk(view);
1481 struct wined3d_device *device = uav_vk->v.resource->device;
1482 unsigned int swapchain_count = device->swapchain_count;
1483 struct wined3d_view_vk *view_vk = &uav_vk->view_vk;
1484 VkBufferView *vk_buffer_view = NULL;
1485 VkImageView *vk_image_view = NULL;
1486
1487 TRACE("uav_vk %p.\n", uav_vk);
1488
1489 /* Take a reference to the device, in case releasing the view's resource
1490 * would cause the device to be destroyed. However, swapchain resources
1491 * don't take a reference to the device, and we wouldn't want to increment
1492 * the refcount on a device that's in the process of being destroyed. */
1493 if (swapchain_count)
1494 wined3d_device_incref(device);
1495 if (uav_vk->v.resource->type == WINED3D_RTYPE_BUFFER)
1496 vk_buffer_view = &view_vk->u.vk_buffer_view;
1497 else
1498 vk_image_view = &view_vk->u.vk_image_info.imageView;
1499 list_remove(&view_vk->bo_user.entry);
1500 wined3d_unordered_access_view_cleanup(&uav_vk->v);
1501 wined3d_view_vk_destroy(device, vk_buffer_view, vk_image_view, &uav_vk->counter_bo,
1502 &uav_vk->vk_counter_view, &view_vk->command_buffer_id, uav_vk);
1503 if (swapchain_count)
1504 wined3d_device_decref(device);
1505 }
1506
1507 static HRESULT adapter_vk_create_sampler(struct wined3d_device *device, const struct wined3d_sampler_desc *desc,
1508 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_sampler **sampler)
1509 {
1510 struct wined3d_sampler_vk *sampler_vk;
1511
1512 TRACE("device %p, desc %p, parent %p, parent_ops %p, sampler %p.\n",
1513 device, desc, parent, parent_ops, sampler);
1514
1515 if (!(sampler_vk = heap_alloc_zero(sizeof(*sampler_vk))))
1516 return E_OUTOFMEMORY;
1517
1518 wined3d_sampler_vk_init(sampler_vk, device, desc, parent, parent_ops);
1519
1520 TRACE("Created sampler %p.\n", sampler_vk);
1521 *sampler = &sampler_vk->s;
1522
1523 return WINED3D_OK;
1524 }
1525
1526 static void wined3d_sampler_vk_destroy_object(void *object)
1527 {
1528 struct wined3d_sampler_vk *sampler_vk = object;
1529 struct wined3d_context_vk *context_vk;
1530
1531 context_vk = wined3d_context_vk(context_acquire(sampler_vk->s.device, NULL, 0));
1532
1533 wined3d_context_vk_destroy_sampler(context_vk, sampler_vk->vk_image_info.sampler, sampler_vk->command_buffer_id);
1534 heap_free(sampler_vk);
1535
1536 context_release(&context_vk->c);
1537 }
1538
1539 static void adapter_vk_destroy_sampler(struct wined3d_sampler *sampler)
1540 {
1541 struct wined3d_sampler_vk *sampler_vk = wined3d_sampler_vk(sampler);
1542
1543 TRACE("sampler_vk %p.\n", sampler_vk);
1544
1545 wined3d_cs_destroy_object(sampler->device->cs, wined3d_sampler_vk_destroy_object, sampler_vk);
1546 }
1547
1548 static HRESULT adapter_vk_create_query(struct wined3d_device *device, enum wined3d_query_type type,
1549 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
1550 {
1551 TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1552 device, type, parent, parent_ops, query);
1553
1554 return wined3d_query_vk_create(device, type, parent, parent_ops, query);
1555 }
1556
1557 static void wined3d_query_vk_destroy_object(void *object)
1558 {
1559 struct wined3d_query_vk *query_vk = object;
1560
1561 query_vk->q.query_ops->query_destroy(&query_vk->q);
1562 }
1563
1564 static void adapter_vk_destroy_query(struct wined3d_query *query)
1565 {
1566 struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1567
1568 TRACE("query_vk %p.\n", query_vk);
1569
1570 wined3d_cs_destroy_object(query->device->cs, wined3d_query_vk_destroy_object, query_vk);
1571 }
1572
1573 static void adapter_vk_flush_context(struct wined3d_context *context)
1574 {
1575 struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
1576
1577 TRACE("context_vk %p.\n", context_vk);
1578
1579 wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL);
1580 }
1581
1582 static void adapter_vk_draw_primitive(struct wined3d_device *device,
1583 const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters)
1584 {
1585 struct wined3d_buffer_vk *indirect_vk = NULL;
1586 const struct wined3d_vk_info *vk_info;
1587 struct wined3d_context_vk *context_vk;
1588 VkCommandBuffer vk_command_buffer;
1589 uint32_t instance_count;
1590 unsigned int i;
1591
1592 TRACE("device %p, state %p, parameters %p.\n", device, state, parameters);
1593
1594 context_vk = wined3d_context_vk(context_acquire(device, NULL, 0));
1595 vk_info = context_vk->vk_info;
1596
1597 if (parameters->indirect)
1598 indirect_vk = wined3d_buffer_vk(parameters->u.indirect.buffer);
1599
1600 if (!(vk_command_buffer = wined3d_context_vk_apply_draw_state(context_vk,
1601 state, indirect_vk, parameters->indexed)))
1602 {
1603 ERR("Failed to apply draw state.\n");
1604 context_release(&context_vk->c);
1605 return;
1606 }
1607
1608 if (context_vk->c.transform_feedback_active)
1609 {
1610 if (!context_vk->vk_so_counter_bo.vk_buffer)
1611 {
1612 struct wined3d_bo_vk *bo = &context_vk->vk_so_counter_bo;
1613
1614 if (!wined3d_context_vk_create_bo(context_vk, ARRAY_SIZE(context_vk->vk_so_counters) * sizeof(uint32_t) * 2,
1615 VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, bo))
1616 ERR("Failed to create counter BO.\n");
1617 for (i = 0; i < ARRAY_SIZE(context_vk->vk_so_counters); ++i)
1618 {
1619 context_vk->vk_so_counters[i] = bo->vk_buffer;
1620 context_vk->vk_so_offsets[i] = bo->buffer_offset + i * sizeof(uint32_t) * 2;
1621 }
1622 }
1623
1624 wined3d_context_vk_reference_bo(context_vk, &context_vk->vk_so_counter_bo);
1625 if (context_vk->c.transform_feedback_paused)
1626 VK_CALL(vkCmdBeginTransformFeedbackEXT(vk_command_buffer, 0, ARRAY_SIZE(context_vk->vk_so_counters),
1627 context_vk->vk_so_counters, context_vk->vk_so_offsets));
1628 else
1629 VK_CALL(vkCmdBeginTransformFeedbackEXT(vk_command_buffer, 0, 0, NULL, NULL));
1630 }
1631
1632 if (parameters->indirect)
1633 {
1634 struct wined3d_bo_vk *bo = &indirect_vk->bo;
1635 uint32_t stride, size;
1636
1637 wined3d_context_vk_reference_bo(context_vk, bo);
1638 size = indirect_vk->b.resource.size - parameters->u.indirect.offset;
1639
1640 if (parameters->indexed)
1641 {
1642 stride = sizeof(VkDrawIndexedIndirectCommand);
1643 VK_CALL(vkCmdDrawIndexedIndirect(vk_command_buffer, bo->vk_buffer,
1644 bo->buffer_offset + parameters->u.indirect.offset, size / stride, stride));
1645 }
1646 else
1647 {
1648 stride = sizeof(VkDrawIndirectCommand);
1649 VK_CALL(vkCmdDrawIndirect(vk_command_buffer, bo->vk_buffer,
1650 bo->buffer_offset + parameters->u.indirect.offset, size / stride, stride));
1651 }
1652 }
1653 else
1654 {
1655 instance_count = parameters->u.direct.instance_count;
1656 if (context_vk->c.instance_count)
1657 instance_count = context_vk->c.instance_count;
1658 if (!instance_count)
1659 instance_count = 1;
1660
1661 if (parameters->indexed)
1662 VK_CALL(vkCmdDrawIndexed(vk_command_buffer, parameters->u.direct.index_count,
1663 instance_count, parameters->u.direct.start_idx, parameters->u.direct.base_vertex_idx,
1664 parameters->u.direct.start_instance));
1665 else
1666 VK_CALL(vkCmdDraw(vk_command_buffer, parameters->u.direct.index_count, instance_count,
1667 parameters->u.direct.start_idx, parameters->u.direct.start_instance));
1668 }
1669
1670 if (context_vk->c.transform_feedback_active)
1671 {
1672 VK_CALL(vkCmdEndTransformFeedbackEXT(vk_command_buffer, 0, ARRAY_SIZE(context_vk->vk_so_counters),
1673 context_vk->vk_so_counters, context_vk->vk_so_offsets));
1674 context_vk->c.transform_feedback_paused = 1;
1675 context_vk->c.transform_feedback_active = 0;
1676 }
1677
1678 context_release(&context_vk->c);
1679 }
1680
1681 static void adapter_vk_dispatch_compute(struct wined3d_device *device,
1682 const struct wined3d_state *state, const struct wined3d_dispatch_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
1689 TRACE("device %p, state %p, parameters %p.\n", device, state, parameters);
1690
1691 context_vk = wined3d_context_vk(context_acquire(device, NULL, 0));
1692 vk_info = context_vk->vk_info;
1693
1694 if (parameters->indirect)
1695 indirect_vk = wined3d_buffer_vk(parameters->u.indirect.buffer);
1696
1697 if (!(vk_command_buffer = wined3d_context_vk_apply_compute_state(context_vk, state, indirect_vk)))
1698 {
1699 ERR("Failed to apply compute state.\n");
1700 context_release(&context_vk->c);
1701 return;
1702 }
1703
1704 if (parameters->indirect)
1705 {
1706 struct wined3d_bo_vk *bo = &indirect_vk->bo;
1707
1708 wined3d_context_vk_reference_bo(context_vk, bo);
1709 VK_CALL(vkCmdDispatchIndirect(vk_command_buffer, bo->vk_buffer,
1710 bo->buffer_offset + parameters->u.indirect.offset));
1711 }
1712 else
1713 {
1714 const struct wined3d_direct_dispatch_parameters *direct = &parameters->u.direct;
1715
1716 VK_CALL(vkCmdDispatch(vk_command_buffer, direct->group_count_x, direct->group_count_y, direct->group_count_z));
1717 }
1718
1719 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
1720 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, 0, 0, NULL, 0, NULL, 0, NULL));
1721
1722 context_release(&context_vk->c);
1723 }
1724
1725 static void adapter_vk_clear_uav(struct wined3d_context *context,
1726 struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value)
1727 {
1728 TRACE("context %p, view %p, clear_value %s.\n", context, view, debug_uvec4(clear_value));
1729
1730 wined3d_unordered_access_view_vk_clear_uint(wined3d_unordered_access_view_vk(view),
1731 clear_value, wined3d_context_vk(context));
1732 }
1733
1734 static const struct wined3d_adapter_ops wined3d_adapter_vk_ops =
1735 {
1736 .adapter_destroy = adapter_vk_destroy,
1737 .adapter_create_device = adapter_vk_create_device,
1738 .adapter_destroy_device = adapter_vk_destroy_device,
1739 .adapter_acquire_context = adapter_vk_acquire_context,
1740 .adapter_release_context = adapter_vk_release_context,
1741 .adapter_get_wined3d_caps = adapter_vk_get_wined3d_caps,
1742 .adapter_check_format = adapter_vk_check_format,
1743 .adapter_init_3d = adapter_vk_init_3d,
1744 .adapter_uninit_3d = adapter_vk_uninit_3d,
1745 .adapter_map_bo_address = adapter_vk_map_bo_address,
1746 .adapter_unmap_bo_address = adapter_vk_unmap_bo_address,
1747 .adapter_copy_bo_address = adapter_vk_copy_bo_address,
1748 .adapter_create_swapchain = adapter_vk_create_swapchain,
1749 .adapter_destroy_swapchain = adapter_vk_destroy_swapchain,
1750 .adapter_create_buffer = adapter_vk_create_buffer,
1751 .adapter_destroy_buffer = adapter_vk_destroy_buffer,
1752 .adapter_create_texture = adapter_vk_create_texture,
1753 .adapter_destroy_texture = adapter_vk_destroy_texture,
1754 .adapter_create_rendertarget_view = adapter_vk_create_rendertarget_view,
1755 .adapter_destroy_rendertarget_view = adapter_vk_destroy_rendertarget_view,
1756 .adapter_create_shader_resource_view = adapter_vk_create_shader_resource_view,
1757 .adapter_destroy_shader_resource_view = adapter_vk_destroy_shader_resource_view,
1758 .adapter_create_unordered_access_view = adapter_vk_create_unordered_access_view,
1759 .adapter_destroy_unordered_access_view = adapter_vk_destroy_unordered_access_view,
1760 .adapter_create_sampler = adapter_vk_create_sampler,
1761 .adapter_destroy_sampler = adapter_vk_destroy_sampler,
1762 .adapter_create_query = adapter_vk_create_query,
1763 .adapter_destroy_query = adapter_vk_destroy_query,
1764 .adapter_flush_context = adapter_vk_flush_context,
1765 .adapter_draw_primitive = adapter_vk_draw_primitive,
1766 .adapter_dispatch_compute = adapter_vk_dispatch_compute,
1767 .adapter_clear_uav = adapter_vk_clear_uav,
1768 };
1769
1770 static unsigned int wined3d_get_wine_vk_version(void)
1771 {
1772 const char *ptr = PACKAGE_VERSION;
1773 int major, minor;
1774
1775 major = atoi(ptr);
1776
1777 while (isdigit(*ptr))
1778 ++ptr;
1779 if (*ptr == '.')
1780 ++ptr;
1781
1782 minor = atoi(ptr);
1783
1784 return VK_MAKE_VERSION(major, minor, 0);
1785 }
1786
1787 static const struct
1788 {
1789 const char *name;
1790 unsigned int core_since_version;
1791 BOOL required;
1792 }
1793 vulkan_instance_extensions[] =
1794 {
1795 {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_API_VERSION_1_1, FALSE},
1796 {VK_KHR_SURFACE_EXTENSION_NAME, ~0u, TRUE},
1797 {VK_KHR_WIN32_SURFACE_EXTENSION_NAME, ~0u, TRUE},
1798 };
1799
1800 static BOOL enable_vulkan_instance_extensions(uint32_t *extension_count,
1801 const char *enabled_extensions[], const struct wined3d_vk_info *vk_info)
1802 {
1803 PFN_vkEnumerateInstanceExtensionProperties pfn_vkEnumerateInstanceExtensionProperties;
1804 VkExtensionProperties *extensions = NULL;
1805 BOOL success = FALSE, found;
1806 unsigned int i, j, count;
1807 VkResult vr;
1808
1809 *extension_count = 0;
1810
1811 if (!(pfn_vkEnumerateInstanceExtensionProperties
1812 = (void *)VK_CALL(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties"))))
1813 {
1814 WARN("Failed to get 'vkEnumerateInstanceExtensionProperties'.\n");
1815 goto done;
1816 }
1817
1818 if ((vr = pfn_vkEnumerateInstanceExtensionProperties(NULL, &count, NULL)) < 0)
1819 {
1820 WARN("Failed to count instance extensions, vr %s.\n", wined3d_debug_vkresult(vr));
1821 goto done;
1822 }
1823 if (!(extensions = heap_calloc(count, sizeof(*extensions))))
1824 {
1825 WARN("Out of memory.\n");
1826 goto done;
1827 }
1828 if ((vr = pfn_vkEnumerateInstanceExtensionProperties(NULL, &count, extensions)) < 0)
1829 {
1830 WARN("Failed to enumerate extensions, vr %s.\n", wined3d_debug_vkresult(vr));
1831 goto done;
1832 }
1833
1834 for (i = 0; i < ARRAY_SIZE(vulkan_instance_extensions); ++i)
1835 {
1836 if (vulkan_instance_extensions[i].core_since_version <= vk_info->api_version)
1837 continue;
1838
1839 for (j = 0, found = FALSE; j < count; ++j)
1840 {
1841 if (!strcmp(extensions[j].extensionName, vulkan_instance_extensions[i].name))
1842 {
1843 found = TRUE;
1844 break;
1845 }
1846 }
1847 if (found)
1848 {
1849 TRACE("Enabling instance extension '%s'.\n", vulkan_instance_extensions[i].name);
1850 enabled_extensions[(*extension_count)++] = vulkan_instance_extensions[i].name;
1851 }
1852 else if (!found && vulkan_instance_extensions[i].required)
1853 {
1854 WARN("Required extension '%s' is not available.\n", vulkan_instance_extensions[i].name);
1855 goto done;
1856 }
1857 }
1858 success = TRUE;
1859
1860 done:
1861 heap_free(extensions);
1862 return success;
1863 }
1864
1865 static BOOL wined3d_init_vulkan(struct wined3d_vk_info *vk_info)
1866 {
1867 const char *enabled_instance_extensions[ARRAY_SIZE(vulkan_instance_extensions)];
1868 PFN_vkEnumerateInstanceVersion pfn_vkEnumerateInstanceVersion;
1869 struct vulkan_ops *vk_ops = &vk_info->vk_ops;
1870 VkInstance instance = VK_NULL_HANDLE;
1871 VkInstanceCreateInfo instance_info;
1872 VkApplicationInfo app_info;
1873 uint32_t api_version = 0;
1874 char app_name[MAX_PATH];
1875 VkResult vr;
1876
1877 if (!wined3d_load_vulkan(vk_info))
1878 return FALSE;
1879
1880 if (!(vk_ops->vkCreateInstance = (void *)VK_CALL(vkGetInstanceProcAddr(NULL, "vkCreateInstance"))))
1881 {
1882 ERR("Failed to get 'vkCreateInstance'.\n");
1883 goto fail;
1884 }
1885
1886 vk_info->api_version = VK_API_VERSION_1_0;
1887 if ((pfn_vkEnumerateInstanceVersion = (void *)VK_CALL(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion")))
1888 && pfn_vkEnumerateInstanceVersion(&api_version) == VK_SUCCESS)
1889 {
1890 TRACE("Vulkan instance API version %s.\n", debug_vk_version(api_version));
1891
1892 if (api_version >= VK_API_VERSION_1_1)
1893 vk_info->api_version = VK_API_VERSION_1_1;
1894 }
1895
1896 memset(&app_info, 0, sizeof(app_info));
1897 app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
1898 if (wined3d_get_app_name(app_name, ARRAY_SIZE(app_name)))
1899 app_info.pApplicationName = app_name;
1900 app_info.pEngineName = "Damavand";
1901 app_info.engineVersion = wined3d_get_wine_vk_version();
1902 app_info.apiVersion = vk_info->api_version;
1903
1904 memset(&instance_info, 0, sizeof(instance_info));
1905 instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
1906 instance_info.pApplicationInfo = &app_info;
1907 instance_info.ppEnabledExtensionNames = enabled_instance_extensions;
1908 if (!enable_vulkan_instance_extensions(&instance_info.enabledExtensionCount, enabled_instance_extensions, vk_info))
1909 goto fail;
1910
1911 memset(vk_info->supported, 0, sizeof(vk_info->supported));
1912 vk_info->supported[WINED3D_VK_EXT_NONE] = TRUE;
1913
1914 if ((vr = VK_CALL(vkCreateInstance(&instance_info, NULL, &instance))) < 0)
1915 {
1916 WARN("Failed to create Vulkan instance, vr %s.\n", wined3d_debug_vkresult(vr));
1917 goto fail;
1918 }
1919
1920 TRACE("Created Vulkan instance %p.\n", instance);
1921
1922 #define LOAD_INSTANCE_PFN(name) \
1923 if (!(vk_ops->name = (void *)VK_CALL(vkGetInstanceProcAddr(instance, #name)))) \
1924 { \
1925 WARN("Could not get instance proc addr for '" #name "'.\n"); \
1926 goto fail; \
1927 }
1928 #define LOAD_INSTANCE_OPT_PFN(name) \
1929 vk_ops->name = (void *)VK_CALL(vkGetInstanceProcAddr(instance, #name));
1930 #define VK_INSTANCE_PFN LOAD_INSTANCE_PFN
1931 #define VK_INSTANCE_EXT_PFN LOAD_INSTANCE_OPT_PFN
1932 #define VK_DEVICE_PFN LOAD_INSTANCE_PFN
1933 #define VK_DEVICE_EXT_PFN LOAD_INSTANCE_OPT_PFN
1934 VK_INSTANCE_FUNCS()
1935 VK_DEVICE_FUNCS()
1936 #undef VK_INSTANCE_PFN
1937 #undef VK_INSTANCE_EXT_PFN
1938 #undef VK_DEVICE_PFN
1939 #undef VK_DEVICE_EXT_PFN
1940
1941 #define MAP_INSTANCE_FUNCTION(core_pfn, ext_pfn) \
1942 if (!vk_ops->core_pfn) \
1943 vk_ops->core_pfn = (void *)VK_CALL(vkGetInstanceProcAddr(instance, #ext_pfn));
1944 MAP_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties2, vkGetPhysicalDeviceProperties2KHR)
1945 MAP_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures2, vkGetPhysicalDeviceFeatures2KHR)
1946 #undef MAP_INSTANCE_FUNCTION
1947
1948 vk_info->instance = instance;
1949
1950 return TRUE;
1951
1952 fail:
1953 if (vk_ops->vkDestroyInstance)
1954 VK_CALL(vkDestroyInstance(instance, NULL));
1955 wined3d_unload_vulkan(vk_info);
1956 return FALSE;
1957 }
1958
1959 static VkPhysicalDevice get_vulkan_physical_device(struct wined3d_vk_info *vk_info)
1960 {
1961 VkPhysicalDevice physical_devices[1];
1962 uint32_t count;
1963 VkResult vr;
1964
1965 if ((vr = VK_CALL(vkEnumeratePhysicalDevices(vk_info->instance, &count, NULL))) < 0)
1966 {
1967 WARN("Failed to enumerate physical devices, vr %s.\n", wined3d_debug_vkresult(vr));
1968 return VK_NULL_HANDLE;
1969 }
1970 if (!count)
1971 {
1972 WARN("No physical device.\n");
1973 return VK_NULL_HANDLE;
1974 }
1975 if (count > 1)
1976 {
1977 /* TODO: Create wined3d_adapter for each device. */
1978 FIXME("Multiple physical devices available.\n");
1979 count = 1;
1980 }
1981
1982 if ((vr = VK_CALL(vkEnumeratePhysicalDevices(vk_info->instance, &count, physical_devices))) < 0)
1983 {
1984 WARN("Failed to get physical devices, vr %s.\n", wined3d_debug_vkresult(vr));
1985 return VK_NULL_HANDLE;
1986 }
1987
1988 return physical_devices[0];
1989 }
1990
1991 static enum wined3d_display_driver guess_display_driver(enum wined3d_pci_vendor vendor)
1992 {
1993 switch (vendor)
1994 {
1995 case HW_VENDOR_AMD: return DRIVER_AMD_RX;
1996 case HW_VENDOR_INTEL: return DRIVER_INTEL_HD4000;
1997 case HW_VENDOR_NVIDIA: return DRIVER_NVIDIA_GEFORCE8;
1998 default: return DRIVER_WINE;
1999 }
2000 }
2001
2002 static bool adapter_vk_init_driver_info(struct wined3d_adapter_vk *adapter_vk,
2003 const VkPhysicalDeviceProperties *properties)
2004 {
2005 const VkPhysicalDeviceMemoryProperties *memory_properties = &adapter_vk->memory_properties;
2006 const struct wined3d_gpu_description *gpu_description;
2007 struct wined3d_gpu_description description;
2008 UINT64 vram_bytes, sysmem_bytes;
2009 const VkMemoryHeap *heap;
2010 unsigned int i;
2011
2012 TRACE("Device name: %s.\n", debugstr_a(properties->deviceName));
2013 TRACE("Vendor ID: 0x%04x, Device ID: 0x%04x.\n", properties->vendorID, properties->deviceID);
2014 TRACE("Driver version: %#x.\n", properties->driverVersion);
2015 TRACE("API version: %s.\n", debug_vk_version(properties->apiVersion));
2016
2017 for (i = 0, vram_bytes = 0, sysmem_bytes = 0; i < memory_properties->memoryHeapCount; ++i)
2018 {
2019 heap = &memory_properties->memoryHeaps[i];
2020 TRACE("Memory heap [%u]: flags %#x, size 0x%s.\n",
2021 i, heap->flags, wine_dbgstr_longlong(heap->size));
2022 if (heap->flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
2023 vram_bytes += heap->size;
2024 else
2025 sysmem_bytes += heap->size;
2026 }
2027 TRACE("Total device memory: 0x%s.\n", wine_dbgstr_longlong(vram_bytes));
2028 TRACE("Total shared system memory: 0x%s.\n", wine_dbgstr_longlong(sysmem_bytes));
2029
2030 if (!(gpu_description = wined3d_get_user_override_gpu_description(properties->vendorID, properties->deviceID)))
2031 gpu_description = wined3d_get_gpu_description(properties->vendorID, properties->deviceID);
2032
2033 if (!gpu_description)
2034 {
2035 FIXME("Failed to retrieve GPU description for device %s %04x:%04x.\n",
2036 debugstr_a(properties->deviceName), properties->vendorID, properties->deviceID);
2037
2038 description.vendor = properties->vendorID;
2039 description.device = properties->deviceID;
2040 description.description = properties->deviceName;
2041 description.driver = guess_display_driver(properties->vendorID);
2042 description.vidmem = vram_bytes;
2043
2044 gpu_description = &description;
2045 }
2046
2047 return wined3d_driver_info_init(&adapter_vk->a.driver_info, gpu_description,
2048 adapter_vk->a.d3d_info.feature_level, vram_bytes, sysmem_bytes);
2049 }
2050
2051 static enum wined3d_feature_level feature_level_from_caps(const struct shader_caps *shader_caps)
2052 {
2053 unsigned int shader_model;
2054
2055 shader_model = min(shader_caps->vs_version, shader_caps->ps_version);
2056 shader_model = min(shader_model, max(shader_caps->gs_version, 3));
2057 shader_model = min(shader_model, max(shader_caps->hs_version, 4));
2058 shader_model = min(shader_model, max(shader_caps->ds_version, 4));
2059
2060 if (shader_model >= 5)
2061 return WINED3D_FEATURE_LEVEL_11_1;
2062
2063 if (shader_model >= 4)
2064 return WINED3D_FEATURE_LEVEL_10_1;
2065
2066 return WINED3D_FEATURE_LEVEL_NONE;
2067 }
2068
2069 static void wined3d_adapter_vk_init_d3d_info(struct wined3d_adapter_vk *adapter_vk, uint32_t wined3d_creation_flags)
2070 {
2071 struct wined3d_d3d_info *d3d_info = &adapter_vk->a.d3d_info;
2072 struct wined3d_vertex_caps vertex_caps;
2073 struct fragment_caps fragment_caps;
2074 struct shader_caps shader_caps;
2075
2076 adapter_vk->a.shader_backend->shader_get_caps(&adapter_vk->a, &shader_caps);
2077 adapter_vk->a.vertex_pipe->vp_get_caps(&adapter_vk->a, &vertex_caps);
2078 adapter_vk->a.fragment_pipe->get_caps(&adapter_vk->a, &fragment_caps);
2079
2080 d3d_info->limits.vs_version = shader_caps.vs_version;
2081 d3d_info->limits.hs_version = shader_caps.hs_version;
2082 d3d_info->limits.ds_version = shader_caps.ds_version;
2083 d3d_info->limits.gs_version = shader_caps.gs_version;
2084 d3d_info->limits.ps_version = shader_caps.ps_version;
2085 d3d_info->limits.cs_version = shader_caps.cs_version;
2086 d3d_info->limits.vs_uniform_count = shader_caps.vs_uniform_count;
2087 d3d_info->limits.ps_uniform_count = shader_caps.ps_uniform_count;
2088 d3d_info->limits.varying_count = shader_caps.varying_count;
2089 d3d_info->limits.ffp_textures = fragment_caps.MaxSimultaneousTextures;
2090 d3d_info->limits.ffp_blend_stages = fragment_caps.MaxTextureBlendStages;
2091 d3d_info->limits.ffp_vertex_blend_matrices = vertex_caps.max_vertex_blend_matrices;
2092 d3d_info->limits.active_light_count = vertex_caps.max_active_lights;
2093
2094 d3d_info->limits.max_rt_count = WINED3D_MAX_RENDER_TARGETS;
2095 d3d_info->limits.max_clip_distances = WINED3D_MAX_CLIP_DISTANCES;
2096 d3d_info->limits.texture_size = adapter_vk->device_limits.maxImageDimension2D;
2097 d3d_info->limits.pointsize_max = adapter_vk->device_limits.pointSizeRange[1];
2098
2099 d3d_info->wined3d_creation_flags = wined3d_creation_flags;
2100
2101 d3d_info->xyzrhw = vertex_caps.xyzrhw;
2102 d3d_info->emulated_flatshading = vertex_caps.emulated_flatshading;
2103 d3d_info->ffp_generic_attributes = vertex_caps.ffp_generic_attributes;
2104 d3d_info->ffp_alpha_test = false;
2105 d3d_info->vs_clipping = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_VS_CLIPPING);
2106 d3d_info->shader_color_key = !!(fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_COLOR_KEY);
2107 d3d_info->shader_double_precision = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION);
2108 d3d_info->shader_output_interpolation = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_OUTPUT_INTERPOLATION);
2109 d3d_info->viewport_array_index_any_shader = false; /* VK_EXT_shader_viewport_index_layer */
2110 d3d_info->texture_npot = true;
2111 d3d_info->texture_npot_conditional = true;
2112 d3d_info->draw_base_vertex_offset = true;
2113 d3d_info->vertex_bgra = true;
2114 d3d_info->texture_swizzle = true;
2115 d3d_info->srgb_read_control = false;
2116 d3d_info->srgb_write_control = false;
2117 d3d_info->clip_control = true;
2118 d3d_info->full_ffp_varyings = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_FULL_FFP_VARYINGS);
2119 d3d_info->scaled_resolve = false;
2120 d3d_info->feature_level = feature_level_from_caps(&shader_caps);
2121
2122 d3d_info->multisample_draw_location = WINED3D_LOCATION_TEXTURE_RGB;
2123 }
2124
2125 static bool wined3d_adapter_vk_init_device_extensions(struct wined3d_adapter_vk *adapter_vk)
2126 {
2127 VkPhysicalDevice physical_device = adapter_vk->physical_device;
2128 struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
2129 unsigned int count, enable_count, i, j;
2130 const char **enabled_extensions = NULL;
2131 VkExtensionProperties *extensions;
2132 bool found, success = false;
2133 SIZE_T enable_size = 0;
2134 VkResult vr;
2135
2136 static const struct
2137 {
2138 const char *name;
2139 unsigned int core_since_version;
2140 bool required;
2141 }
2142 info[] =
2143 {
2144 {VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, ~0u},
2145 {VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, ~0u, true},
2146 {VK_KHR_MAINTENANCE1_EXTENSION_NAME, VK_API_VERSION_1_1, true},
2147 {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_API_VERSION_1_1, true},
2148 {VK_KHR_SWAPCHAIN_EXTENSION_NAME, ~0u, true},
2149 };
2150
2151 static const struct
2152 {
2153 const char *name;
2154 enum wined3d_vk_extension extension;
2155 }
2156 map[] =
2157 {
2158 {VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, WINED3D_VK_EXT_TRANSFORM_FEEDBACK},
2159 };
2160
2161 if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL))) < 0)
2162 {
2163 ERR("Failed to enumerate device extensions, vr %s.\n", wined3d_debug_vkresult(vr));
2164 return false;
2165 }
2166
2167 if (!(extensions = heap_calloc(count, sizeof(*extensions))))
2168 {
2169 ERR("Failed to allocate extension properties array.\n");
2170 return false;
2171 }
2172
2173 if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, extensions))) < 0)
2174 {
2175 ERR("Failed to enumerate device extensions, vr %s.\n", wined3d_debug_vkresult(vr));
2176 goto done;
2177 }
2178
2179 for (i = 0, enable_count = 0; i < ARRAY_SIZE(info); ++i)
2180 {
2181 if (info[i].core_since_version <= vk_info->api_version)
2182 continue;
2183
2184 for (j = 0, found = false; j < count; ++j)
2185 {
2186 if (!strcmp(extensions[j].extensionName, info[i].name))
2187 {
2188 found = true;
2189 break;
2190 }
2191 }
2192
2193 if (!found)
2194 {
2195 if (!info[i].required)
2196 continue;
2197 WARN("Required extension '%s' is not available.\n", info[i].name);
2198 goto done;
2199 }
2200
2201 TRACE("Enabling device extension '%s'.\n", info[i].name);
2202 if (!wined3d_array_reserve((void **)&enabled_extensions, &enable_size,
2203 enable_count + 1, sizeof(*enabled_extensions)))
2204 {
2205 ERR("Failed to allocate enabled extensions array.\n");
2206 goto done;
2207 }
2208 enabled_extensions[enable_count++] = info[i].name;
2209 }
2210 success = true;
2211
2212 for (i = 0; i < ARRAY_SIZE(map); ++i)
2213 {
2214 for (j = 0; j < enable_count; ++j)
2215 {
2216 if (!strcmp(enabled_extensions[j], map[i].name))
2217 {
2218 vk_info->supported[map[i].extension] = TRUE;
2219 break;
2220 }
2221 }
2222 }
2223
2224 done:
2225 if (success)
2226 {
2227 adapter_vk->device_extension_count = enable_count;
2228 adapter_vk->device_extensions = enabled_extensions;
2229 }
2230 else
2231 {
2232 heap_free(enabled_extensions);
2233 }
2234 heap_free(extensions);
2235 return success;
2236 }
2237
2238 static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk,
2239 unsigned int ordinal, unsigned int wined3d_creation_flags)
2240 {
2241 struct wined3d_vk_info *vk_info = &adapter_vk->vk_info;
2242 struct wined3d_adapter *adapter = &adapter_vk->a;
2243 VkPhysicalDeviceIDProperties id_properties;
2244 VkPhysicalDeviceProperties2 properties2;
2245 LUID primary_luid, *luid = NULL;
2246
2247 TRACE("adapter_vk %p, ordinal %u, wined3d_creation_flags %#x.\n",
2248 adapter_vk, ordinal, wined3d_creation_flags);
2249
2250 if (!wined3d_init_vulkan(vk_info))
2251 {
2252 WARN("Failed to initialize Vulkan.\n");
2253 return FALSE;
2254 }
2255
2256 if (!(adapter_vk->physical_device = get_vulkan_physical_device(vk_info)))
2257 goto fail_vulkan;
2258
2259 if (!wined3d_adapter_vk_init_device_extensions(adapter_vk))
2260 goto fail_vulkan;
2261
2262 memset(&id_properties, 0, sizeof(id_properties));
2263 id_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
2264 properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
2265 properties2.pNext = &id_properties;
2266
2267 if (vk_info->vk_ops.vkGetPhysicalDeviceProperties2)
2268 VK_CALL(vkGetPhysicalDeviceProperties2(adapter_vk->physical_device, &properties2));
2269 else
2270 VK_CALL(vkGetPhysicalDeviceProperties(adapter_vk->physical_device, &properties2.properties));
2271 adapter_vk->device_limits = properties2.properties.limits;
2272
2273 VK_CALL(vkGetPhysicalDeviceMemoryProperties(adapter_vk->physical_device, &adapter_vk->memory_properties));
2274
2275 if (id_properties.deviceLUIDValid)
2276 luid = (LUID *)id_properties.deviceLUID;
2277 else if (ordinal == 0 && wined3d_get_primary_adapter_luid(&primary_luid))
2278 luid = &primary_luid;
2279
2280 if (!wined3d_adapter_init(adapter, ordinal, luid, &wined3d_adapter_vk_ops))
2281 {
2282 heap_free(adapter_vk->device_extensions);
2283 goto fail_vulkan;
2284 }
2285
2286 adapter->vertex_pipe = wined3d_spirv_vertex_pipe_init_vk();
2287 adapter->fragment_pipe = wined3d_spirv_fragment_pipe_init_vk();
2288 adapter->misc_state_template = misc_state_template_vk;
2289 adapter->shader_backend = wined3d_spirv_shader_backend_init_vk();
2290
2291 wined3d_adapter_vk_init_d3d_info(adapter_vk, wined3d_creation_flags);
2292
2293 if (!adapter_vk_init_driver_info(adapter_vk, &properties2.properties))
2294 goto fail;
2295 TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n",
2296 adapter_vk->a.driver_info.version_high, adapter_vk->a.driver_info.version_low);
2297 adapter->vram_bytes_used = 0;
2298 TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->driver_info.vram_bytes));
2299
2300 memcpy(&adapter->driver_uuid, id_properties.driverUUID, sizeof(adapter->driver_uuid));
2301 memcpy(&adapter->device_uuid, id_properties.deviceUUID, sizeof(adapter->device_uuid));
2302
2303 if (!wined3d_adapter_vk_init_format_info(adapter_vk, vk_info))
2304 goto fail;
2305
2306 return TRUE;
2307
2308 fail:
2309 wined3d_adapter_cleanup(adapter);
2310 heap_free(adapter_vk->device_extensions);
2311 fail_vulkan:
2312 VK_CALL(vkDestroyInstance(vk_info->instance, NULL));
2313 wined3d_unload_vulkan(vk_info);
2314 return FALSE;
2315 }
2316
2317 struct wined3d_adapter *wined3d_adapter_vk_create(unsigned int ordinal,
2318 unsigned int wined3d_creation_flags)
2319 {
2320 struct wined3d_adapter_vk *adapter_vk;
2321
2322 if (!(adapter_vk = heap_alloc_zero(sizeof(*adapter_vk))))
2323 return NULL;
2324
2325 if (!wined3d_adapter_vk_init(adapter_vk, ordinal, wined3d_creation_flags))
2326 {
2327 heap_free(adapter_vk);
2328 return NULL;
2329 }
2330
2331 TRACE("Created adapter %p.\n", adapter_vk);
2332
2333 return &adapter_vk->a;
2334 }
Windows API implementation