2 * Copyright 2002-2004 Jason Edmeades
3 * Copyright 2003-2004 Raphael Junqueira
4 * Copyright 2004 Christian Costa
5 * Copyright 2005 Oliver Stieber
6 * Copyright 2009-2010 Henri Verbeet for CodeWeavers
7 * Copyright 2006-2008, 2013 Stefan Dösinger for CodeWeavers
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
26 #include "wined3d_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
29 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf
);
31 static void resource_check_usage(DWORD usage
, unsigned int access
)
33 static const DWORD handled
= WINED3DUSAGE_DYNAMIC
34 | WINED3DUSAGE_STATICDECL
35 | WINED3DUSAGE_OVERLAY
36 | WINED3DUSAGE_SCRATCH
37 | WINED3DUSAGE_PRIVATE
38 | WINED3DUSAGE_LEGACY_CUBEMAP
41 /* Write-only CPU access is supposed to result in write-combined mappings
42 * being returned. OpenGL doesn't give us explicit control over that, but
43 * the hints and access flags we set for typical access patterns on
44 * dynamic resources should in theory have the same effect on the OpenGL
48 FIXME("Unhandled usage flags %#x.\n", usage
& ~handled
);
49 if (usage
& WINED3DUSAGE_DYNAMIC
&& access
& WINED3D_RESOURCE_ACCESS_MAP_R
)
50 WARN_(d3d_perf
)("WINED3DUSAGE_DYNAMIC used with WINED3D_RESOURCE_ACCESS_MAP_R.\n");
53 HRESULT
resource_init(struct wined3d_resource
*resource
, struct wined3d_device
*device
,
54 enum wined3d_resource_type type
, const struct wined3d_format
*format
,
55 enum wined3d_multisample_type multisample_type
, unsigned int multisample_quality
, unsigned int usage
,
56 unsigned int bind_flags
, unsigned int access
, unsigned int width
, unsigned int height
, unsigned int depth
,
57 unsigned int size
, void *parent
, const struct wined3d_parent_ops
*parent_ops
,
58 const struct wined3d_resource_ops
*resource_ops
)
60 const struct wined3d_d3d_info
*d3d_info
= &device
->adapter
->d3d_info
;
61 enum wined3d_gl_resource_type base_type
= WINED3D_GL_RES_TYPE_COUNT
;
62 enum wined3d_gl_resource_type gl_type
= WINED3D_GL_RES_TYPE_COUNT
;
63 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
64 BOOL tex_2d_ok
= FALSE
;
69 enum wined3d_resource_type type
;
71 enum wined3d_gl_resource_type gl_type
;
75 {WINED3D_RTYPE_BUFFER
, 0, WINED3D_GL_RES_TYPE_BUFFER
},
76 {WINED3D_RTYPE_TEXTURE_1D
, 0, WINED3D_GL_RES_TYPE_TEX_1D
},
77 {WINED3D_RTYPE_TEXTURE_2D
, 0, WINED3D_GL_RES_TYPE_TEX_2D
},
78 {WINED3D_RTYPE_TEXTURE_2D
, 0, WINED3D_GL_RES_TYPE_TEX_RECT
},
79 {WINED3D_RTYPE_TEXTURE_2D
, 0, WINED3D_GL_RES_TYPE_RB
},
80 {WINED3D_RTYPE_TEXTURE_2D
, WINED3DUSAGE_LEGACY_CUBEMAP
, WINED3D_GL_RES_TYPE_TEX_CUBE
},
81 {WINED3D_RTYPE_TEXTURE_3D
, 0, WINED3D_GL_RES_TYPE_TEX_3D
},
84 resource_check_usage(usage
, access
);
86 if (usage
& WINED3DUSAGE_SCRATCH
&& access
& WINED3D_RESOURCE_ACCESS_GPU
)
88 ERR("Trying to create a scratch resource with access flags %s.\n",
89 wined3d_debug_resource_access(access
));
90 return WINED3DERR_INVALIDCALL
;
93 if (bind_flags
& (WINED3D_BIND_RENDER_TARGET
| WINED3D_BIND_DEPTH_STENCIL
))
95 if ((access
& (WINED3D_RESOURCE_ACCESS_CPU
| WINED3D_RESOURCE_ACCESS_GPU
)) != WINED3D_RESOURCE_ACCESS_GPU
)
97 WARN("Bind flags %s are incompatible with resource access %s.\n",
98 wined3d_debug_bind_flags(bind_flags
), wined3d_debug_resource_access(access
));
99 return WINED3DERR_INVALIDCALL
;
102 /* Dynamic usage is incompatible with GPU writes. */
103 if (usage
& WINED3DUSAGE_DYNAMIC
)
105 WARN("Bind flags %s are incompatible with resource usage %s.\n",
106 wined3d_debug_bind_flags(bind_flags
), debug_d3dusage(usage
));
107 return WINED3DERR_INVALIDCALL
;
112 ERR("Attempting to create a zero-sized resource.\n");
114 for (i
= 0; i
< ARRAY_SIZE(resource_types
); ++i
)
116 if (resource_types
[i
].type
!= type
117 || resource_types
[i
].cube_usage
!= (usage
& WINED3DUSAGE_LEGACY_CUBEMAP
))
120 gl_type
= resource_types
[i
].gl_type
;
121 if (base_type
== WINED3D_GL_RES_TYPE_COUNT
)
124 if (type
!= WINED3D_RTYPE_BUFFER
)
126 if ((bind_flags
& WINED3D_BIND_RENDER_TARGET
)
127 && !(format
->flags
[gl_type
] & WINED3DFMT_FLAG_RENDERTARGET
))
129 WARN("Format %s cannot be used for render targets.\n", debug_d3dformat(format
->id
));
132 if ((bind_flags
& WINED3D_BIND_DEPTH_STENCIL
)
133 && !(format
->flags
[gl_type
] & WINED3DFMT_FLAG_DEPTH_STENCIL
))
135 WARN("Format %s cannot be used for depth/stencil buffers.\n", debug_d3dformat(format
->id
));
138 if ((bind_flags
& WINED3D_BIND_SHADER_RESOURCE
)
139 && !(format
->flags
[gl_type
] & WINED3DFMT_FLAG_TEXTURE
))
141 WARN("Format %s cannot be used for texturing.\n", debug_d3dformat(format
->id
));
145 if (((width
& (width
- 1)) || (height
& (height
- 1)))
146 && !d3d_info
->texture_npot
147 && !gl_info
->supported
[WINED3D_GL_NORMALIZED_TEXRECT
]
148 && gl_type
== WINED3D_GL_RES_TYPE_TEX_2D
)
150 TRACE("Skipping 2D texture type to try texture rectangle.\n");
157 if (base_type
!= WINED3D_GL_RES_TYPE_COUNT
&& i
== ARRAY_SIZE(resource_types
))
161 /* Non power of 2 texture and rectangle textures or renderbuffers do not work.
162 * Use 2D textures, the texture code will pad to a power of 2 size. */
163 gl_type
= WINED3D_GL_RES_TYPE_TEX_2D
;
165 else if (usage
& WINED3DUSAGE_SCRATCH
)
167 /* Needed for proper format information. */
172 WARN("Did not find a suitable GL resource type for resource type %s.\n",
173 debug_d3dresourcetype(type
));
174 return WINED3DERR_INVALIDCALL
;
178 if (base_type
!= WINED3D_GL_RES_TYPE_COUNT
179 && (format
->flags
[base_type
] & (WINED3DFMT_FLAG_BLOCKS
| WINED3DFMT_FLAG_BLOCKS_NO_VERIFY
))
180 == WINED3DFMT_FLAG_BLOCKS
)
182 UINT width_mask
= format
->block_width
- 1;
183 UINT height_mask
= format
->block_height
- 1;
184 if (width
& width_mask
|| height
& height_mask
)
185 return WINED3DERR_INVALIDCALL
;
189 resource
->device
= device
;
190 resource
->type
= type
;
191 resource
->gl_type
= gl_type
;
192 resource
->format
= format
;
193 if (gl_type
< WINED3D_GL_RES_TYPE_COUNT
)
194 resource
->format_flags
= format
->flags
[gl_type
];
195 resource
->multisample_type
= multisample_type
;
196 resource
->multisample_quality
= multisample_quality
;
197 resource
->usage
= usage
;
198 resource
->bind_flags
= bind_flags
;
199 if (resource
->format_flags
& WINED3DFMT_FLAG_MAPPABLE
)
200 access
|= WINED3D_RESOURCE_ACCESS_MAP_R
| WINED3D_RESOURCE_ACCESS_MAP_W
;
201 resource
->access
= access
;
202 resource
->width
= width
;
203 resource
->height
= height
;
204 resource
->depth
= depth
;
205 resource
->size
= size
;
206 resource
->priority
= 0;
207 resource
->parent
= parent
;
208 resource
->parent_ops
= parent_ops
;
209 resource
->resource_ops
= resource_ops
;
210 resource
->map_binding
= WINED3D_LOCATION_SYSMEM
;
211 resource
->heap_memory
= NULL
;
213 if (!(usage
& WINED3DUSAGE_PRIVATE
))
215 /* Check that we have enough video ram left */
216 if (!(access
& WINED3D_RESOURCE_ACCESS_CPU
) && device
->wined3d
->flags
& WINED3D_VIDMEM_ACCOUNTING
)
218 if (size
> wined3d_device_get_available_texture_mem(device
))
220 ERR("Out of adapter memory.\n");
221 return WINED3DERR_OUTOFVIDEOMEMORY
;
223 adapter_adjust_memory(device
->adapter
, size
);
226 device_resource_add(device
, resource
);
232 static void wined3d_resource_destroy_object(void *object
)
234 struct wined3d_resource
*resource
= object
;
236 TRACE("resource %p.\n", resource
);
238 wined3d_resource_free_sysmem(resource
);
239 context_resource_released(resource
->device
, resource
);
240 wined3d_resource_release(resource
);
243 void resource_cleanup(struct wined3d_resource
*resource
)
245 const struct wined3d
*d3d
= resource
->device
->wined3d
;
247 TRACE("Cleaning up resource %p.\n", resource
);
249 if (!(resource
->usage
& WINED3DUSAGE_PRIVATE
))
251 if (!(resource
->access
& WINED3D_RESOURCE_ACCESS_CPU
) && d3d
->flags
& WINED3D_VIDMEM_ACCOUNTING
)
253 TRACE("Decrementing device memory pool by %u.\n", resource
->size
);
254 adapter_adjust_memory(resource
->device
->adapter
, (INT64
)0 - resource
->size
);
257 device_resource_released(resource
->device
, resource
);
259 wined3d_resource_acquire(resource
);
260 wined3d_cs_destroy_object(resource
->device
->cs
, wined3d_resource_destroy_object
, resource
);
263 void resource_unload(struct wined3d_resource
*resource
)
265 if (resource
->map_count
)
266 ERR("Resource %p is being unloaded while mapped.\n", resource
);
269 DWORD CDECL
wined3d_resource_set_priority(struct wined3d_resource
*resource
, DWORD priority
)
273 if (!wined3d_resource_access_is_managed(resource
->access
))
275 WARN("Called on non-managed resource %p, ignoring.\n", resource
);
279 prev
= resource
->priority
;
280 resource
->priority
= priority
;
281 TRACE("resource %p, new priority %u, returning old priority %u.\n", resource
, priority
, prev
);
285 DWORD CDECL
wined3d_resource_get_priority(const struct wined3d_resource
*resource
)
287 TRACE("resource %p, returning %u.\n", resource
, resource
->priority
);
288 return resource
->priority
;
291 void * CDECL
wined3d_resource_get_parent(const struct wined3d_resource
*resource
)
293 return resource
->parent
;
296 void CDECL
wined3d_resource_set_parent(struct wined3d_resource
*resource
, void *parent
)
298 resource
->parent
= parent
;
301 void CDECL
wined3d_resource_get_desc(const struct wined3d_resource
*resource
, struct wined3d_resource_desc
*desc
)
303 desc
->resource_type
= resource
->type
;
304 desc
->format
= resource
->format
->id
;
305 desc
->multisample_type
= resource
->multisample_type
;
306 desc
->multisample_quality
= resource
->multisample_quality
;
307 desc
->usage
= resource
->usage
;
308 desc
->bind_flags
= resource
->bind_flags
;
309 desc
->access
= resource
->access
;
310 desc
->width
= resource
->width
;
311 desc
->height
= resource
->height
;
312 desc
->depth
= resource
->depth
;
313 desc
->size
= resource
->size
;
316 HRESULT CDECL
wined3d_resource_map(struct wined3d_resource
*resource
, unsigned int sub_resource_idx
,
317 struct wined3d_map_desc
*map_desc
, const struct wined3d_box
*box
, DWORD flags
)
319 TRACE("resource %p, sub_resource_idx %u, map_desc %p, box %s, flags %#x.\n",
320 resource
, sub_resource_idx
, map_desc
, debug_box(box
), flags
);
322 return wined3d_device_context_map(&resource
->device
->cs
->c
, resource
, sub_resource_idx
, map_desc
, box
, flags
);
325 HRESULT CDECL
wined3d_resource_unmap(struct wined3d_resource
*resource
, unsigned int sub_resource_idx
)
327 TRACE("resource %p, sub_resource_idx %u.\n", resource
, sub_resource_idx
);
329 return wined3d_device_context_unmap(&resource
->device
->cs
->c
, resource
, sub_resource_idx
);
332 void CDECL
wined3d_resource_preload(struct wined3d_resource
*resource
)
334 wined3d_cs_emit_preload_resource(resource
->device
->cs
, resource
);
337 static BOOL
wined3d_resource_allocate_sysmem(struct wined3d_resource
*resource
)
340 SIZE_T align
= RESOURCE_ALIGNMENT
- 1 + sizeof(*p
);
343 if (!(mem
= heap_alloc_zero(resource
->size
+ align
)))
345 ERR("Failed to allocate system memory.\n");
349 p
= (void **)(((ULONG_PTR
)mem
+ align
) & ~(RESOURCE_ALIGNMENT
- 1)) - 1;
352 resource
->heap_memory
= ++p
;
357 BOOL
wined3d_resource_prepare_sysmem(struct wined3d_resource
*resource
)
359 if (resource
->heap_memory
)
362 return wined3d_resource_allocate_sysmem(resource
);
365 void wined3d_resource_free_sysmem(struct wined3d_resource
*resource
)
367 void **p
= resource
->heap_memory
;
373 resource
->heap_memory
= NULL
;
376 GLbitfield
wined3d_resource_gl_storage_flags(const struct wined3d_resource
*resource
)
378 uint32_t access
= resource
->access
;
379 GLbitfield flags
= 0;
381 if (resource
->usage
& WINED3DUSAGE_DYNAMIC
)
382 flags
|= GL_CLIENT_STORAGE_BIT
;
383 if (access
& WINED3D_RESOURCE_ACCESS_MAP_W
)
384 flags
|= GL_MAP_WRITE_BIT
;
385 if (access
& WINED3D_RESOURCE_ACCESS_MAP_R
)
386 flags
|= GL_MAP_READ_BIT
;
391 GLbitfield
wined3d_resource_gl_map_flags(DWORD d3d_flags
)
395 if (d3d_flags
& WINED3D_MAP_WRITE
)
396 ret
|= GL_MAP_WRITE_BIT
| GL_MAP_FLUSH_EXPLICIT_BIT
;
397 if (d3d_flags
& WINED3D_MAP_READ
)
398 ret
|= GL_MAP_READ_BIT
;
400 ret
|= GL_MAP_UNSYNCHRONIZED_BIT
;
405 GLenum
wined3d_resource_gl_legacy_map_flags(DWORD d3d_flags
)
407 switch (d3d_flags
& (WINED3D_MAP_READ
| WINED3D_MAP_WRITE
))
409 case WINED3D_MAP_READ
:
410 return GL_READ_ONLY_ARB
;
412 case WINED3D_MAP_WRITE
:
413 return GL_WRITE_ONLY_ARB
;
416 return GL_READ_WRITE_ARB
;
420 BOOL
wined3d_resource_is_offscreen(struct wined3d_resource
*resource
)
422 struct wined3d_swapchain
*swapchain
;
424 /* Only 2D texture resources can be onscreen. */
425 if (resource
->type
!= WINED3D_RTYPE_TEXTURE_2D
)
428 /* Not on a swapchain - must be offscreen */
429 if (!(swapchain
= texture_from_resource(resource
)->swapchain
))
432 /* The front buffer is always onscreen */
433 if (resource
== &swapchain
->front_buffer
->resource
)
436 /* If the swapchain is rendered to an FBO, the backbuffer is
437 * offscreen, otherwise onscreen */
438 return swapchain
->render_to_fbo
;
441 void wined3d_resource_update_draw_binding(struct wined3d_resource
*resource
)
443 const struct wined3d_d3d_info
*d3d_info
= &resource
->device
->adapter
->d3d_info
;
445 if (!wined3d_resource_is_offscreen(resource
) || wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
)
447 resource
->draw_binding
= WINED3D_LOCATION_DRAWABLE
;
449 else if (resource
->multisample_type
)
451 resource
->draw_binding
= d3d_info
->multisample_draw_location
;
453 else if (resource
->gl_type
== WINED3D_GL_RES_TYPE_RB
)
455 resource
->draw_binding
= WINED3D_LOCATION_RB_RESOLVED
;
459 resource
->draw_binding
= WINED3D_LOCATION_TEXTURE_RGB
;
463 const struct wined3d_format
*wined3d_resource_get_decompress_format(const struct wined3d_resource
*resource
)
465 const struct wined3d_adapter
*adapter
= resource
->device
->adapter
;
466 if (resource
->format_flags
& (WINED3DFMT_FLAG_SRGB_READ
| WINED3DFMT_FLAG_SRGB_WRITE
)
467 && !(adapter
->d3d_info
.wined3d_creation_flags
& WINED3D_SRGB_READ_WRITE_CONTROL
))
468 return wined3d_get_format(adapter
, WINED3DFMT_B8G8R8A8_UNORM_SRGB
, resource
->bind_flags
);
469 return wined3d_get_format(adapter
, WINED3DFMT_B8G8R8A8_UNORM
, resource
->bind_flags
);
472 unsigned int wined3d_resource_get_sample_count(const struct wined3d_resource
*resource
)
474 const struct wined3d_format
*format
= resource
->format
;
476 /* TODO: NVIDIA expose their Coverage Sample Anti-Aliasing (CSAA)
477 * feature through type == MULTISAMPLE_XX and quality != 0. This could
478 * be mapped to GL_NV_framebuffer_multisample_coverage.
480 * AMD have a similar feature called Enhanced Quality Anti-Aliasing
481 * (EQAA), but it does not have an equivalent OpenGL extension. */
483 /* We advertise as many WINED3D_MULTISAMPLE_NON_MASKABLE quality
484 * levels as the count of advertised multisample types for the texture
486 if (resource
->multisample_type
== WINED3D_MULTISAMPLE_NON_MASKABLE
)
488 unsigned int i
, count
= 0;
490 for (i
= 0; i
< sizeof(format
->multisample_types
) * CHAR_BIT
; ++i
)
492 if (format
->multisample_types
& 1u << i
)
494 if (resource
->multisample_quality
== count
++)
501 return resource
->multisample_type
;
504 HRESULT
wined3d_resource_check_box_dimensions(struct wined3d_resource
*resource
,
505 unsigned int sub_resource_idx
, const struct wined3d_box
*box
)
507 const struct wined3d_format
*format
= resource
->format
;
508 struct wined3d_sub_resource_desc desc
;
509 unsigned int width_mask
, height_mask
;
511 wined3d_resource_get_sub_resource_desc(resource
, sub_resource_idx
, &desc
);
513 if (box
->left
>= box
->right
|| box
->right
> desc
.width
514 || box
->top
>= box
->bottom
|| box
->bottom
> desc
.height
515 || box
->front
>= box
->back
|| box
->back
> desc
.depth
)
517 WARN("Box %s is invalid.\n", debug_box(box
));
518 return WINEDDERR_INVALIDRECT
;
521 if (resource
->format_flags
& WINED3DFMT_FLAG_BLOCKS
)
523 /* This assumes power of two block sizes, but NPOT block sizes would
526 * This also assumes that the format's block depth is 1. */
527 width_mask
= format
->block_width
- 1;
528 height_mask
= format
->block_height
- 1;
530 if ((box
->left
& width_mask
) || (box
->top
& height_mask
)
531 || (box
->right
& width_mask
&& box
->right
!= desc
.width
)
532 || (box
->bottom
& height_mask
&& box
->bottom
!= desc
.height
))
534 WARN("Box %s is misaligned for %ux%u blocks.\n", debug_box(box
), format
->block_width
, format
->block_height
);
535 return WINED3DERR_INVALIDCALL
;
542 VkAccessFlags
vk_access_mask_from_bind_flags(uint32_t bind_flags
)
544 VkAccessFlags flags
= 0;
546 if (bind_flags
& WINED3D_BIND_VERTEX_BUFFER
)
547 flags
|= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
;
548 if (bind_flags
& WINED3D_BIND_INDEX_BUFFER
)
549 flags
|= VK_ACCESS_INDEX_READ_BIT
;
550 if (bind_flags
& WINED3D_BIND_CONSTANT_BUFFER
)
551 flags
|= VK_ACCESS_UNIFORM_READ_BIT
;
552 if (bind_flags
& WINED3D_BIND_SHADER_RESOURCE
)
553 flags
|= VK_ACCESS_SHADER_READ_BIT
;
554 if (bind_flags
& WINED3D_BIND_UNORDERED_ACCESS
)
555 flags
|= VK_ACCESS_SHADER_READ_BIT
| VK_ACCESS_SHADER_WRITE_BIT
;
556 if (bind_flags
& WINED3D_BIND_INDIRECT_BUFFER
)
557 flags
|= VK_ACCESS_INDIRECT_COMMAND_READ_BIT
;
558 if (bind_flags
& WINED3D_BIND_RENDER_TARGET
)
559 flags
|= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
;
560 if (bind_flags
& WINED3D_BIND_DEPTH_STENCIL
)
561 flags
|= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT
| VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
;
562 if (bind_flags
& WINED3D_BIND_STREAM_OUTPUT
)
563 flags
|= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT
;
568 VkPipelineStageFlags
vk_pipeline_stage_mask_from_bind_flags(uint32_t bind_flags
)
570 VkPipelineStageFlags flags
= 0;
572 if (bind_flags
& (WINED3D_BIND_VERTEX_BUFFER
| WINED3D_BIND_INDEX_BUFFER
))
573 flags
|= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
;
574 if (bind_flags
& (WINED3D_BIND_CONSTANT_BUFFER
| WINED3D_BIND_SHADER_RESOURCE
| WINED3D_BIND_UNORDERED_ACCESS
))
575 flags
|= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
| VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
576 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
| VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
577 | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
| VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
;
578 if (bind_flags
& WINED3D_BIND_INDIRECT_BUFFER
)
579 flags
|= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
;
580 if (bind_flags
& WINED3D_BIND_RENDER_TARGET
)
581 flags
|= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
;
582 if (bind_flags
& WINED3D_BIND_DEPTH_STENCIL
)
583 flags
|= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
;
584 if (bind_flags
& WINED3D_BIND_STREAM_OUTPUT
)
585 flags
|= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT
;