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