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