?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Remove BO users from the list when invalidating them.
[wine.git] / dlls / wined3d / view.c
blob755fd5b2648794e548c41795850680f41b8a7922
1 /*
2 * Copyright 2009, 2011 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
20 #include "wined3d_private.h"
21 #include "wined3d_shaders.h"
22 #include "wined3d_vk.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
25
26 #define WINED3D_VIEW_CUBE_ARRAY (WINED3D_VIEW_TEXTURE_CUBE | WINED3D_VIEW_TEXTURE_ARRAY)
27
28 static BOOL is_stencil_view_format(const struct wined3d_format *format)
29 {
30 return format->id == WINED3DFMT_X24_TYPELESS_G8_UINT
31 || format->id == WINED3DFMT_X32_TYPELESS_G8X24_UINT;
32 }
33
34 static GLenum get_texture_view_target(const struct wined3d_gl_info *gl_info,
35 const struct wined3d_view_desc *desc, const struct wined3d_texture_gl *texture_gl)
36 {
37 static const struct
38 {
39 GLenum texture_target;
40 unsigned int view_flags;
41 GLenum view_target;
42 enum wined3d_gl_extension extension;
43 }
44 view_types[] =
45 {
46 {GL_TEXTURE_CUBE_MAP, 0, GL_TEXTURE_CUBE_MAP},
47 {GL_TEXTURE_RECTANGLE, 0, GL_TEXTURE_RECTANGLE},
48 {GL_TEXTURE_3D, 0, GL_TEXTURE_3D},
49
50 {GL_TEXTURE_2D, 0, GL_TEXTURE_2D},
51 {GL_TEXTURE_2D, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
52 {GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_2D},
53 {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
54 {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_CUBE, GL_TEXTURE_CUBE_MAP},
55 {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_CUBE_ARRAY, GL_TEXTURE_CUBE_MAP_ARRAY, ARB_TEXTURE_CUBE_MAP_ARRAY},
56
57 {GL_TEXTURE_2D_MULTISAMPLE, 0, GL_TEXTURE_2D_MULTISAMPLE},
58 {GL_TEXTURE_2D_MULTISAMPLE, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_MULTISAMPLE_ARRAY},
59 {GL_TEXTURE_2D_MULTISAMPLE_ARRAY, 0, GL_TEXTURE_2D_MULTISAMPLE},
60 {GL_TEXTURE_2D_MULTISAMPLE_ARRAY, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_MULTISAMPLE_ARRAY},
61
62 {GL_TEXTURE_1D, 0, GL_TEXTURE_1D},
63 {GL_TEXTURE_1D, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_1D_ARRAY},
64 {GL_TEXTURE_1D_ARRAY, 0, GL_TEXTURE_1D},
65 {GL_TEXTURE_1D_ARRAY, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_1D_ARRAY},
66 };
67 unsigned int flags = desc->flags & (WINED3D_VIEW_BUFFER_RAW | WINED3D_VIEW_BUFFER_APPEND
68 | WINED3D_VIEW_BUFFER_COUNTER | WINED3D_VIEW_TEXTURE_CUBE | WINED3D_VIEW_TEXTURE_ARRAY);
69 unsigned int i;
70
71 for (i = 0; i < ARRAY_SIZE(view_types); ++i)
72 {
73 if (view_types[i].texture_target != texture_gl->target || view_types[i].view_flags != flags)
74 continue;
75 if (gl_info->supported[view_types[i].extension])
76 return view_types[i].view_target;
77
78 FIXME("Extension %#x not supported.\n", view_types[i].extension);
79 }
80
81 FIXME("Unhandled view flags %#x for texture target %#x.\n", flags, texture_gl->target);
82 return texture_gl->target;
83 }
84
85 static const struct wined3d_format *validate_resource_view(const struct wined3d_view_desc *desc,
86 struct wined3d_resource *resource, BOOL mip_slice, BOOL allow_srgb_toggle)
87 {
88 const struct wined3d_adapter *adapter = resource->device->adapter;
89 const struct wined3d_format *format;
90
91 format = wined3d_get_format(adapter, desc->format_id, resource->bind_flags);
92 if (resource->type == WINED3D_RTYPE_BUFFER && (desc->flags & WINED3D_VIEW_BUFFER_RAW))
93 {
94 if (format->id != WINED3DFMT_R32_TYPELESS)
95 {
96 WARN("Invalid format %s for raw buffer view.\n", debug_d3dformat(format->id));
97 return NULL;
98 }
99
100 format = wined3d_get_format(adapter, WINED3DFMT_R32_UINT, resource->bind_flags);
101 }
102
103 if (wined3d_format_is_typeless(format))
104 {
105 WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(format->id));
106 return NULL;
107 }
108
109 if (resource->type == WINED3D_RTYPE_BUFFER)
110 {
111 struct wined3d_buffer *buffer = buffer_from_resource(resource);
112 unsigned int buffer_size, element_size;
113
114 if (buffer->structure_byte_stride)
115 {
116 if (desc->format_id != WINED3DFMT_UNKNOWN)
117 {
118 WARN("Invalid format %s for structured buffer view.\n", debug_d3dformat(desc->format_id));
119 return NULL;
120 }
121
122 format = wined3d_get_format(adapter, WINED3DFMT_R32_UINT, resource->bind_flags);
123 element_size = buffer->structure_byte_stride;
124 }
125 else
126 {
127 element_size = format->byte_count;
128 }
129
130 if (!element_size)
131 return NULL;
132
133 buffer_size = buffer->resource.size / element_size;
134 if (!wined3d_bound_range(desc->u.buffer.start_idx, desc->u.buffer.count, buffer_size))
135 return NULL;
136 }
137 else
138 {
139 struct wined3d_texture *texture = texture_from_resource(resource);
140 unsigned int depth_or_layer_count;
141
142 if (resource->format->id != format->id && !wined3d_format_is_typeless(resource->format)
143 && (!allow_srgb_toggle || !wined3d_formats_are_srgb_variants(resource->format->id, format->id)))
144 {
145 WARN("Trying to create incompatible view for non typeless format %s.\n",
146 debug_d3dformat(format->id));
147 return NULL;
148 }
149
150 if (mip_slice && resource->type == WINED3D_RTYPE_TEXTURE_3D)
151 depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
152 else
153 depth_or_layer_count = texture->layer_count;
154
155 if (!desc->u.texture.level_count
156 || (mip_slice && desc->u.texture.level_count != 1)
157 || !wined3d_bound_range(desc->u.texture.level_idx, desc->u.texture.level_count, texture->level_count)
158 || !desc->u.texture.layer_count
159 || !wined3d_bound_range(desc->u.texture.layer_idx, desc->u.texture.layer_count, depth_or_layer_count))
160 return NULL;
161 }
162
163 return format;
164 }
165
166 static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target,
167 const struct wined3d_view_desc *desc, struct wined3d_texture_gl *texture_gl,
168 const struct wined3d_format *view_format)
169 {
170 const struct wined3d_format_gl *view_format_gl;
171 unsigned int level_idx, layer_idx, layer_count;
172 const struct wined3d_gl_info *gl_info;
173 struct wined3d_context_gl *context_gl;
174 struct wined3d_context *context;
175 GLuint texture_name;
176
177 view_format_gl = wined3d_format_gl(view_format);
178 view->target = view_target;
179
180 context = context_acquire(texture_gl->t.resource.device, NULL, 0);
181 context_gl = wined3d_context_gl(context);
182 gl_info = context_gl->gl_info;
183
184 if (!gl_info->supported[ARB_TEXTURE_VIEW])
185 {
186 context_release(context);
187 FIXME("OpenGL implementation does not support texture views.\n");
188 return;
189 }
190
191 wined3d_texture_gl_prepare_texture(texture_gl, context_gl, FALSE);
192 texture_name = wined3d_texture_gl_get_texture_name(texture_gl, context, FALSE);
193
194 level_idx = desc->u.texture.level_idx;
195 layer_idx = desc->u.texture.layer_idx;
196 layer_count = desc->u.texture.layer_count;
197 if (view_target == GL_TEXTURE_3D)
198 {
199 if (layer_idx || layer_count != wined3d_texture_get_level_depth(&texture_gl->t, level_idx))
200 FIXME("Depth slice (%u-%u) not supported.\n", layer_idx, layer_count);
201 layer_idx = 0;
202 layer_count = 1;
203 }
204
205 gl_info->gl_ops.gl.p_glGenTextures(1, &view->name);
206 GL_EXTCALL(glTextureView(view->name, view->target, texture_name, view_format_gl->internal,
207 level_idx, desc->u.texture.level_count, layer_idx, layer_count));
208 checkGLcall("create texture view");
209
210 if (is_stencil_view_format(view_format))
211 {
212 static const GLint swizzle[] = {GL_ZERO, GL_RED, GL_ZERO, GL_ZERO};
213
214 if (!gl_info->supported[ARB_STENCIL_TEXTURING])
215 {
216 context_release(context);
217 FIXME("OpenGL implementation does not support stencil texturing.\n");
218 return;
219 }
220
221 wined3d_context_gl_bind_texture(context_gl, view->target, view->name);
222 gl_info->gl_ops.gl.p_glTexParameteriv(view->target, GL_TEXTURE_SWIZZLE_RGBA, swizzle);
223 gl_info->gl_ops.gl.p_glTexParameteri(view->target, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
224 checkGLcall("initialize stencil view");
225
226 context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
227 context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
228 }
229 else if (!is_identity_fixup(view_format->color_fixup) && can_use_texture_swizzle(context->d3d_info, view_format))
230 {
231 GLint swizzle[4];
232
233 wined3d_context_gl_bind_texture(context_gl, view->target, view->name);
234 wined3d_gl_texture_swizzle_from_color_fixup(swizzle, view_format->color_fixup);
235 gl_info->gl_ops.gl.p_glTexParameteriv(view->target, GL_TEXTURE_SWIZZLE_RGBA, swizzle);
236 checkGLcall("set format swizzle");
237
238 context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
239 context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
240 }
241
242 context_release(context);
243 }
244
245 static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_context_gl *context_gl,
246 struct wined3d_buffer *buffer, const struct wined3d_format_gl *view_format_gl,
247 unsigned int offset, unsigned int size)
248 {
249 const struct wined3d_gl_info *gl_info = context_gl->gl_info;
250 const struct wined3d_bo_gl *bo_gl;
251
252 if (!gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
253 {
254 FIXME("OpenGL implementation does not support buffer textures.\n");
255 return;
256 }
257
258 wined3d_buffer_load_location(buffer, &context_gl->c, WINED3D_LOCATION_BUFFER);
259 bo_gl = wined3d_bo_gl(buffer->buffer_object);
260 offset += bo_gl->b.buffer_offset;
261
262 if ((offset & (gl_info->limits.texture_buffer_offset_alignment - 1)))
263 {
264 FIXME("Buffer offset %u is not %u byte aligned.\n",
265 offset, gl_info->limits.texture_buffer_offset_alignment);
266 return;
267 }
268
269 view->target = GL_TEXTURE_BUFFER;
270 if (!view->name)
271 gl_info->gl_ops.gl.p_glGenTextures(1, &view->name);
272
273 wined3d_context_gl_bind_texture(context_gl, GL_TEXTURE_BUFFER, view->name);
274 if (gl_info->supported[ARB_TEXTURE_BUFFER_RANGE])
275 {
276 GL_EXTCALL(glTexBufferRange(GL_TEXTURE_BUFFER, view_format_gl->internal, bo_gl->id, offset, size));
277 }
278 else
279 {
280 if (offset || size != buffer->resource.size)
281 FIXME("OpenGL implementation does not support ARB_texture_buffer_range.\n");
282 GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, view_format_gl->internal, bo_gl->id));
283 }
284 checkGLcall("Create buffer texture");
285
286 context_invalidate_compute_state(&context_gl->c, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
287 context_invalidate_state(&context_gl->c, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
288 }
289
290 static void get_buffer_view_range(const struct wined3d_buffer *buffer,
291 const struct wined3d_view_desc *desc, const struct wined3d_format *view_format,
292 unsigned int *offset, unsigned int *size)
293 {
294 if (desc->format_id == WINED3DFMT_UNKNOWN)
295 {
296 *offset = desc->u.buffer.start_idx * buffer->structure_byte_stride;
297 *size = desc->u.buffer.count * buffer->structure_byte_stride;
298 }
299 else
300 {
301 *offset = desc->u.buffer.start_idx * view_format->byte_count;
302 *size = desc->u.buffer.count * view_format->byte_count;
303 }
304 }
305
306 static void create_buffer_view(struct wined3d_gl_view *view, struct wined3d_context *context,
307 const struct wined3d_view_desc *desc, struct wined3d_buffer *buffer,
308 const struct wined3d_format *view_format)
309 {
310 unsigned int offset, size;
311
312 get_buffer_view_range(buffer, desc, view_format, &offset, &size);
313 create_buffer_texture(view, wined3d_context_gl(context), buffer, wined3d_format_gl(view_format), offset, size);
314 }
315
316 static void wined3d_view_invalidate_location(struct wined3d_resource *resource,
317 const struct wined3d_view_desc *desc, DWORD location)
318 {
319 unsigned int i, sub_resource_idx;
320 struct wined3d_texture *texture;
321
322 if (resource->type == WINED3D_RTYPE_BUFFER)
323 {
324 wined3d_buffer_invalidate_location(buffer_from_resource(resource), location);
325 return;
326 }
327
328 texture = texture_from_resource(resource);
329 if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
330 {
331 wined3d_texture_invalidate_location(texture, desc->u.texture.level_idx, location);
332 return;
333 }
334
335 sub_resource_idx = desc->u.texture.layer_idx * texture->level_count + desc->u.texture.level_idx;
336 for (i = 0; i < desc->u.texture.layer_count; ++i, sub_resource_idx += texture->level_count)
337 wined3d_texture_invalidate_location(texture, sub_resource_idx, location);
338 }
339
340 static void wined3d_view_load_location(struct wined3d_resource *resource,
341 const struct wined3d_view_desc *desc, struct wined3d_context *context, DWORD location)
342 {
343 unsigned int i, sub_resource_idx;
344 struct wined3d_texture *texture;
345
346 if (resource->type == WINED3D_RTYPE_BUFFER)
347 {
348 wined3d_buffer_load_location(buffer_from_resource(resource), context, location);
349 return;
350 }
351
352 texture = texture_from_resource(resource);
353 if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
354 {
355 wined3d_texture_load_location(texture, desc->u.texture.level_idx, context, location);
356 return;
357 }
358
359 sub_resource_idx = desc->u.texture.layer_idx * texture->level_count + desc->u.texture.level_idx;
360 for (i = 0; i < desc->u.texture.layer_count; ++i, sub_resource_idx += texture->level_count)
361 wined3d_texture_load_location(texture, sub_resource_idx, context, location);
362 }
363
364 ULONG CDECL wined3d_rendertarget_view_incref(struct wined3d_rendertarget_view *view)
365 {
366 unsigned int refcount = InterlockedIncrement(&view->refcount);
367
368 TRACE("%p increasing refcount to %u.\n", view, refcount);
369
370 return refcount;
371 }
372
373 void wined3d_rendertarget_view_cleanup(struct wined3d_rendertarget_view *view)
374 {
375 /* Call wined3d_object_destroyed() before releasing the resource,
376 * since releasing the resource may end up destroying the parent. */
377 view->parent_ops->wined3d_object_destroyed(view->parent);
378 wined3d_resource_decref(view->resource);
379 }
380
381 ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *view)
382 {
383 unsigned int refcount = InterlockedDecrement(&view->refcount);
384
385 TRACE("%p decreasing refcount to %u.\n", view, refcount);
386
387 if (!refcount)
388 {
389 wined3d_mutex_lock();
390 view->resource->device->adapter->adapter_ops->adapter_destroy_rendertarget_view(view);
391 wined3d_mutex_unlock();
392 }
393
394 return refcount;
395 }
396
397 void * CDECL wined3d_rendertarget_view_get_parent(const struct wined3d_rendertarget_view *view)
398 {
399 TRACE("view %p.\n", view);
400
401 return view->parent;
402 }
403
404 void * CDECL wined3d_rendertarget_view_get_sub_resource_parent(const struct wined3d_rendertarget_view *view)
405 {
406 struct wined3d_texture *texture;
407
408 TRACE("view %p.\n", view);
409
410 if (view->resource->type == WINED3D_RTYPE_BUFFER)
411 return wined3d_buffer_get_parent(buffer_from_resource(view->resource));
412
413 texture = texture_from_resource(view->resource);
414
415 return texture->sub_resources[view->sub_resource_idx].parent;
416 }
417
418 void CDECL wined3d_rendertarget_view_set_parent(struct wined3d_rendertarget_view *view,
419 void *parent, const struct wined3d_parent_ops *parent_ops)
420 {
421 TRACE("view %p, parent %p, parent_ops %p.\n", view, parent, parent_ops);
422
423 view->parent = parent;
424 view->parent_ops = parent_ops;
425 }
426
427 struct wined3d_resource * CDECL wined3d_rendertarget_view_get_resource(const struct wined3d_rendertarget_view *view)
428 {
429 TRACE("view %p.\n", view);
430
431 return view->resource;
432 }
433
434 void wined3d_rendertarget_view_get_drawable_size(const struct wined3d_rendertarget_view *view,
435 const struct wined3d_context *context, unsigned int *width, unsigned int *height)
436 {
437 const struct wined3d_texture *texture;
438
439 if (view->resource->type != WINED3D_RTYPE_TEXTURE_2D)
440 {
441 *width = view->width;
442 *height = view->height;
443 return;
444 }
445
446 texture = texture_from_resource(view->resource);
447 if (texture->swapchain)
448 {
449 /* The drawable size of an onscreen drawable is the surface size.
450 * (Actually: The window size, but the surface is created in window
451 * size.) */
452 *width = texture->resource.width;
453 *height = texture->resource.height;
454 }
455 else if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
456 {
457 const struct wined3d_swapchain_desc *desc = &context->swapchain->state.desc;
458
459 /* The drawable size of a backbuffer / aux buffer offscreen target is
460 * the size of the current context's drawable, which is the size of
461 * the back buffer of the swapchain the active context belongs to. */
462 *width = desc->backbuffer_width;
463 *height = desc->backbuffer_height;
464 }
465 else
466 {
467 unsigned int level_idx = view->sub_resource_idx % texture->level_count;
468
469 /* The drawable size of an FBO target is the OpenGL texture size,
470 * which is the power of two size. */
471 *width = wined3d_texture_get_level_pow2_width(texture, level_idx);
472 *height = wined3d_texture_get_level_pow2_height(texture, level_idx);
473 }
474 }
475
476 void wined3d_rendertarget_view_prepare_location(struct wined3d_rendertarget_view *view,
477 struct wined3d_context *context, uint32_t location)
478 {
479 struct wined3d_resource *resource = view->resource;
480 unsigned int i, sub_resource_idx, layer_count;
481 struct wined3d_texture *texture;
482
483 if (resource->type == WINED3D_RTYPE_BUFFER)
484 {
485 FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
486 return;
487 }
488
489 texture = texture_from_resource(resource);
490 sub_resource_idx = view->sub_resource_idx;
491 layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
492 for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
493 wined3d_texture_prepare_location(texture, sub_resource_idx, context, location);
494 }
495
496 void wined3d_rendertarget_view_load_location(struct wined3d_rendertarget_view *view,
497 struct wined3d_context *context, uint32_t location)
498 {
499 wined3d_view_load_location(view->resource, &view->desc, context, location);
500 }
501
502 void wined3d_rendertarget_view_validate_location(struct wined3d_rendertarget_view *view, uint32_t location)
503 {
504 struct wined3d_resource *resource = view->resource;
505 unsigned int i, sub_resource_idx, layer_count;
506 struct wined3d_texture *texture;
507
508 if (resource->type == WINED3D_RTYPE_BUFFER)
509 {
510 FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
511 return;
512 }
513
514 texture = texture_from_resource(resource);
515 sub_resource_idx = view->sub_resource_idx;
516 layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
517 for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
518 wined3d_texture_validate_location(texture, sub_resource_idx, location);
519 }
520
521 void wined3d_rendertarget_view_invalidate_location(struct wined3d_rendertarget_view *view, uint32_t location)
522 {
523 wined3d_view_invalidate_location(view->resource, &view->desc, location);
524 }
525
526 /* Note: This may return 0 if the selected layers do not have a location in common. */
527 DWORD wined3d_rendertarget_view_get_locations(const struct wined3d_rendertarget_view *view)
528 {
529 struct wined3d_resource *resource = view->resource;
530 unsigned int i, sub_resource_idx, layer_count;
531 const struct wined3d_texture *texture;
532 DWORD ret = ~0u;
533
534 if (resource->type == WINED3D_RTYPE_BUFFER)
535 return buffer_from_resource(resource)->locations;
536
537 texture = texture_from_resource(resource);
538 sub_resource_idx = view->sub_resource_idx;
539 layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
540 for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
541 ret &= texture->sub_resources[sub_resource_idx].locations;
542
543 if (!ret)
544 WARN("View %p (texture %p) layers do not have a location in common.\n", view, texture);
545
546 return ret;
547 }
548
549 void wined3d_rendertarget_view_get_box(struct wined3d_rendertarget_view *view,
550 struct wined3d_box *box)
551 {
552 if (view->resource->type != WINED3D_RTYPE_TEXTURE_3D)
553 {
554 wined3d_box_set(box, 0, 0, view->width, view->height, 0, 1);
555 }
556 else
557 {
558 struct wined3d_texture *texture = texture_from_resource(view->resource);
559 wined3d_texture_get_level_box(texture, view->sub_resource_idx, box);
560 }
561 }
562
563 static void wined3d_render_target_view_gl_cs_init(void *object)
564 {
565 struct wined3d_rendertarget_view_gl *view_gl = object;
566 struct wined3d_resource *resource = view_gl->v.resource;
567 const struct wined3d_view_desc *desc = &view_gl->v.desc;
568
569 TRACE("view_gl %p.\n", view_gl);
570
571 if (resource->type == WINED3D_RTYPE_BUFFER)
572 {
573 FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
574 }
575 else
576 {
577 struct wined3d_texture_gl *texture_gl = wined3d_texture_gl(texture_from_resource(resource));
578 unsigned int depth_or_layer_count;
579
580 if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
581 depth_or_layer_count = wined3d_texture_get_level_depth(&texture_gl->t, desc->u.texture.level_idx);
582 else
583 depth_or_layer_count = texture_gl->t.layer_count;
584
585 if (resource->format->id != view_gl->v.format->id
586 || (view_gl->v.layer_count != 1 && view_gl->v.layer_count != depth_or_layer_count))
587 {
588 GLenum resource_class, view_class;
589
590 resource_class = wined3d_format_gl(resource->format)->view_class;
591 view_class = wined3d_format_gl(view_gl->v.format)->view_class;
592 if (resource_class != view_class)
593 {
594 FIXME("Render target view not supported, resource format %s, view format %s.\n",
595 debug_d3dformat(resource->format->id), debug_d3dformat(view_gl->v.format->id));
596 return;
597 }
598 if (texture_gl->t.swapchain && texture_gl->t.swapchain->state.desc.backbuffer_count > 1)
599 {
600 FIXME("Swapchain views not supported.\n");
601 return;
602 }
603
604 create_texture_view(&view_gl->gl_view, texture_gl->target, desc, texture_gl, view_gl->v.format);
605 }
606 }
607 }
608
609 static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view,
610 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
611 void *parent, const struct wined3d_parent_ops *parent_ops)
612 {
613 BOOL allow_srgb_toggle = FALSE;
614
615 view->refcount = 1;
616 view->parent = parent;
617 view->parent_ops = parent_ops;
618
619 if (resource->type != WINED3D_RTYPE_BUFFER)
620 {
621 struct wined3d_texture *texture = texture_from_resource(resource);
622
623 if (texture->swapchain)
624 allow_srgb_toggle = TRUE;
625 }
626 if (!(view->format = validate_resource_view(desc, resource, TRUE, allow_srgb_toggle)))
627 return E_INVALIDARG;
628 view->format_attrs = view->format->attrs;
629 view->format_caps = view->format->caps[resource->gl_type];
630 view->desc = *desc;
631
632 if (resource->type == WINED3D_RTYPE_BUFFER)
633 {
634 view->sub_resource_idx = 0;
635 view->layer_count = 1;
636 view->width = desc->u.buffer.count;
637 view->height = 1;
638 }
639 else
640 {
641 struct wined3d_texture *texture = texture_from_resource(resource);
642
643 view->sub_resource_idx = desc->u.texture.level_idx;
644 if (resource->type != WINED3D_RTYPE_TEXTURE_3D)
645 view->sub_resource_idx += desc->u.texture.layer_idx * texture->level_count;
646 view->layer_count = desc->u.texture.layer_count;
647 view->width = wined3d_texture_get_level_width(texture, desc->u.texture.level_idx);
648 view->height = wined3d_texture_get_level_height(texture, desc->u.texture.level_idx);
649 }
650
651 wined3d_resource_incref(view->resource = resource);
652
653 return WINED3D_OK;
654 }
655
656 HRESULT wined3d_rendertarget_view_no3d_init(struct wined3d_rendertarget_view *view_no3d,
657 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
658 void *parent, const struct wined3d_parent_ops *parent_ops)
659 {
660 TRACE("view_no3d %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
661 view_no3d, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
662
663 return wined3d_rendertarget_view_init(view_no3d, desc, resource, parent, parent_ops);
664 }
665
666 HRESULT wined3d_rendertarget_view_gl_init(struct wined3d_rendertarget_view_gl *view_gl,
667 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
668 void *parent, const struct wined3d_parent_ops *parent_ops)
669 {
670 HRESULT hr;
671
672 TRACE("view_gl %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
673 view_gl, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
674
675 if (FAILED(hr = wined3d_rendertarget_view_init(&view_gl->v, desc, resource, parent, parent_ops)))
676 return hr;
677
678 wined3d_cs_init_object(resource->device->cs, wined3d_render_target_view_gl_cs_init, view_gl);
679
680 return hr;
681 }
682
683 VkImageViewType vk_image_view_type_from_wined3d(enum wined3d_resource_type type, uint32_t flags)
684 {
685 switch (type)
686 {
687 case WINED3D_RTYPE_TEXTURE_1D:
688 if (flags & WINED3D_VIEW_TEXTURE_ARRAY)
689 return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
690 else
691 return VK_IMAGE_VIEW_TYPE_1D;
692
693 case WINED3D_RTYPE_TEXTURE_2D:
694 if (flags & WINED3D_VIEW_TEXTURE_CUBE)
695 {
696 if (flags & WINED3D_VIEW_TEXTURE_ARRAY)
697 return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
698 else
699 return VK_IMAGE_VIEW_TYPE_CUBE;
700 }
701 if (flags & WINED3D_VIEW_TEXTURE_ARRAY)
702 return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
703 else
704 return VK_IMAGE_VIEW_TYPE_2D;
705
706 case WINED3D_RTYPE_TEXTURE_3D:
707 return VK_IMAGE_VIEW_TYPE_3D;
708
709 default:
710 ERR("Unhandled resource type %s.\n", debug_d3dresourcetype(type));
711 return ~0u;
712 }
713 }
714
715 static VkBufferView wined3d_view_vk_create_vk_buffer_view(struct wined3d_context_vk *context_vk,
716 const struct wined3d_view_desc *desc, struct wined3d_buffer_vk *buffer_vk,
717 const struct wined3d_format_vk *view_format_vk)
718 {
719 const struct wined3d_vk_info *vk_info = context_vk->vk_info;
720 VkBufferViewCreateInfo create_info;
721 struct wined3d_device_vk *device_vk;
722 VkBufferView vk_buffer_view;
723 unsigned int offset, size;
724 struct wined3d_bo_vk *bo;
725 VkResult vr;
726
727 get_buffer_view_range(&buffer_vk->b, desc, &view_format_vk->f, &offset, &size);
728 wined3d_buffer_prepare_location(&buffer_vk->b, &context_vk->c, WINED3D_LOCATION_BUFFER);
729 bo = wined3d_bo_vk(buffer_vk->b.buffer_object);
730
731 create_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
732 create_info.pNext = NULL;
733 create_info.flags = 0;
734 create_info.buffer = bo->vk_buffer;
735 create_info.format = view_format_vk->vk_format;
736 create_info.offset = bo->b.buffer_offset + offset;
737 create_info.range = size;
738
739 device_vk = wined3d_device_vk(buffer_vk->b.resource.device);
740 if ((vr = VK_CALL(vkCreateBufferView(device_vk->vk_device, &create_info, NULL, &vk_buffer_view))) < 0)
741 {
742 ERR("Failed to create buffer view, vr %s.\n", wined3d_debug_vkresult(vr));
743 return VK_NULL_HANDLE;
744 }
745
746 return vk_buffer_view;
747 }
748
749 static VkImageView wined3d_view_vk_create_vk_image_view(struct wined3d_context_vk *context_vk,
750 const struct wined3d_view_desc *desc, struct wined3d_texture_vk *texture_vk,
751 const struct wined3d_format_vk *view_format_vk, struct color_fixup_desc fixup, bool rtv)
752 {
753 const struct wined3d_resource *resource = &texture_vk->t.resource;
754 const struct wined3d_vk_info *vk_info = context_vk->vk_info;
755 const struct wined3d_format_vk *format_vk;
756 struct wined3d_device_vk *device_vk;
757 VkImageViewCreateInfo create_info;
758 VkImageView vk_image_view;
759 VkResult vr;
760
761 device_vk = wined3d_device_vk(resource->device);
762
763 if (!wined3d_texture_vk_prepare_texture(texture_vk, context_vk))
764 {
765 ERR("Failed to prepare texture.\n");
766 return VK_NULL_HANDLE;
767 }
768
769 /* Depth formats are a little complicated. For example, the typeless
770 * format corresponding to depth/stencil view format WINED3DFMT_D32_FLOAT
771 * is WINED3DFMT_R32_TYPELESS, and the corresponding shader resource view
772 * format would be WINED3DFMT_R32_FLOAT. Vulkan depth/stencil formats are
773 * only compatible with themselves, so it's not possible to create e.g. a
774 * VK_FORMAT_R32_SFLOAT view on a VK_FORMAT_D32_SFLOAT image. In order to
775 * make it work, we create Vulkan images for WINED3DFMT_R32_TYPELESS
776 * resources with either a depth format (VK_FORMAT_D32_SFLOAT) or a colour
777 * format, depending on whether the bind flags include
778 * WINED3D_BIND_DEPTH_STENCIL or not. In order to then create a Vulkan
779 * view on the image, we then replace the view format here with the
780 * underlying resource format. However, that means it's still not possible
781 * to create e.g. a WINED3DFMT_R32_UINT view on a WINED3DFMT_R32_TYPELESS
782 * depth/stencil resource. */
783 if (resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL)
784 format_vk = wined3d_format_vk(resource->format);
785 else
786 format_vk = view_format_vk;
787
788 create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
789 create_info.pNext = NULL;
790 create_info.flags = 0;
791 create_info.image = texture_vk->image.vk_image;
792 create_info.viewType = vk_image_view_type_from_wined3d(resource->type, desc->flags);
793 if (rtv && create_info.viewType == VK_IMAGE_VIEW_TYPE_3D)
794 {
795 if (desc->u.texture.layer_count > 1)
796 create_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
797 else
798 create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
799 }
800 create_info.format = format_vk->vk_format;
801 if (is_stencil_view_format(&view_format_vk->f))
802 {
803 create_info.components.r = VK_COMPONENT_SWIZZLE_ZERO;
804 create_info.components.g = VK_COMPONENT_SWIZZLE_R;
805 create_info.components.b = VK_COMPONENT_SWIZZLE_ZERO;
806 create_info.components.a = VK_COMPONENT_SWIZZLE_ZERO;
807 }
808 else if (is_identity_fixup(fixup) || !can_use_texture_swizzle(context_vk->c.d3d_info, &format_vk->f))
809 {
810 create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
811 create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
812 create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
813 create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
814 }
815 else
816 {
817 wined3d_vk_swizzle_from_color_fixup(&create_info.components, fixup);
818 }
819 if ((resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL)
820 && (view_format_vk->f.red_size || view_format_vk->f.green_size))
821 {
822 create_info.subresourceRange.aspectMask = 0;
823 if (view_format_vk->f.red_size)
824 create_info.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_DEPTH_BIT;
825 if (view_format_vk->f.green_size)
826 create_info.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
827 }
828 else
829 {
830 create_info.subresourceRange.aspectMask = vk_aspect_mask_from_format(&format_vk->f);
831 }
832 create_info.subresourceRange.baseMipLevel = desc->u.texture.level_idx;
833 create_info.subresourceRange.levelCount = desc->u.texture.level_count;
834 if (create_info.viewType == VK_IMAGE_VIEW_TYPE_3D)
835 {
836 if (desc->u.texture.layer_idx || (desc->u.texture.layer_count != texture_vk->t.resource.depth
837 && desc->u.texture.layer_count != ~0u))
838 WARN("Partial 3D texture views are not supported.\n");
839 create_info.subresourceRange.baseArrayLayer = 0;
840 create_info.subresourceRange.layerCount = 1;
841 }
842 else
843 {
844 create_info.subresourceRange.baseArrayLayer = desc->u.texture.layer_idx;
845 create_info.subresourceRange.layerCount = desc->u.texture.layer_count;
846 }
847 if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &create_info, NULL, &vk_image_view))) < 0)
848 {
849 ERR("Failed to create Vulkan image view, vr %s.\n", wined3d_debug_vkresult(vr));
850 return VK_NULL_HANDLE;
851 }
852
853 return vk_image_view;
854 }
855
856 static void wined3d_render_target_view_vk_cs_init(void *object)
857 {
858 struct wined3d_rendertarget_view_vk *view_vk = object;
859 struct wined3d_view_desc *desc = &view_vk->v.desc;
860 const struct wined3d_format_vk *format_vk;
861 struct wined3d_texture_vk *texture_vk;
862 struct wined3d_resource *resource;
863 struct wined3d_context *context;
864 uint32_t default_flags = 0;
865
866 TRACE("view_vk %p.\n", view_vk);
867
868 resource = view_vk->v.resource;
869 if (resource->type == WINED3D_RTYPE_BUFFER)
870 {
871 FIXME("Buffer views not implemented.\n");
872 return;
873 }
874
875 texture_vk = wined3d_texture_vk(texture_from_resource(resource));
876 format_vk = wined3d_format_vk(view_vk->v.format);
877
878 if (texture_vk->t.layer_count > 1)
879 default_flags |= WINED3D_VIEW_TEXTURE_ARRAY;
880
881 if (resource->format->id == format_vk->f.id && desc->flags == default_flags
882 && !desc->u.texture.level_idx && desc->u.texture.level_count == texture_vk->t.level_count
883 && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture_vk->t.layer_count
884 && !is_stencil_view_format(&format_vk->f) && resource->type != WINED3D_RTYPE_TEXTURE_3D
885 && is_identity_fixup(format_vk->f.color_fixup))
886 {
887 TRACE("Creating identity render target view.\n");
888 return;
889 }
890
891 if (texture_vk->t.swapchain && texture_vk->t.swapchain->state.desc.backbuffer_count > 1)
892 {
893 FIXME("Swapchain views not supported.\n");
894 return;
895 }
896
897 context = context_acquire(resource->device, NULL, 0);
898 view_vk->vk_image_view = wined3d_view_vk_create_vk_image_view(wined3d_context_vk(context),
899 desc, texture_vk, format_vk, COLOR_FIXUP_IDENTITY, true);
900 context_release(context);
901
902 if (!view_vk->vk_image_view)
903 return;
904
905 TRACE("Created image view 0x%s.\n", wine_dbgstr_longlong(view_vk->vk_image_view));
906 }
907
908 HRESULT wined3d_rendertarget_view_vk_init(struct wined3d_rendertarget_view_vk *view_vk,
909 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
910 void *parent, const struct wined3d_parent_ops *parent_ops)
911 {
912 HRESULT hr;
913
914 TRACE("view_vk %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
915 view_vk, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
916
917 if (FAILED(hr = wined3d_rendertarget_view_init(&view_vk->v, desc, resource, parent, parent_ops)))
918 return hr;
919
920 wined3d_cs_init_object(resource->device->cs, wined3d_render_target_view_vk_cs_init, view_vk);
921
922 return hr;
923 }
924
925 HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_view_desc *desc,
926 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
927 struct wined3d_rendertarget_view **view)
928 {
929 const struct wined3d_adapter_ops *adapter_ops;
930
931 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
932 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
933
934 adapter_ops = resource->device->adapter->adapter_ops;
935 return adapter_ops->adapter_create_rendertarget_view(desc, resource, parent, parent_ops, view);
936 }
937
938 HRESULT CDECL wined3d_rendertarget_view_create_from_sub_resource(struct wined3d_texture *texture,
939 unsigned int sub_resource_idx, void *parent, const struct wined3d_parent_ops *parent_ops,
940 struct wined3d_rendertarget_view **view)
941 {
942 struct wined3d_view_desc desc;
943
944 TRACE("texture %p, sub_resource_idx %u, parent %p, parent_ops %p, view %p.\n",
945 texture, sub_resource_idx, parent, parent_ops, view);
946
947 desc.format_id = texture->resource.format->id;
948 desc.flags = 0;
949 desc.u.texture.level_idx = sub_resource_idx % texture->level_count;
950 desc.u.texture.level_count = 1;
951 desc.u.texture.layer_idx = sub_resource_idx / texture->level_count;
952 desc.u.texture.layer_count = 1;
953
954 return wined3d_rendertarget_view_create(&desc, &texture->resource, parent, parent_ops, view);
955 }
956
957 ULONG CDECL wined3d_shader_resource_view_incref(struct wined3d_shader_resource_view *view)
958 {
959 unsigned int refcount = InterlockedIncrement(&view->refcount);
960
961 TRACE("%p increasing refcount to %u.\n", view, refcount);
962
963 return refcount;
964 }
965
966 void wined3d_shader_resource_view_cleanup(struct wined3d_shader_resource_view *view)
967 {
968 /* Call wined3d_object_destroyed() before releasing the resource,
969 * since releasing the resource may end up destroying the parent. */
970 view->parent_ops->wined3d_object_destroyed(view->parent);
971 wined3d_resource_decref(view->resource);
972 }
973
974 ULONG CDECL wined3d_shader_resource_view_decref(struct wined3d_shader_resource_view *view)
975 {
976 unsigned int refcount = InterlockedDecrement(&view->refcount);
977
978 TRACE("%p decreasing refcount to %u.\n", view, refcount);
979
980 if (!refcount)
981 {
982 wined3d_mutex_lock();
983 view->resource->device->adapter->adapter_ops->adapter_destroy_shader_resource_view(view);
984 wined3d_mutex_unlock();
985 }
986
987 return refcount;
988 }
989
990 void * CDECL wined3d_shader_resource_view_get_parent(const struct wined3d_shader_resource_view *view)
991 {
992 TRACE("view %p.\n", view);
993
994 return view->parent;
995 }
996
997 void wined3d_shader_resource_view_gl_update(struct wined3d_shader_resource_view_gl *srv_gl,
998 struct wined3d_context_gl *context_gl)
999 {
1000 struct wined3d_buffer *buffer = buffer_from_resource(srv_gl->v.resource);
1001
1002 assert(!srv_gl->bo_user.valid);
1003
1004 create_buffer_view(&srv_gl->gl_view, &context_gl->c, &srv_gl->v.desc, buffer, srv_gl->v.format);
1005 srv_gl->bo_user.valid = true;
1006 list_add_head(&buffer->buffer_object->users, &srv_gl->bo_user.entry);
1007 }
1008
1009 static void wined3d_shader_resource_view_gl_cs_init(void *object)
1010 {
1011 struct wined3d_shader_resource_view_gl *view_gl = object;
1012 struct wined3d_resource *resource = view_gl->v.resource;
1013 const struct wined3d_format *view_format;
1014 const struct wined3d_gl_info *gl_info;
1015 const struct wined3d_view_desc *desc;
1016 GLenum view_target;
1017
1018 TRACE("view_gl %p.\n", view_gl);
1019
1020 view_format = view_gl->v.format;
1021 gl_info = &wined3d_adapter_gl(resource->device->adapter)->gl_info;
1022 desc = &view_gl->v.desc;
1023
1024 if (resource->type == WINED3D_RTYPE_BUFFER)
1025 {
1026 struct wined3d_buffer *buffer = buffer_from_resource(resource);
1027 struct wined3d_context *context;
1028
1029 context = context_acquire(resource->device, NULL, 0);
1030 create_buffer_view(&view_gl->gl_view, context, desc, buffer, view_format);
1031 view_gl->bo_user.valid = true;
1032 list_add_head(&buffer->buffer_object->users, &view_gl->bo_user.entry);
1033 context_release(context);
1034 }
1035 else
1036 {
1037 struct wined3d_texture_gl *texture_gl = wined3d_texture_gl(texture_from_resource(resource));
1038 GLenum resource_class, view_class;
1039
1040 resource_class = wined3d_format_gl(resource->format)->view_class;
1041 view_class = wined3d_format_gl(view_format)->view_class;
1042 view_target = get_texture_view_target(gl_info, desc, texture_gl);
1043
1044 if (resource->format->id == view_format->id && texture_gl->target == view_target
1045 && !desc->u.texture.level_idx && desc->u.texture.level_count == texture_gl->t.level_count
1046 && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture_gl->t.layer_count
1047 && !is_stencil_view_format(view_format))
1048 {
1049 TRACE("Creating identity shader resource view.\n");
1050 }
1051 else if (texture_gl->t.swapchain && texture_gl->t.swapchain->state.desc.backbuffer_count > 1)
1052 {
1053 FIXME("Swapchain shader resource views not supported.\n");
1054 }
1055 else if (resource->format->typeless_id == view_format->typeless_id
1056 && resource_class == view_class)
1057 {
1058 create_texture_view(&view_gl->gl_view, view_target, desc, texture_gl, view_format);
1059 }
1060 else if (wined3d_format_is_depth_view(resource->format->id, view_format->id))
1061 {
1062 create_texture_view(&view_gl->gl_view, view_target, desc, texture_gl, resource->format);
1063 }
1064 else
1065 {
1066 FIXME("Shader resource view not supported, resource format %s, view format %s.\n",
1067 debug_d3dformat(resource->format->id), debug_d3dformat(view_format->id));
1068 }
1069 }
1070 }
1071
1072 static HRESULT wined3d_shader_resource_view_init(struct wined3d_shader_resource_view *view,
1073 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
1074 void *parent, const struct wined3d_parent_ops *parent_ops)
1075 {
1076 view->refcount = 1;
1077 view->parent = parent;
1078 view->parent_ops = parent_ops;
1079
1080 if (!(resource->bind_flags & WINED3D_BIND_SHADER_RESOURCE))
1081 return E_INVALIDARG;
1082 if (!(view->format = validate_resource_view(desc, resource, FALSE, FALSE)))
1083 return E_INVALIDARG;
1084 view->desc = *desc;
1085
1086 wined3d_resource_incref(view->resource = resource);
1087
1088 return WINED3D_OK;
1089 }
1090
1091 HRESULT wined3d_shader_resource_view_gl_init(struct wined3d_shader_resource_view_gl *view_gl,
1092 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
1093 void *parent, const struct wined3d_parent_ops *parent_ops)
1094 {
1095 HRESULT hr;
1096
1097 TRACE("view_gl %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
1098 view_gl, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
1099
1100 if (FAILED(hr = wined3d_shader_resource_view_init(&view_gl->v, desc, resource, parent, parent_ops)))
1101 return hr;
1102
1103 list_init(&view_gl->bo_user.entry);
1104 wined3d_cs_init_object(resource->device->cs, wined3d_shader_resource_view_gl_cs_init, view_gl);
1105
1106 return hr;
1107 }
1108
1109 void wined3d_shader_resource_view_vk_update_buffer(struct wined3d_shader_resource_view_vk *srv_vk,
1110 struct wined3d_context_vk *context_vk)
1111 {
1112 const struct wined3d_format_vk *view_format_vk = wined3d_format_vk(srv_vk->v.format);
1113 const struct wined3d_view_desc *desc = &srv_vk->v.desc;
1114 struct wined3d_resource *resource = srv_vk->v.resource;
1115 struct wined3d_view_vk *view_vk = &srv_vk->view_vk;
1116 struct wined3d_buffer_vk *buffer_vk;
1117 VkBufferView vk_buffer_view;
1118
1119 assert(!view_vk->bo_user.valid);
1120
1121 buffer_vk = wined3d_buffer_vk(buffer_from_resource(resource));
1122 wined3d_context_vk_destroy_vk_buffer_view(context_vk, view_vk->u.vk_buffer_view, view_vk->command_buffer_id);
1123 if ((vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(context_vk, desc, buffer_vk, view_format_vk)))
1124 {
1125 view_vk->u.vk_buffer_view = vk_buffer_view;
1126 view_vk->bo_user.valid = true;
1127 list_add_head(&buffer_vk->b.buffer_object->users, &view_vk->bo_user.entry);
1128 }
1129 }
1130
1131 void wined3d_shader_resource_view_vk_update_layout(struct wined3d_shader_resource_view_vk *srv_vk,
1132 VkImageLayout layout)
1133 {
1134 srv_vk->view_vk.u.vk_image_info.imageLayout = layout;
1135 }
1136
1137 static void wined3d_shader_resource_view_vk_cs_init(void *object)
1138 {
1139 struct wined3d_shader_resource_view_vk *srv_vk = object;
1140 struct wined3d_view_desc *desc = &srv_vk->v.desc;
1141 struct wined3d_texture_vk *texture_vk;
1142 const struct wined3d_format *format;
1143 struct wined3d_buffer_vk *buffer_vk;
1144 struct wined3d_resource *resource;
1145 struct wined3d_context *context;
1146 VkBufferView vk_buffer_view;
1147 uint32_t default_flags = 0;
1148 VkImageView vk_image_view;
1149 struct wined3d_bo_vk *bo;
1150
1151 TRACE("srv_vk %p.\n", srv_vk);
1152
1153 resource = srv_vk->v.resource;
1154 format = srv_vk->v.format;
1155
1156 if (resource->type == WINED3D_RTYPE_BUFFER)
1157 {
1158 buffer_vk = wined3d_buffer_vk(buffer_from_resource(resource));
1159
1160 context = context_acquire(resource->device, NULL, 0);
1161 vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(wined3d_context_vk(context),
1162 desc, buffer_vk, wined3d_format_vk(format));
1163 context_release(context);
1164
1165 if (!vk_buffer_view)
1166 return;
1167 bo = wined3d_bo_vk(buffer_vk->b.buffer_object);
1168
1169 TRACE("Created buffer view 0x%s.\n", wine_dbgstr_longlong(vk_buffer_view));
1170
1171 srv_vk->view_vk.u.vk_buffer_view = vk_buffer_view;
1172 srv_vk->view_vk.bo_user.valid = true;
1173 list_add_head(&bo->b.users, &srv_vk->view_vk.bo_user.entry);
1174
1175 return;
1176 }
1177
1178 texture_vk = wined3d_texture_vk(texture_from_resource(resource));
1179
1180 if (texture_vk->t.layer_count > 1)
1181 default_flags |= WINED3D_VIEW_TEXTURE_ARRAY;
1182
1183 if (resource->format->id == format->id && desc->flags == default_flags
1184 && !desc->u.texture.level_idx && desc->u.texture.level_count == texture_vk->t.level_count
1185 && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture_vk->t.layer_count
1186 && !(resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL))
1187 {
1188 TRACE("Creating identity shader resource view.\n");
1189 return;
1190 }
1191
1192 if (texture_vk->t.swapchain && texture_vk->t.swapchain->state.desc.backbuffer_count > 1)
1193 FIXME("Swapchain shader resource views not supported.\n");
1194
1195 context = context_acquire(resource->device, NULL, 0);
1196 vk_image_view = wined3d_view_vk_create_vk_image_view(wined3d_context_vk(context),
1197 desc, texture_vk, wined3d_format_vk(format), format->color_fixup, false);
1198 context_release(context);
1199
1200 if (!vk_image_view)
1201 return;
1202
1203 TRACE("Created image view 0x%s.\n", wine_dbgstr_longlong(vk_image_view));
1204
1205 srv_vk->view_vk.u.vk_image_info.imageView = vk_image_view;
1206 srv_vk->view_vk.u.vk_image_info.sampler = VK_NULL_HANDLE;
1207 if (texture_vk->layout == VK_IMAGE_LAYOUT_GENERAL)
1208 srv_vk->view_vk.u.vk_image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
1209 else
1210 srv_vk->view_vk.u.vk_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
1211 }
1212
1213 HRESULT wined3d_shader_resource_view_vk_init(struct wined3d_shader_resource_view_vk *view_vk,
1214 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
1215 void *parent, const struct wined3d_parent_ops *parent_ops)
1216 {
1217 HRESULT hr;
1218
1219 TRACE("view_vk %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
1220 view_vk, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
1221
1222 if (FAILED(hr = wined3d_shader_resource_view_init(&view_vk->v, desc, resource, parent, parent_ops)))
1223 return hr;
1224
1225 list_init(&view_vk->view_vk.bo_user.entry);
1226 wined3d_cs_init_object(resource->device->cs, wined3d_shader_resource_view_vk_cs_init, view_vk);
1227
1228 return hr;
1229 }
1230
1231 HRESULT CDECL wined3d_shader_resource_view_create(const struct wined3d_view_desc *desc,
1232 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1233 struct wined3d_shader_resource_view **view)
1234 {
1235 const struct wined3d_adapter_ops *adapter_ops;
1236
1237 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
1238 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
1239
1240 adapter_ops = resource->device->adapter->adapter_ops;
1241 return adapter_ops->adapter_create_shader_resource_view(desc, resource, parent, parent_ops, view);
1242 }
1243
1244 void wined3d_shader_resource_view_gl_bind(struct wined3d_shader_resource_view_gl *view_gl,
1245 unsigned int unit, struct wined3d_sampler_gl *sampler_gl, struct wined3d_context_gl *context_gl)
1246 {
1247 const struct wined3d_gl_info *gl_info = context_gl->gl_info;
1248 struct wined3d_texture_gl *texture_gl;
1249
1250 wined3d_context_gl_active_texture(context_gl, gl_info, unit);
1251
1252 if (view_gl->gl_view.name)
1253 {
1254 wined3d_context_gl_bind_texture(context_gl, view_gl->gl_view.target, view_gl->gl_view.name);
1255 wined3d_sampler_gl_bind(sampler_gl, unit, NULL, context_gl);
1256 return;
1257 }
1258
1259 if (view_gl->v.resource->type == WINED3D_RTYPE_BUFFER)
1260 {
1261 FIXME("Buffer shader resources not supported.\n");
1262 return;
1263 }
1264
1265 texture_gl = wined3d_texture_gl(wined3d_texture_from_resource(view_gl->v.resource));
1266 wined3d_texture_gl_bind(texture_gl, context_gl, FALSE);
1267 wined3d_sampler_gl_bind(sampler_gl, unit, texture_gl, context_gl);
1268 }
1269
1270 /* Context activation is done by the caller. */
1271 static void shader_resource_view_gl_bind_and_dirtify(struct wined3d_shader_resource_view_gl *view_gl,
1272 struct wined3d_context_gl *context_gl)
1273 {
1274 if (context_gl->active_texture < ARRAY_SIZE(context_gl->rev_tex_unit_map))
1275 {
1276 unsigned int active_sampler = context_gl->rev_tex_unit_map[context_gl->active_texture];
1277 if (active_sampler != WINED3D_UNMAPPED_STAGE)
1278 context_invalidate_state(&context_gl->c, STATE_SAMPLER(active_sampler));
1279 }
1280 /* FIXME: Ideally we'd only do this when touching a binding that's used by
1281 * a shader. */
1282 context_invalidate_compute_state(&context_gl->c, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1283 context_invalidate_state(&context_gl->c, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1284
1285 wined3d_context_gl_bind_texture(context_gl, view_gl->gl_view.target, view_gl->gl_view.name);
1286 }
1287
1288 void wined3d_shader_resource_view_gl_generate_mipmap(struct wined3d_shader_resource_view_gl *view_gl,
1289 struct wined3d_context_gl *context_gl)
1290 {
1291 unsigned int i, j, layer_count, level_count, base_level, base_layer, sub_resource_idx;
1292 const struct wined3d_gl_info *gl_info = context_gl->gl_info;
1293 struct wined3d_texture_gl *texture_gl;
1294 struct gl_texture *gl_tex;
1295 DWORD location;
1296 BOOL srgb;
1297
1298 TRACE("view_gl %p.\n", view_gl);
1299
1300 layer_count = view_gl->v.desc.u.texture.layer_count;
1301 level_count = view_gl->v.desc.u.texture.level_count;
1302 base_level = view_gl->v.desc.u.texture.level_idx;
1303 base_layer = view_gl->v.desc.u.texture.layer_idx;
1304
1305 texture_gl = wined3d_texture_gl(texture_from_resource(view_gl->v.resource));
1306 srgb = !!(texture_gl->t.flags & WINED3D_TEXTURE_IS_SRGB);
1307 location = srgb ? WINED3D_LOCATION_TEXTURE_SRGB : WINED3D_LOCATION_TEXTURE_RGB;
1308 for (i = 0; i < layer_count; ++i)
1309 {
1310 sub_resource_idx = (base_layer + i) * texture_gl->t.level_count + base_level;
1311 if (!wined3d_texture_load_location(&texture_gl->t, sub_resource_idx, &context_gl->c, location))
1312 ERR("Failed to load source layer %u.\n", base_layer + i);
1313 }
1314
1315 if (view_gl->gl_view.name)
1316 {
1317 shader_resource_view_gl_bind_and_dirtify(view_gl, context_gl);
1318 }
1319 else
1320 {
1321 wined3d_texture_gl_bind_and_dirtify(texture_gl, context_gl, srgb);
1322 gl_info->gl_ops.gl.p_glTexParameteri(texture_gl->target, GL_TEXTURE_BASE_LEVEL, base_level);
1323 gl_info->gl_ops.gl.p_glTexParameteri(texture_gl->target, GL_TEXTURE_MAX_LEVEL, base_level + level_count - 1);
1324 }
1325
1326 if (gl_info->supported[ARB_SAMPLER_OBJECTS])
1327 GL_EXTCALL(glBindSampler(context_gl->active_texture, 0));
1328 gl_tex = wined3d_texture_gl_get_gl_texture(texture_gl, srgb);
1329 if (context_gl->c.d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL
1330 && gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
1331 {
1332 gl_info->gl_ops.gl.p_glTexParameteri(texture_gl->target,
1333 GL_TEXTURE_SRGB_DECODE_EXT, GL_SKIP_DECODE_EXT);
1334 gl_tex->sampler_desc.srgb_decode = FALSE;
1335 }
1336
1337 gl_info->fbo_ops.glGenerateMipmap(texture_gl->target);
1338 checkGLcall("glGenerateMipMap()");
1339
1340 for (i = 0; i < layer_count; ++i)
1341 {
1342 for (j = 1; j < level_count; ++j)
1343 {
1344 sub_resource_idx = (base_layer + i) * texture_gl->t.level_count + base_level + j;
1345 wined3d_texture_validate_location(&texture_gl->t, sub_resource_idx, location);
1346 wined3d_texture_invalidate_location(&texture_gl->t, sub_resource_idx, ~location);
1347 }
1348 }
1349
1350 if (!view_gl->gl_view.name)
1351 {
1352 gl_tex->base_level = base_level;
1353 gl_info->gl_ops.gl.p_glTexParameteri(texture_gl->target,
1354 GL_TEXTURE_MAX_LEVEL, texture_gl->t.level_count - 1);
1355 }
1356 }
1357
1358 void wined3d_shader_resource_view_vk_generate_mipmap(struct wined3d_shader_resource_view_vk *srv_vk,
1359 struct wined3d_context_vk *context_vk)
1360 {
1361 unsigned int i, j, layer_count, level_count, base_level, base_layer, sub_resource_idx;
1362 const struct wined3d_vk_info *vk_info = context_vk->vk_info;
1363 VkImageSubresourceRange vk_src_range, vk_dst_range;
1364 struct wined3d_texture_vk *texture_vk;
1365 VkCommandBuffer vk_command_buffer;
1366 VkImageBlit region;
1367
1368 TRACE("srv_vk %p.\n", srv_vk);
1369
1370 layer_count = srv_vk->v.desc.u.texture.layer_count;
1371 level_count = srv_vk->v.desc.u.texture.level_count;
1372 base_level = srv_vk->v.desc.u.texture.level_idx;
1373 base_layer = srv_vk->v.desc.u.texture.layer_idx;
1374
1375 texture_vk = wined3d_texture_vk(texture_from_resource(srv_vk->v.resource));
1376 for (i = 0; i < layer_count; ++i)
1377 {
1378 sub_resource_idx = (base_layer + i) * texture_vk->t.level_count + base_level;
1379 if (!wined3d_texture_load_location(&texture_vk->t, sub_resource_idx,
1380 &context_vk->c, WINED3D_LOCATION_TEXTURE_RGB))
1381 ERR("Failed to load source layer %u.\n", base_layer + i);
1382 }
1383
1384 if (context_vk->c.d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
1385 FIXME("Unhandled sRGB read/write control.\n");
1386
1387 if (wined3d_format_vk(srv_vk->v.format)->vk_format != wined3d_format_vk(texture_vk->t.resource.format)->vk_format)
1388 FIXME("Ignoring view format %s.\n", debug_d3dformat(srv_vk->v.format->id));
1389
1390 if (wined3d_resource_get_sample_count(&texture_vk->t.resource) > 1)
1391 FIXME("Unhandled multi-sampled resource.\n");
1392
1393 if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
1394 {
1395 ERR("Failed to get command buffer.\n");
1396 return;
1397 }
1398
1399 vk_src_range.aspectMask = vk_aspect_mask_from_format(texture_vk->t.resource.format);
1400 vk_src_range.baseMipLevel = base_level;
1401 vk_src_range.levelCount = 1;
1402 vk_src_range.baseArrayLayer = base_layer;
1403 vk_src_range.layerCount = layer_count;
1404
1405 vk_dst_range = vk_src_range;
1406 ++vk_dst_range.baseMipLevel;
1407
1408 wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
1409 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1410 vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
1411 VK_ACCESS_TRANSFER_READ_BIT,
1412 texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1413 texture_vk->image.vk_image, &vk_src_range);
1414 wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
1415 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1416 vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
1417 VK_ACCESS_TRANSFER_WRITE_BIT,
1418 texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1419 texture_vk->image.vk_image, &vk_dst_range);
1420
1421 region.srcSubresource.aspectMask = vk_src_range.aspectMask;
1422 region.srcSubresource.mipLevel = vk_src_range.baseMipLevel;
1423 region.srcSubresource.baseArrayLayer = vk_src_range.baseArrayLayer;
1424 region.srcSubresource.layerCount = vk_src_range.layerCount;
1425 region.srcOffsets[0].x = 0;
1426 region.srcOffsets[0].y = 0;
1427 region.srcOffsets[0].z = 0;
1428
1429 region.dstSubresource.aspectMask = vk_dst_range.aspectMask;
1430 region.dstSubresource.mipLevel = vk_dst_range.baseMipLevel;
1431 region.dstSubresource.baseArrayLayer = vk_dst_range.baseArrayLayer;
1432 region.dstSubresource.layerCount = vk_dst_range.layerCount;
1433 region.dstOffsets[0].x = 0;
1434 region.dstOffsets[0].y = 0;
1435 region.dstOffsets[0].z = 0;
1436
1437 for (i = 1; i < level_count; ++i)
1438 {
1439 region.srcOffsets[1].x = wined3d_texture_get_level_width(&texture_vk->t, vk_src_range.baseMipLevel);
1440 region.srcOffsets[1].y = wined3d_texture_get_level_height(&texture_vk->t, vk_src_range.baseMipLevel);
1441 region.srcOffsets[1].z = wined3d_texture_get_level_depth(&texture_vk->t, vk_src_range.baseMipLevel);
1442
1443 region.dstOffsets[1].x = wined3d_texture_get_level_width(&texture_vk->t, vk_dst_range.baseMipLevel);
1444 region.dstOffsets[1].y = wined3d_texture_get_level_height(&texture_vk->t, vk_dst_range.baseMipLevel);
1445 region.dstOffsets[1].z = wined3d_texture_get_level_depth(&texture_vk->t, vk_dst_range.baseMipLevel);
1446
1447 VK_CALL(vkCmdBlitImage(vk_command_buffer, texture_vk->image.vk_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1448 texture_vk->image.vk_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region, VK_FILTER_LINEAR));
1449
1450 wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
1451 VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
1452 VK_ACCESS_TRANSFER_READ_BIT,
1453 vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
1454 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, texture_vk->layout,
1455 texture_vk->image.vk_image, &vk_src_range);
1456
1457 if (i == level_count - 1)
1458 {
1459 wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
1460 VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
1461 VK_ACCESS_TRANSFER_WRITE_BIT,
1462 vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
1463 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, texture_vk->layout,
1464 texture_vk->image.vk_image, &vk_dst_range);
1465 }
1466 else
1467 {
1468 region.srcSubresource.mipLevel = ++vk_src_range.baseMipLevel;
1469 region.dstSubresource.mipLevel = ++vk_dst_range.baseMipLevel;
1470
1471 wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
1472 VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1473 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1474 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1475 texture_vk->image.vk_image, &vk_src_range);
1476 wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
1477 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1478 vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
1479 VK_ACCESS_TRANSFER_WRITE_BIT,
1480 texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1481 texture_vk->image.vk_image, &vk_dst_range);
1482 }
1483 }
1484
1485 for (i = 0; i < layer_count; ++i)
1486 {
1487 for (j = 1; j < level_count; ++j)
1488 {
1489 sub_resource_idx = (base_layer + i) * texture_vk->t.level_count + base_level + j;
1490 wined3d_texture_validate_location(&texture_vk->t, sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
1491 wined3d_texture_invalidate_location(&texture_vk->t, sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
1492 }
1493 }
1494
1495 wined3d_context_vk_reference_texture(context_vk, texture_vk);
1496 }
1497
1498 ULONG CDECL wined3d_unordered_access_view_incref(struct wined3d_unordered_access_view *view)
1499 {
1500 unsigned int refcount = InterlockedIncrement(&view->refcount);
1501
1502 TRACE("%p increasing refcount to %u.\n", view, refcount);
1503
1504 return refcount;
1505 }
1506
1507 void wined3d_unordered_access_view_cleanup(struct wined3d_unordered_access_view *view)
1508 {
1509 /* Call wined3d_object_destroyed() before releasing the resource,
1510 * since releasing the resource may end up destroying the parent. */
1511 view->parent_ops->wined3d_object_destroyed(view->parent);
1512 wined3d_resource_decref(view->resource);
1513 }
1514
1515 ULONG CDECL wined3d_unordered_access_view_decref(struct wined3d_unordered_access_view *view)
1516 {
1517 unsigned int refcount = InterlockedDecrement(&view->refcount);
1518
1519 TRACE("%p decreasing refcount to %u.\n", view, refcount);
1520
1521 if (!refcount)
1522 {
1523 wined3d_mutex_lock();
1524 view->resource->device->adapter->adapter_ops->adapter_destroy_unordered_access_view(view);
1525 wined3d_mutex_unlock();
1526 }
1527
1528 return refcount;
1529 }
1530
1531 void * CDECL wined3d_unordered_access_view_get_parent(const struct wined3d_unordered_access_view *view)
1532 {
1533 TRACE("view %p.\n", view);
1534
1535 return view->parent;
1536 }
1537
1538 void wined3d_unordered_access_view_invalidate_location(struct wined3d_unordered_access_view *view,
1539 uint32_t location)
1540 {
1541 wined3d_view_invalidate_location(view->resource, &view->desc, location);
1542 }
1543
1544 void wined3d_unordered_access_view_gl_clear(struct wined3d_unordered_access_view_gl *view_gl,
1545 const struct wined3d_uvec4 *clear_value, struct wined3d_context_gl *context_gl, bool fp)
1546 {
1547 const struct wined3d_gl_info *gl_info = context_gl->gl_info;
1548 const struct wined3d_format_gl *format_gl;
1549 struct wined3d_resource *resource;
1550 struct wined3d_buffer *buffer;
1551 struct wined3d_bo_gl *bo_gl;
1552 unsigned int offset, size;
1553
1554 resource = view_gl->v.resource;
1555 if (resource->type != WINED3D_RTYPE_BUFFER)
1556 {
1557 unsigned int layer_count, level_count, base_level, base_layer;
1558 unsigned int sub_resource_idx, width, height, depth, i, j;
1559 struct wined3d_texture_gl *texture_gl;
1560 const void *data = clear_value;
1561 GLenum gl_format, gl_type;
1562 uint32_t packed;
1563
1564 if (!gl_info->supported[ARB_CLEAR_TEXTURE])
1565 {
1566 FIXME("OpenGL implementation does not support ARB_clear_texture.\n");
1567 return;
1568 }
1569
1570 format_gl = wined3d_format_gl(resource->format);
1571 texture_gl = wined3d_texture_gl(texture_from_resource(resource));
1572 level_count = view_gl->v.desc.u.texture.level_count;
1573 base_level = view_gl->v.desc.u.texture.level_idx;
1574
1575 if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
1576 {
1577 layer_count = 1;
1578 base_layer = 0;
1579 }
1580 else
1581 {
1582 layer_count = view_gl->v.desc.u.texture.layer_count;
1583 base_layer = view_gl->v.desc.u.texture.layer_idx;
1584 }
1585
1586 if (format_gl->f.byte_count <= 4 && !fp)
1587 {
1588 gl_format = format_gl->format;
1589 gl_type = format_gl->type;
1590 packed = wined3d_format_pack(&format_gl->f, clear_value);
1591 data = &packed;
1592 }
1593 else if (resource->format_attrs & WINED3D_FORMAT_ATTR_INTEGER)
1594 {
1595 gl_format = GL_RGBA_INTEGER;
1596 gl_type = GL_UNSIGNED_INT;
1597 }
1598 else
1599 {
1600 gl_format = GL_RGBA;
1601 gl_type = GL_FLOAT;
1602 }
1603
1604 for (i = 0; i < layer_count; ++i)
1605 {
1606 for (j = 0; j < level_count; ++j)
1607 {
1608 sub_resource_idx = (base_layer + i) * texture_gl->t.level_count + base_level + j;
1609 wined3d_texture_prepare_location(&texture_gl->t, sub_resource_idx,
1610 &context_gl->c, WINED3D_LOCATION_TEXTURE_RGB);
1611
1612 width = wined3d_texture_get_level_width(&texture_gl->t, base_level + j);
1613 height = wined3d_texture_get_level_height(&texture_gl->t, base_level + j);
1614 depth = wined3d_texture_get_level_depth(&texture_gl->t, base_level + j);
1615
1616 switch (texture_gl->target)
1617 {
1618 case GL_TEXTURE_1D_ARRAY:
1619 GL_EXTCALL(glClearTexSubImage(texture_gl->texture_rgb.name, base_level + j,
1620 0, base_layer + i, 0, width, 1, 1, gl_format, gl_type, data));
1621 break;
1622
1623 case GL_TEXTURE_2D_ARRAY:
1624 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
1625 case GL_TEXTURE_CUBE_MAP:
1626 case GL_TEXTURE_CUBE_MAP_ARRAY:
1627 GL_EXTCALL(glClearTexSubImage(texture_gl->texture_rgb.name, base_level + j,
1628 0, 0, base_layer + i, width, height, 1, gl_format, gl_type, data));
1629 break;
1630
1631 default:
1632 GL_EXTCALL(glClearTexSubImage(texture_gl->texture_rgb.name, base_level + j,
1633 0, 0, 0, width, height, depth, gl_format, gl_type, data));
1634 break;
1635 }
1636
1637 wined3d_texture_validate_location(&texture_gl->t, sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
1638 wined3d_texture_invalidate_location(&texture_gl->t, sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
1639 }
1640 }
1641
1642 return;
1643 }
1644
1645 if (!gl_info->supported[ARB_CLEAR_BUFFER_OBJECT])
1646 {
1647 FIXME("OpenGL implementation does not support ARB_clear_buffer_object.\n");
1648 return;
1649 }
1650
1651 format_gl = wined3d_format_gl(view_gl->v.format);
1652 if (format_gl->f.id != WINED3DFMT_R32_UINT && format_gl->f.id != WINED3DFMT_R32_SINT
1653 && format_gl->f.id != WINED3DFMT_R32G32B32A32_UINT
1654 && format_gl->f.id != WINED3DFMT_R32G32B32A32_SINT)
1655 {
1656 FIXME("Not implemented for format %s.\n", debug_d3dformat(format_gl->f.id));
1657 return;
1658 }
1659
1660 if (fp)
1661 {
1662 FIXME("Floating-point buffer clears not implemented.\n");
1663 return;
1664 }
1665
1666 buffer = buffer_from_resource(resource);
1667 get_buffer_view_range(buffer, &view_gl->v.desc, &format_gl->f, &offset, &size);
1668
1669 if (!offset && size == buffer->resource.size)
1670 wined3d_buffer_prepare_location(buffer, &context_gl->c, WINED3D_LOCATION_BUFFER);
1671 else
1672 wined3d_buffer_load_location(buffer, &context_gl->c, WINED3D_LOCATION_BUFFER);
1673 wined3d_unordered_access_view_invalidate_location(&view_gl->v, ~WINED3D_LOCATION_BUFFER);
1674
1675 bo_gl = wined3d_bo_gl(buffer->buffer_object);
1676 wined3d_context_gl_bind_bo(context_gl, bo_gl->binding, bo_gl->id);
1677 GL_EXTCALL(glClearBufferSubData(bo_gl->binding, format_gl->internal,
1678 bo_gl->b.buffer_offset + offset, size, format_gl->format, format_gl->type, clear_value));
1679 wined3d_context_gl_reference_bo(context_gl, bo_gl);
1680 checkGLcall("clear unordered access view");
1681 }
1682
1683 void wined3d_unordered_access_view_set_counter(struct wined3d_unordered_access_view *view,
1684 unsigned int value)
1685 {
1686 struct wined3d_bo_address dst, src;
1687 struct wined3d_context *context;
1688 struct wined3d_range range;
1689
1690 if (!view->counter_bo)
1691 return;
1692
1693 context = context_acquire(view->resource->device, NULL, 0);
1694
1695 src.buffer_object = 0;
1696 src.addr = (void *)&value;
1697
1698 dst.buffer_object = view->counter_bo;
1699 dst.addr = NULL;
1700
1701 range.offset = 0;
1702 range.size = sizeof(value);
1703 wined3d_context_copy_bo_address(context, &dst, &src, 1, &range, WINED3D_MAP_WRITE | WINED3D_MAP_DISCARD);
1704
1705 context_release(context);
1706 }
1707
1708 void wined3d_unordered_access_view_copy_counter(struct wined3d_unordered_access_view *view,
1709 struct wined3d_buffer *buffer, unsigned int offset, struct wined3d_context *context)
1710 {
1711 struct wined3d_const_bo_address src;
1712
1713 if (!view->counter_bo)
1714 return;
1715
1716 src.buffer_object = view->counter_bo;
1717 src.addr = NULL;
1718
1719 wined3d_buffer_copy_bo_address(buffer, context, offset, &src, sizeof(uint32_t));
1720 }
1721
1722 void wined3d_unordered_access_view_gl_update(struct wined3d_unordered_access_view_gl *uav_gl,
1723 struct wined3d_context_gl *context_gl)
1724 {
1725 struct wined3d_buffer *buffer = buffer_from_resource(uav_gl->v.resource);
1726
1727 assert(!uav_gl->bo_user.valid);
1728 create_buffer_view(&uav_gl->gl_view, &context_gl->c, &uav_gl->v.desc, buffer, uav_gl->v.format);
1729 uav_gl->bo_user.valid = true;
1730 list_add_head(&buffer->buffer_object->users, &uav_gl->bo_user.entry);
1731 }
1732
1733 static void wined3d_unordered_access_view_gl_cs_init(void *object)
1734 {
1735 struct wined3d_unordered_access_view_gl *view_gl = object;
1736 struct wined3d_resource *resource = view_gl->v.resource;
1737 struct wined3d_view_desc *desc = &view_gl->v.desc;
1738 const struct wined3d_gl_info *gl_info;
1739
1740 TRACE("view_gl %p.\n", view_gl);
1741
1742 gl_info = &wined3d_adapter_gl(resource->device->adapter)->gl_info;
1743
1744 if (resource->type == WINED3D_RTYPE_BUFFER)
1745 {
1746 struct wined3d_device_gl *device_gl = wined3d_device_gl(resource->device);
1747 struct wined3d_buffer *buffer = buffer_from_resource(resource);
1748 struct wined3d_context_gl *context_gl;
1749
1750 context_gl = wined3d_context_gl(context_acquire(&device_gl->d, NULL, 0));
1751 create_buffer_view(&view_gl->gl_view, &context_gl->c, desc, buffer, view_gl->v.format);
1752 view_gl->bo_user.valid = true;
1753 list_add_head(&buffer->buffer_object->users, &view_gl->bo_user.entry);
1754 if (desc->flags & (WINED3D_VIEW_BUFFER_COUNTER | WINED3D_VIEW_BUFFER_APPEND))
1755 {
1756 struct wined3d_bo_gl *bo = &view_gl->counter_bo;
1757
1758 view_gl->v.counter_bo = &bo->b;
1759 wined3d_device_gl_create_bo(device_gl, context_gl, sizeof(uint32_t), GL_ATOMIC_COUNTER_BUFFER,
1760 GL_STATIC_DRAW, true, GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_CLIENT_STORAGE_BIT, bo);
1761 wined3d_unordered_access_view_set_counter(&view_gl->v, 0);
1762 }
1763 context_release(&context_gl->c);
1764 }
1765 else
1766 {
1767 struct wined3d_texture_gl *texture_gl = wined3d_texture_gl(texture_from_resource(resource));
1768 unsigned int depth_or_layer_count;
1769
1770 if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
1771 depth_or_layer_count = wined3d_texture_get_level_depth(&texture_gl->t, desc->u.texture.level_idx);
1772 else
1773 depth_or_layer_count = texture_gl->t.layer_count;
1774
1775 if (desc->u.texture.layer_idx || desc->u.texture.layer_count != depth_or_layer_count)
1776 {
1777 create_texture_view(&view_gl->gl_view, get_texture_view_target(gl_info, desc, texture_gl),
1778 desc, texture_gl, view_gl->v.format);
1779 }
1780 }
1781 }
1782
1783 static HRESULT wined3d_unordered_access_view_init(struct wined3d_unordered_access_view *view,
1784 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
1785 void *parent, const struct wined3d_parent_ops *parent_ops)
1786 {
1787 view->refcount = 1;
1788 view->parent = parent;
1789 view->parent_ops = parent_ops;
1790
1791 if (!(resource->bind_flags & WINED3D_BIND_UNORDERED_ACCESS))
1792 return E_INVALIDARG;
1793 if (!(view->format = validate_resource_view(desc, resource, TRUE, FALSE)))
1794 return E_INVALIDARG;
1795 view->desc = *desc;
1796
1797 wined3d_resource_incref(view->resource = resource);
1798
1799 return WINED3D_OK;
1800 }
1801
1802 HRESULT wined3d_unordered_access_view_gl_init(struct wined3d_unordered_access_view_gl *view_gl,
1803 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
1804 void *parent, const struct wined3d_parent_ops *parent_ops)
1805 {
1806 HRESULT hr;
1807
1808 TRACE("view_gl %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
1809 view_gl, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
1810
1811 if (FAILED(hr = wined3d_unordered_access_view_init(&view_gl->v, desc, resource, parent, parent_ops)))
1812 return hr;
1813
1814 list_init(&view_gl->bo_user.entry);
1815 wined3d_cs_init_object(resource->device->cs, wined3d_unordered_access_view_gl_cs_init, view_gl);
1816
1817 return hr;
1818 }
1819
1820 struct wined3d_uav_clear_constants_vk
1821 {
1822 VkClearColorValue color;
1823 VkOffset2D offset;
1824 VkExtent2D extent;
1825 };
1826
1827 static VkPipeline create_uav_pipeline(struct wined3d_context_vk *context_vk,
1828 struct wined3d_pipeline_layout_vk *layout, const unsigned int *byte_code, size_t byte_code_size,
1829 enum wined3d_shader_resource_type resource_type)
1830 {
1831 VkComputePipelineCreateInfo pipeline_info;
1832 struct wined3d_shader_desc shader_desc;
1833 const struct wined3d_vk_info *vk_info;
1834 struct wined3d_context *context;
1835 VkShaderModule shader_module;
1836 VkDevice vk_device;
1837 VkPipeline result;
1838 VkResult vr;
1839
1840 vk_info = context_vk->vk_info;
1841 context = &context_vk->c;
1842
1843 shader_desc.byte_code = (const DWORD *)byte_code;
1844 shader_desc.byte_code_size = byte_code_size;
1845
1846 shader_module = (VkShaderModule)context->device->adapter->shader_backend->shader_compile(context, &shader_desc,
1847 WINED3D_SHADER_TYPE_COMPUTE);
1848 if (shader_module == VK_NULL_HANDLE)
1849 {
1850 ERR("Failed to create shader.\n");
1851 return VK_NULL_HANDLE;
1852 }
1853
1854 pipeline_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
1855 pipeline_info.pNext = NULL;
1856 pipeline_info.flags = 0;
1857 pipeline_info.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
1858 pipeline_info.stage.pNext = NULL;
1859 pipeline_info.stage.flags = 0;
1860 pipeline_info.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
1861 pipeline_info.stage.pName = "main";
1862 pipeline_info.stage.pSpecializationInfo = NULL;
1863 pipeline_info.stage.module = shader_module;
1864 pipeline_info.layout = layout->vk_pipeline_layout;
1865 pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
1866 pipeline_info.basePipelineIndex = -1;
1867
1868 vk_device = wined3d_device_vk(context->device)->vk_device;
1869
1870 if ((vr = VK_CALL(vkCreateComputePipelines(vk_device, VK_NULL_HANDLE, 1, &pipeline_info, NULL, &result))) < 0)
1871 {
1872 ERR("Failed to create Vulkan compute pipeline, vr %s.\n", wined3d_debug_vkresult(vr));
1873 return VK_NULL_HANDLE;
1874 }
1875
1876 VK_CALL(vkDestroyShaderModule(vk_device, shader_module, NULL));
1877 return result;
1878 }
1879
1880 void wined3d_device_vk_uav_clear_state_init(struct wined3d_device_vk *device_vk)
1881 {
1882 struct wined3d_uav_clear_state_vk *state = &device_vk->uav_clear_state;
1883 struct wined3d_context_vk *context_vk = &device_vk->context_vk;
1884 VkDescriptorSetLayoutBinding vk_set_bindings[2];
1885
1886 vk_set_bindings[0].binding = 0;
1887 vk_set_bindings[0].descriptorCount = 1;
1888 vk_set_bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
1889 vk_set_bindings[0].pImmutableSamplers = NULL;
1890 vk_set_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
1891
1892 vk_set_bindings[1].binding = 1;
1893 vk_set_bindings[1].descriptorCount = 1;
1894 vk_set_bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
1895 vk_set_bindings[1].pImmutableSamplers = NULL;
1896
1897 vk_set_bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
1898 state->image_layout = wined3d_context_vk_get_pipeline_layout(context_vk, vk_set_bindings, 2);
1899
1900 vk_set_bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
1901 state->buffer_layout = wined3d_context_vk_get_pipeline_layout(context_vk, vk_set_bindings, 2);
1902
1903 #define SHADER_DESC(name) name, sizeof(name)
1904 state->float_pipelines.buffer = create_uav_pipeline(context_vk, state->buffer_layout,
1905 SHADER_DESC(cs_uav_clear_buffer_float_code), WINED3D_SHADER_RESOURCE_BUFFER);
1906 state->uint_pipelines.buffer = create_uav_pipeline(context_vk, state->buffer_layout,
1907 SHADER_DESC(cs_uav_clear_buffer_uint_code), WINED3D_SHADER_RESOURCE_BUFFER);
1908 state->float_pipelines.image_1d = create_uav_pipeline(context_vk, state->image_layout,
1909 SHADER_DESC(cs_uav_clear_1d_float_code), WINED3D_SHADER_RESOURCE_TEXTURE_1D);
1910 state->uint_pipelines.image_1d = create_uav_pipeline(context_vk, state->image_layout,
1911 SHADER_DESC(cs_uav_clear_1d_uint_code), WINED3D_SHADER_RESOURCE_TEXTURE_1D);
1912 state->float_pipelines.image_1d_array = create_uav_pipeline(context_vk, state->image_layout,
1913 SHADER_DESC(cs_uav_clear_1d_array_float_code), WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY);
1914 state->uint_pipelines.image_1d_array = create_uav_pipeline(context_vk, state->image_layout,
1915 SHADER_DESC(cs_uav_clear_1d_array_uint_code), WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY);
1916 state->float_pipelines.image_2d = create_uav_pipeline(context_vk, state->image_layout,
1917 SHADER_DESC(cs_uav_clear_2d_float_code), WINED3D_SHADER_RESOURCE_TEXTURE_2D);
1918 state->uint_pipelines.image_2d = create_uav_pipeline(context_vk, state->image_layout,
1919 SHADER_DESC(cs_uav_clear_2d_uint_code), WINED3D_SHADER_RESOURCE_TEXTURE_2D);
1920 state->float_pipelines.image_2d_array = create_uav_pipeline(context_vk, state->image_layout,
1921 SHADER_DESC(cs_uav_clear_2d_array_float_code), WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY);
1922 state->uint_pipelines.image_2d_array = create_uav_pipeline(context_vk, state->image_layout,
1923 SHADER_DESC(cs_uav_clear_2d_array_uint_code), WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY);
1924 state->float_pipelines.image_3d = create_uav_pipeline(context_vk, state->image_layout,
1925 SHADER_DESC(cs_uav_clear_3d_float_code), WINED3D_SHADER_RESOURCE_TEXTURE_3D);
1926 state->uint_pipelines.image_3d = create_uav_pipeline(context_vk, state->image_layout,
1927 SHADER_DESC(cs_uav_clear_3d_uint_code), WINED3D_SHADER_RESOURCE_TEXTURE_3D);
1928 #undef SHADER_DESC
1929
1930 state->buffer_group_size.x = 128;
1931 state->buffer_group_size.y = 1;
1932 state->buffer_group_size.z = 1;
1933 state->image_1d_group_size.x = 64;
1934 state->image_1d_group_size.y = 1;
1935 state->image_1d_group_size.z = 1;
1936 state->image_1d_array_group_size.x = 64;
1937 state->image_1d_array_group_size.y = 1;
1938 state->image_1d_array_group_size.z = 1;
1939 state->image_2d_group_size.x = 8;
1940 state->image_2d_group_size.y = 8;
1941 state->image_2d_group_size.z = 1;
1942 state->image_2d_array_group_size.x = 8;
1943 state->image_2d_array_group_size.y = 8;
1944 state->image_2d_array_group_size.z = 1;
1945 state->image_3d_group_size.x = 8;
1946 state->image_3d_group_size.y = 8;
1947 state->image_3d_group_size.z = 1;
1948 }
1949
1950 void wined3d_device_vk_uav_clear_state_cleanup(struct wined3d_device_vk *device_vk)
1951 {
1952 struct wined3d_uav_clear_state_vk *state = &device_vk->uav_clear_state;
1953 const struct wined3d_vk_info *vk_info = &device_vk->vk_info;
1954
1955 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.buffer, NULL));
1956 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_1d, NULL));
1957 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_1d_array, NULL));
1958 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_2d, NULL));
1959 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_2d_array, NULL));
1960 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_3d, NULL));
1961
1962 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.buffer, NULL));
1963 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_1d, NULL));
1964 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_1d_array, NULL));
1965 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_2d, NULL));
1966 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_2d_array, NULL));
1967 VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_3d, NULL));
1968 }
1969
1970 void wined3d_unordered_access_view_vk_clear(struct wined3d_unordered_access_view_vk *view_vk,
1971 const struct wined3d_uvec4 *clear_value, struct wined3d_context_vk *context_vk, bool fp)
1972 {
1973 struct wined3d_bo_address cb_source_address, cb_destination_address;
1974 const struct wined3d_format *view_format = view_vk->v.format;
1975 struct wined3d_view_desc *view_desc = &view_vk->v.desc;
1976 struct wined3d_uav_clear_constants_vk constants = {0};
1977 struct wined3d_device *device = context_vk->c.device;
1978 struct wined3d_shader_thread_group_size group_count;
1979 enum wined3d_format_id format_id = view_format->id;
1980 struct wined3d_uav_clear_pipelines_vk *pipelines;
1981 struct wined3d_texture_vk *texture_vk = NULL;
1982 struct wined3d_pipeline_layout_vk *layout;
1983 struct wined3d_uav_clear_state_vk *state;
1984 const struct wined3d_vk_info *vk_info;
1985 VkDescriptorImageInfo vk_image_info;
1986 struct wined3d_device_vk *device_vk;
1987 VkDescriptorBufferInfo buffer_info;
1988 struct wined3d_resource *resource;
1989 VkCommandBuffer vk_command_buffer;
1990 struct wined3d_bo_vk constants_bo;
1991 VkWriteDescriptorSet vk_writes[2];
1992 VkBufferView vk_buffer_view;
1993 struct wined3d_range range;
1994 VkMemoryBarrier vk_barrier;
1995 VkPipeline vk_pipeline;
1996 bool is_array;
1997
1998 device_vk = wined3d_device_vk(device);
1999 state = &device_vk->uav_clear_state;
2000 pipelines = fp ? &state->float_pipelines : &state->uint_pipelines;
2001
2002 resource = view_vk->v.resource;
2003 is_array = view_desc->flags & WINED3D_VIEW_TEXTURE_ARRAY;
2004
2005 switch (resource->type)
2006 {
2007 case WINED3D_RTYPE_BUFFER:
2008 vk_pipeline = pipelines->buffer;
2009 group_count = state->buffer_group_size;
2010 break;
2011 case WINED3D_RTYPE_TEXTURE_1D:
2012 if (is_array)
2013 {
2014 vk_pipeline = pipelines->image_1d_array;
2015 group_count = state->image_1d_array_group_size;
2016 }
2017 else
2018 {
2019 vk_pipeline = pipelines->image_1d;
2020 group_count = state->image_1d_group_size;
2021 }
2022 break;
2023 case WINED3D_RTYPE_TEXTURE_2D:
2024 if (is_array)
2025 {
2026 vk_pipeline = pipelines->image_2d_array;
2027 group_count = state->image_2d_array_group_size;
2028 }
2029 else
2030 {
2031 vk_pipeline = pipelines->image_2d;
2032 group_count = state->image_2d_group_size;
2033 }
2034 break;
2035 case WINED3D_RTYPE_TEXTURE_3D:
2036 vk_pipeline = pipelines->image_3d;
2037 group_count = state->image_3d_group_size;
2038 break;
2039
2040 default:
2041 ERR("Unhandled resource type %s.\n", debug_d3dresourcetype(resource->type));
2042 return;
2043 }
2044
2045 if (vk_pipeline == VK_NULL_HANDLE)
2046 {
2047 ERR("Pipeline was not correctly initialized.\n");
2048 return;
2049 }
2050
2051 vk_writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
2052 vk_writes[0].pNext = NULL;
2053 vk_writes[0].dstBinding = 1;
2054 vk_writes[0].dstArrayElement = 0;
2055 vk_writes[0].descriptorCount = 1;
2056 vk_writes[0].pImageInfo = NULL;
2057 vk_writes[0].pTexelBufferView = &vk_buffer_view;
2058 vk_writes[0].pImageInfo = &vk_image_info;
2059
2060 if (resource->type == WINED3D_RTYPE_BUFFER)
2061 {
2062 struct wined3d_buffer *buffer = buffer_from_resource(resource);
2063 unsigned int offset, size;
2064
2065 layout = state->buffer_layout;
2066 vk_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
2067
2068 if (buffer->structure_byte_stride)
2069 constants.extent.width = view_desc->u.buffer.count * buffer->structure_byte_stride / 4;
2070 else
2071 constants.extent.width = view_desc->u.buffer.count;
2072 constants.extent.height = 1;
2073
2074 get_buffer_view_range(buffer, view_desc, view_format, &offset, &size);
2075 if (!offset && size == buffer->resource.size)
2076 wined3d_buffer_prepare_location(buffer, &context_vk->c, WINED3D_LOCATION_BUFFER);
2077 else
2078 wined3d_buffer_load_location(buffer, &context_vk->c, WINED3D_LOCATION_BUFFER);
2079 wined3d_buffer_validate_location(buffer, WINED3D_LOCATION_BUFFER);
2080 wined3d_buffer_invalidate_location(buffer, ~WINED3D_LOCATION_BUFFER);
2081 }
2082 else
2083 {
2084 unsigned int layer_count, level_count, base_level, base_layer, i, j;
2085
2086 texture_vk = wined3d_texture_vk(wined3d_texture_from_resource(resource));
2087
2088 layout = state->image_layout;
2089 vk_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
2090
2091 level_count = view_desc->u.texture.level_count;
2092 base_level = view_desc->u.texture.level_idx;
2093 if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
2094 {
2095 layer_count = 1;
2096 base_layer = 0;
2097 }
2098 else
2099 {
2100 layer_count = view_desc->u.texture.layer_count;
2101 base_layer = view_desc->u.texture.layer_idx;
2102 }
2103
2104 constants.extent.width = wined3d_texture_get_level_width(&texture_vk->t, base_level);
2105 constants.extent.height = wined3d_texture_get_level_height(&texture_vk->t, base_level);
2106 group_count.z = (view_desc->u.texture.layer_count + group_count.z - 1) / group_count.z;
2107
2108 for (i = 0; i < layer_count; ++i)
2109 {
2110 for (j = 0; j < level_count; ++j)
2111 {
2112 unsigned int sub_resource_idx = (base_layer + i) * texture_vk->t.level_count + base_level + j;
2113
2114 wined3d_texture_prepare_location(&texture_vk->t, sub_resource_idx,
2115 &context_vk->c, WINED3D_LOCATION_TEXTURE_RGB);
2116 wined3d_texture_validate_location(&texture_vk->t, sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2117 wined3d_texture_invalidate_location(&texture_vk->t, sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2118 }
2119 }
2120 }
2121
2122 group_count.x = (constants.extent.width + group_count.x - 1) / group_count.x;
2123 group_count.y = (constants.extent.height + group_count.y - 1) / group_count.y;
2124
2125 constants.color.uint32[0] = clear_value->x;
2126 constants.color.uint32[1] = clear_value->y;
2127 constants.color.uint32[2] = clear_value->z;
2128 constants.color.uint32[3] = clear_value->w;
2129
2130 if (!fp)
2131 {
2132 /* Make sure values are truncated, not saturated to some maximum value. */
2133 constants.color.uint32[0] &= wined3d_mask_from_size(view_format->red_size);
2134 constants.color.uint32[1] &= wined3d_mask_from_size(view_format->green_size);
2135 constants.color.uint32[2] &= wined3d_mask_from_size(view_format->blue_size);
2136 constants.color.uint32[3] &= wined3d_mask_from_size(view_format->alpha_size);
2137
2138 if (view_format->id == WINED3DFMT_R11G11B10_FLOAT)
2139 {
2140 constants.color.uint32[0] |= constants.color.uint32[1] << 11;
2141 constants.color.uint32[0] |= constants.color.uint32[2] << 22;
2142 format_id = WINED3DFMT_R32_UINT;
2143 }
2144 else
2145 {
2146 format_id = wined3d_get_typed_format_id(context_vk->c.device->adapter, view_format,
2147 WINED3D_CHANNEL_TYPE_UINT);
2148 }
2149 }
2150
2151 if (format_id == WINED3DFMT_UNKNOWN)
2152 {
2153 ERR("Unsupported format %s.\n", debug_d3dformat(view_format->id));
2154 return;
2155 }
2156
2157 if (resource->type == WINED3D_RTYPE_BUFFER)
2158 {
2159 if (format_id == view_format->id)
2160 vk_buffer_view = view_vk->view_vk.u.vk_buffer_view;
2161 else
2162 {
2163 vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(context_vk, view_desc,
2164 wined3d_buffer_vk(buffer_from_resource(resource)), wined3d_format_vk(
2165 wined3d_get_format(context_vk->c.device->adapter, format_id, WINED3D_BIND_UNORDERED_ACCESS)));
2166 if (vk_buffer_view == VK_NULL_HANDLE)
2167 return;
2168 }
2169 }
2170 else
2171 {
2172 if (format_id == view_format->id)
2173 {
2174 vk_image_info = view_vk->view_vk.u.vk_image_info;
2175 if (!vk_image_info.imageView)
2176 {
2177 const VkDescriptorImageInfo *default_info;
2178 if (!(default_info = wined3d_texture_vk_get_default_image_info(texture_vk, context_vk)))
2179 return;
2180 vk_image_info = *default_info;
2181 }
2182 }
2183 else
2184 {
2185 vk_image_info.sampler = VK_NULL_HANDLE;
2186 vk_image_info.imageLayout = texture_vk->layout;
2187 vk_image_info.imageView = wined3d_view_vk_create_vk_image_view(context_vk, view_desc, texture_vk,
2188 wined3d_format_vk(wined3d_get_format(context_vk->c.device->adapter, format_id,
2189 WINED3D_BIND_UNORDERED_ACCESS)),
2190 COLOR_FIXUP_IDENTITY, false);
2191
2192 if (vk_image_info.imageView == VK_NULL_HANDLE)
2193 return;
2194 }
2195 }
2196
2197 vk_writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
2198 vk_writes[1].pNext = NULL;
2199 vk_writes[1].dstBinding = 0;
2200 vk_writes[1].dstArrayElement = 0;
2201 vk_writes[1].descriptorCount = 1;
2202 vk_writes[1].pImageInfo = NULL;
2203 vk_writes[1].pTexelBufferView = NULL;
2204 vk_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
2205 vk_writes[1].pBufferInfo = &buffer_info;
2206
2207 if (!wined3d_context_vk_create_bo(context_vk, sizeof(constants), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
2208 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &constants_bo))
2209 {
2210 ERR("Failed to create constants BO.\n");
2211 goto out;
2212 }
2213
2214 cb_source_address.buffer_object = NULL;
2215 cb_source_address.addr = (BYTE *)&constants;
2216 cb_destination_address.buffer_object = &constants_bo.b;
2217 cb_destination_address.addr = 0;
2218
2219 range.offset = 0;
2220 range.size = sizeof(constants);
2221 adapter_vk_copy_bo_address(&context_vk->c, &cb_destination_address,
2222 &cb_source_address, 1, &range, WINED3D_MAP_WRITE | WINED3D_MAP_DISCARD);
2223
2224 buffer_info.buffer = constants_bo.vk_buffer;
2225 buffer_info.range = constants_bo.size;
2226 buffer_info.offset = constants_bo.b.buffer_offset;
2227
2228 vk_info = context_vk->vk_info;
2229
2230 if (!(vk_writes[0].dstSet = wined3d_context_vk_create_vk_descriptor_set(context_vk, layout->vk_set_layout)))
2231 {
2232 ERR("Failed to create descriptor set.\n");
2233 wined3d_context_vk_destroy_bo(context_vk, &constants_bo);
2234 goto out;
2235 }
2236
2237 vk_writes[1].dstSet = vk_writes[0].dstSet;
2238
2239 VK_CALL(vkUpdateDescriptorSets(device_vk->vk_device, 2, vk_writes, 0, NULL));
2240
2241 vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk);
2242 wined3d_context_vk_end_current_render_pass(context_vk);
2243
2244 wined3d_context_vk_reference_unordered_access_view(context_vk, view_vk);
2245 wined3d_context_vk_reference_bo(context_vk, &constants_bo);
2246 wined3d_context_vk_destroy_bo(context_vk, &constants_bo);
2247
2248 vk_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
2249 vk_barrier.pNext = NULL;
2250 vk_barrier.srcAccessMask = vk_access_mask_from_bind_flags(resource->bind_flags);
2251 vk_barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
2252
2253 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer,
2254 vk_pipeline_stage_mask_from_bind_flags(resource->bind_flags),
2255 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
2256 0, 1, &vk_barrier, 0, NULL, 0, NULL));
2257 VK_CALL(vkCmdBindPipeline(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline));
2258 VK_CALL(vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE,
2259 layout->vk_pipeline_layout, 0, 1, &vk_writes[0].dstSet, 0, NULL));
2260 VK_CALL(vkCmdDispatch(vk_command_buffer, group_count.x, group_count.y, group_count.z));
2261
2262 vk_barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
2263 vk_barrier.dstAccessMask = vk_access_mask_from_bind_flags(resource->bind_flags);
2264
2265 VK_CALL(vkCmdPipelineBarrier(vk_command_buffer,
2266 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
2267 vk_pipeline_stage_mask_from_bind_flags(resource->bind_flags),
2268 0, 1, &vk_barrier, 0, NULL, 0, NULL));
2269
2270 context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_SHADER);
2271
2272 out:
2273 if (format_id != view_format->id)
2274 {
2275 if (resource->type == WINED3D_RTYPE_BUFFER)
2276 wined3d_context_vk_destroy_vk_buffer_view(context_vk, vk_buffer_view, view_vk->view_vk.command_buffer_id);
2277 else
2278 wined3d_context_vk_destroy_vk_image_view(context_vk, vk_image_info.imageView,
2279 view_vk->view_vk.command_buffer_id);
2280 }
2281 }
2282
2283 void wined3d_unordered_access_view_vk_update(struct wined3d_unordered_access_view_vk *uav_vk,
2284 struct wined3d_context_vk *context_vk)
2285 {
2286 const struct wined3d_format_vk *view_format_vk = wined3d_format_vk(uav_vk->v.format);
2287 const struct wined3d_view_desc *desc = &uav_vk->v.desc;
2288 struct wined3d_resource *resource = uav_vk->v.resource;
2289 struct wined3d_view_vk *view_vk = &uav_vk->view_vk;
2290 struct wined3d_buffer_vk *buffer_vk;
2291 VkBufferView vk_buffer_view;
2292
2293 assert(!view_vk->bo_user.valid);
2294
2295 buffer_vk = wined3d_buffer_vk(buffer_from_resource(resource));
2296 wined3d_context_vk_destroy_vk_buffer_view(context_vk, view_vk->u.vk_buffer_view, view_vk->command_buffer_id);
2297 if ((vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(context_vk, desc, buffer_vk, view_format_vk)))
2298 {
2299 view_vk->u.vk_buffer_view = vk_buffer_view;
2300 view_vk->bo_user.valid = true;
2301 list_add_head(&buffer_vk->b.buffer_object->users, &view_vk->bo_user.entry);
2302 }
2303 }
2304
2305 static void wined3d_unordered_access_view_vk_cs_init(void *object)
2306 {
2307 struct wined3d_unordered_access_view_vk *uav_vk = object;
2308 struct wined3d_view_vk *view_vk = &uav_vk->view_vk;
2309 struct wined3d_view_desc *desc = &uav_vk->v.desc;
2310 const struct wined3d_format_vk *format_vk;
2311 const struct wined3d_vk_info *vk_info;
2312 struct wined3d_texture_vk *texture_vk;
2313 struct wined3d_context_vk *context_vk;
2314 struct wined3d_device_vk *device_vk;
2315 struct wined3d_buffer_vk *buffer_vk;
2316 VkBufferViewCreateInfo create_info;
2317 struct wined3d_resource *resource;
2318 VkBufferView vk_buffer_view;
2319 uint32_t default_flags = 0;
2320 VkImageView vk_image_view;
2321 VkResult vr;
2322
2323 TRACE("uav_vk %p.\n", uav_vk);
2324
2325 resource = uav_vk->v.resource;
2326 device_vk = wined3d_device_vk(resource->device);
2327 format_vk = wined3d_format_vk(uav_vk->v.format);
2328
2329 if (resource->type == WINED3D_RTYPE_BUFFER)
2330 {
2331 buffer_vk = wined3d_buffer_vk(buffer_from_resource(resource));
2332
2333 context_vk = wined3d_context_vk(context_acquire(&device_vk->d, NULL, 0));
2334 vk_info = context_vk->vk_info;
2335
2336 if ((vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(context_vk, desc, buffer_vk, format_vk)))
2337 {
2338 struct wined3d_bo_vk *bo = wined3d_bo_vk(buffer_vk->b.buffer_object);
2339
2340 TRACE("Created buffer view 0x%s.\n", wine_dbgstr_longlong(vk_buffer_view));
2341
2342 uav_vk->view_vk.u.vk_buffer_view = vk_buffer_view;
2343 uav_vk->view_vk.bo_user.valid = true;
2344 list_add_head(&bo->b.users, &view_vk->bo_user.entry);
2345 }
2346
2347 if (desc->flags & (WINED3D_VIEW_BUFFER_COUNTER | WINED3D_VIEW_BUFFER_APPEND))
2348 {
2349 if (!wined3d_context_vk_create_bo(context_vk, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_SRC_BIT
2350 | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
2351 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &uav_vk->counter_bo))
2352 {
2353 ERR("Failed to create counter bo.\n");
2354 context_release(&context_vk->c);
2355
2356 return;
2357 }
2358
2359 wined3d_context_vk_end_current_render_pass(context_vk);
2360 VK_CALL(vkCmdFillBuffer(wined3d_context_vk_get_command_buffer(context_vk),
2361 uav_vk->counter_bo.vk_buffer, uav_vk->counter_bo.b.buffer_offset, sizeof(uint32_t), 0));
2362 wined3d_context_vk_reference_bo(context_vk, &uav_vk->counter_bo);
2363
2364 create_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
2365 create_info.pNext = NULL;
2366 create_info.flags = 0;
2367 create_info.buffer = uav_vk->counter_bo.vk_buffer;
2368 create_info.format = VK_FORMAT_R32_UINT;
2369 create_info.offset = uav_vk->counter_bo.b.buffer_offset;
2370 create_info.range = sizeof(uint32_t);
2371 if ((vr = VK_CALL(vkCreateBufferView(device_vk->vk_device,
2372 &create_info, NULL, &uav_vk->vk_counter_view))) < 0)
2373 {
2374 ERR("Failed to create counter buffer view, vr %s.\n", wined3d_debug_vkresult(vr));
2375 }
2376 else
2377 {
2378 TRACE("Created counter buffer view 0x%s.\n", wine_dbgstr_longlong(uav_vk->vk_counter_view));
2379
2380 uav_vk->v.counter_bo = &uav_vk->counter_bo.b;
2381 }
2382 }
2383
2384 context_release(&context_vk->c);
2385
2386 return;
2387 }
2388
2389 texture_vk = wined3d_texture_vk(texture_from_resource(resource));
2390
2391 if (texture_vk->t.layer_count > 1)
2392 default_flags |= WINED3D_VIEW_TEXTURE_ARRAY;
2393
2394 if (resource->format->id == format_vk->f.id && desc->flags == default_flags
2395 && !desc->u.texture.level_idx && desc->u.texture.level_count == texture_vk->t.level_count
2396 && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture_vk->t.layer_count
2397 && !(resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL) && resource->type != WINED3D_RTYPE_TEXTURE_3D)
2398 {
2399 TRACE("Creating identity unordered access view.\n");
2400 return;
2401 }
2402
2403 if (texture_vk->t.swapchain && texture_vk->t.swapchain->state.desc.backbuffer_count > 1)
2404 FIXME("Swapchain unordered access views not supported.\n");
2405
2406 context_vk = wined3d_context_vk(context_acquire(&device_vk->d, NULL, 0));
2407 vk_image_view = wined3d_view_vk_create_vk_image_view(context_vk, desc,
2408 texture_vk, format_vk, format_vk->f.color_fixup, false);
2409 context_release(&context_vk->c);
2410
2411 if (!vk_image_view)
2412 return;
2413
2414 TRACE("Created image view 0x%s.\n", wine_dbgstr_longlong(vk_image_view));
2415
2416 view_vk->u.vk_image_info.imageView = vk_image_view;
2417 view_vk->u.vk_image_info.sampler = VK_NULL_HANDLE;
2418 view_vk->u.vk_image_info.imageLayout = texture_vk->layout;
2419 }
2420
2421 HRESULT wined3d_unordered_access_view_vk_init(struct wined3d_unordered_access_view_vk *view_vk,
2422 const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
2423 void *parent, const struct wined3d_parent_ops *parent_ops)
2424 {
2425 HRESULT hr;
2426
2427 TRACE("view_vk %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
2428 view_vk, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
2429
2430 if (FAILED(hr = wined3d_unordered_access_view_init(&view_vk->v, desc, resource, parent, parent_ops)))
2431 return hr;
2432
2433 list_init(&view_vk->view_vk.bo_user.entry);
2434 wined3d_cs_init_object(resource->device->cs, wined3d_unordered_access_view_vk_cs_init, view_vk);
2435
2436 return hr;
2437 }
2438
2439 HRESULT CDECL wined3d_unordered_access_view_create(const struct wined3d_view_desc *desc,
2440 struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
2441 struct wined3d_unordered_access_view **view)
2442 {
2443 const struct wined3d_adapter_ops *adapter_ops;
2444
2445 TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
2446 wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
2447
2448 adapter_ops = resource->device->adapter->adapter_ops;
2449 return adapter_ops->adapter_create_unordered_access_view(desc, resource, parent, parent_ops, view);
2450 }
Windows API implementation