dlls/wined3d/resource.c

   1 /*
   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
   8  *
   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.
  13  *
  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.
  18  *
  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
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26 #include "wined3d_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  29 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  30
  31 static void resource_check_usage(DWORD usage, unsigned int access)
  32 {
  33     static const DWORD handled = WINED3DUSAGE_DYNAMIC
  34             | WINED3DUSAGE_STATICDECL
  35             | WINED3DUSAGE_OVERLAY
  36             | WINED3DUSAGE_SCRATCH
  37             | WINED3DUSAGE_PRIVATE
  38             | WINED3DUSAGE_LEGACY_CUBEMAP
  39             | ~WINED3DUSAGE_MASK;
  40
  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
  45      * driver. */
  46
  47     if (usage & ~handled)
  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");
  51 }
  52
  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)
  59 {
  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;
  65     unsigned int i;
  66
  67     static const struct
  68     {
  69         enum wined3d_resource_type type;
  70         DWORD cube_usage;
  71         enum wined3d_gl_resource_type gl_type;
  72     }
  73     resource_types[] =
  74     {
  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},
  82     };
  83
  84     resource_check_usage(usage, access);
  85
  86     if (usage & WINED3DUSAGE_SCRATCH && access & WINED3D_RESOURCE_ACCESS_GPU)
  87     {
  88         ERR("Trying to create a scratch resource with access flags %s.\n",
  89                 wined3d_debug_resource_access(access));
  90         return WINED3DERR_INVALIDCALL;
  91     }
  92
  93     if (bind_flags & (WINED3D_BIND_RENDER_TARGET | WINED3D_BIND_DEPTH_STENCIL))
  94     {
  95         if ((access & (WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_GPU)) != WINED3D_RESOURCE_ACCESS_GPU)
  96         {
  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;
 100         }
 101
 102         /* Dynamic usage is incompatible with GPU writes. */
 103         if (usage & WINED3DUSAGE_DYNAMIC)
 104         {
 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;
 108         }
 109     }
 110
 111     if (!size)
 112         ERR("Attempting to create a zero-sized resource.\n");
 113
 114     for (i = 0; i < ARRAY_SIZE(resource_types); ++i)
 115     {
 116         if (resource_types[i].type != type
 117                 || resource_types[i].cube_usage != (usage & WINED3DUSAGE_LEGACY_CUBEMAP))
 118             continue;
 119
 120         gl_type = resource_types[i].gl_type;
 121         if (base_type == WINED3D_GL_RES_TYPE_COUNT)
 122             base_type = gl_type;
 123
 124         if (type != WINED3D_RTYPE_BUFFER)
 125         {
 126             if ((bind_flags & WINED3D_BIND_RENDER_TARGET)
 127                     && !(format->flags[gl_type] & WINED3DFMT_FLAG_RENDERTARGET))
 128             {
 129                 WARN("Format %s cannot be used for render targets.\n", debug_d3dformat(format->id));
 130                 continue;
 131             }
 132             if ((bind_flags & WINED3D_BIND_DEPTH_STENCIL)
 133                     && !(format->flags[gl_type] & WINED3DFMT_FLAG_DEPTH_STENCIL))
 134             {
 135                 WARN("Format %s cannot be used for depth/stencil buffers.\n", debug_d3dformat(format->id));
 136                 continue;
 137             }
 138             if ((bind_flags & WINED3D_BIND_SHADER_RESOURCE)
 139                     && !(format->flags[gl_type] & WINED3DFMT_FLAG_TEXTURE))
 140             {
 141                 WARN("Format %s cannot be used for texturing.\n", debug_d3dformat(format->id));
 142                 continue;
 143             }
 144         }
 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)
 149         {
 150             TRACE("Skipping 2D texture type to try texture rectangle.\n");
 151             tex_2d_ok = TRUE;
 152             continue;
 153         }
 154         break;
 155     }
 156
 157     if (base_type != WINED3D_GL_RES_TYPE_COUNT && i == ARRAY_SIZE(resource_types))
 158     {
 159         if (tex_2d_ok)
 160         {
 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;
 164         }
 165         else if (usage & WINED3DUSAGE_SCRATCH)
 166         {
 167             /* Needed for proper format information. */
 168             gl_type = base_type;
 169         }
 170         else
 171         {
 172             WARN("Did not find a suitable GL resource type for resource type %s.\n",
 173                     debug_d3dresourcetype(type));
 174             return WINED3DERR_INVALIDCALL;
 175         }
 176     }
 177
 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)
 181     {
 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;
 186     }
 187
 188     resource->ref = 1;
 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;
 212
 213     if (!(usage & WINED3DUSAGE_PRIVATE))
 214     {
 215         /* Check that we have enough video ram left */
 216         if (!(access & WINED3D_RESOURCE_ACCESS_CPU) && device->wined3d->flags & WINED3D_VIDMEM_ACCOUNTING)
 217         {
 218             if (size > wined3d_device_get_available_texture_mem(device))
 219             {
 220                 ERR("Out of adapter memory.\n");
 221                 return WINED3DERR_OUTOFVIDEOMEMORY;
 222             }
 223             adapter_adjust_memory(device->adapter, size);
 224         }
 225
 226         device_resource_add(device, resource);
 227     }
 228
 229     return WINED3D_OK;
 230 }
 231
 232 static void wined3d_resource_destroy_object(void *object)
 233 {
 234     struct wined3d_resource *resource = object;
 235
 236     TRACE("resource %p.\n", resource);
 237
 238     heap_free(resource->sub_resource_bind_counts_device);
 239     wined3d_resource_free_sysmem(resource);
 240     context_resource_released(resource->device, resource);
 241     wined3d_resource_release(resource);
 242 }
 243
 244 void resource_cleanup(struct wined3d_resource *resource)
 245 {
 246     const struct wined3d *d3d = resource->device->wined3d;
 247
 248     TRACE("Cleaning up resource %p.\n", resource);
 249
 250     if (!(resource->usage & WINED3DUSAGE_PRIVATE))
 251     {
 252         if (!(resource->access & WINED3D_RESOURCE_ACCESS_CPU) && d3d->flags & WINED3D_VIDMEM_ACCOUNTING)
 253         {
 254             TRACE("Decrementing device memory pool by %u.\n", resource->size);
 255             adapter_adjust_memory(resource->device->adapter, (INT64)0 - resource->size);
 256         }
 257
 258         device_resource_released(resource->device, resource);
 259     }
 260     wined3d_resource_acquire(resource);
 261     wined3d_cs_destroy_object(resource->device->cs, wined3d_resource_destroy_object, resource);
 262 }
 263
 264 void resource_unload(struct wined3d_resource *resource)
 265 {
 266     if (resource->map_count)
 267         ERR("Resource %p is being unloaded while mapped.\n", resource);
 268 }
 269
 270 DWORD CDECL wined3d_resource_set_priority(struct wined3d_resource *resource, DWORD priority)
 271 {
 272     DWORD prev;
 273
 274     if (!wined3d_resource_access_is_managed(resource->access))
 275     {
 276         WARN("Called on non-managed resource %p, ignoring.\n", resource);
 277         return 0;
 278     }
 279
 280     prev = resource->priority;
 281     resource->priority = priority;
 282     TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev);
 283     return prev;
 284 }
 285
 286 DWORD CDECL wined3d_resource_get_priority(const struct wined3d_resource *resource)
 287 {
 288     TRACE("resource %p, returning %u.\n", resource, resource->priority);
 289     return resource->priority;
 290 }
 291
 292 void * CDECL wined3d_resource_get_parent(const struct wined3d_resource *resource)
 293 {
 294     return resource->parent;
 295 }
 296
 297 void CDECL wined3d_resource_set_parent(struct wined3d_resource *resource, void *parent)
 298 {
 299     resource->parent = parent;
 300 }
 301
 302 void CDECL wined3d_resource_get_desc(const struct wined3d_resource *resource, struct wined3d_resource_desc *desc)
 303 {
 304     desc->resource_type = resource->type;
 305     desc->format = resource->format->id;
 306     desc->multisample_type = resource->multisample_type;
 307     desc->multisample_quality = resource->multisample_quality;
 308     desc->usage = resource->usage;
 309     desc->bind_flags = resource->bind_flags;
 310     desc->access = resource->access;
 311     desc->width = resource->width;
 312     desc->height = resource->height;
 313     desc->depth = resource->depth;
 314     desc->size = resource->size;
 315 }
 316
 317 static DWORD wined3d_resource_sanitise_map_flags(const struct wined3d_resource *resource, DWORD flags)
 318 {
 319     /* Not all flags make sense together, but Windows never returns an error.
 320      * Catch the cases that could cause issues. */
 321     if (flags & WINED3D_MAP_READ)
 322     {
 323         if (flags & WINED3D_MAP_DISCARD)
 324         {
 325             WARN("WINED3D_MAP_READ combined with WINED3D_MAP_DISCARD, ignoring flags.\n");
 326             return flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE);
 327         }
 328         if (flags & WINED3D_MAP_NOOVERWRITE)
 329         {
 330             WARN("WINED3D_MAP_READ combined with WINED3D_MAP_NOOVERWRITE, ignoring flags.\n");
 331             return flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE);
 332         }
 333     }
 334     else if (flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE))
 335     {
 336         if (!(resource->usage & WINED3DUSAGE_DYNAMIC))
 337         {
 338             WARN("DISCARD or NOOVERWRITE map on non-dynamic buffer, ignoring.\n");
 339             return flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE);
 340         }
 341         if ((flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE))
 342                 == (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE))
 343         {
 344             WARN("WINED3D_MAP_NOOVERWRITE used with WINED3D_MAP_DISCARD, ignoring WINED3D_MAP_DISCARD.\n");
 345             flags &= ~WINED3D_MAP_DISCARD;
 346         }
 347     }
 348
 349     return flags;
 350 }
 351
 352 HRESULT CDECL wined3d_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx,
 353         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags)
 354 {
 355     TRACE("resource %p, sub_resource_idx %u, map_desc %p, box %s, flags %#x.\n",
 356             resource, sub_resource_idx, map_desc, debug_box(box), flags);
 357
 358     if (!(flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE)))
 359     {
 360         WARN("No read/write flags specified.\n");
 361         return E_INVALIDARG;
 362     }
 363
 364     if ((flags & WINED3D_MAP_READ) && !(resource->access & WINED3D_RESOURCE_ACCESS_MAP_R))
 365     {
 366         WARN("Resource does not have MAP_R access.\n");
 367         return E_INVALIDARG;
 368     }
 369
 370     if ((flags & WINED3D_MAP_WRITE) && !(resource->access & WINED3D_RESOURCE_ACCESS_MAP_W))
 371     {
 372         WARN("Resource does not have MAP_W access.\n");
 373         return E_INVALIDARG;
 374     }
 375
 376     flags = wined3d_resource_sanitise_map_flags(resource, flags);
 377     wined3d_resource_wait_idle(resource);
 378
 379     return wined3d_cs_map(resource->device->cs, resource, sub_resource_idx, map_desc, box, flags);
 380 }
 381
 382 HRESULT CDECL wined3d_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx)
 383 {
 384     TRACE("resource %p, sub_resource_idx %u.\n", resource, sub_resource_idx);
 385
 386     return wined3d_cs_unmap(resource->device->cs, resource, sub_resource_idx);
 387 }
 388
 389 void CDECL wined3d_resource_preload(struct wined3d_resource *resource)
 390 {
 391     wined3d_cs_emit_preload_resource(resource->device->cs, resource);
 392 }
 393
 394 static BOOL wined3d_resource_allocate_sysmem(struct wined3d_resource *resource)
 395 {
 396     void **p;
 397     SIZE_T align = RESOURCE_ALIGNMENT - 1 + sizeof(*p);
 398     void *mem;
 399
 400     if (!(mem = heap_alloc_zero(resource->size + align)))
 401     {
 402         ERR("Failed to allocate system memory.\n");
 403         return FALSE;
 404     }
 405
 406     p = (void **)(((ULONG_PTR)mem + align) & ~(RESOURCE_ALIGNMENT - 1)) - 1;
 407     *p = mem;
 408
 409     resource->heap_memory = ++p;
 410
 411     return TRUE;
 412 }
 413
 414 BOOL wined3d_resource_prepare_sysmem(struct wined3d_resource *resource)
 415 {
 416     if (resource->heap_memory)
 417         return TRUE;
 418
 419     return wined3d_resource_allocate_sysmem(resource);
 420 }
 421
 422 void wined3d_resource_free_sysmem(struct wined3d_resource *resource)
 423 {
 424     void **p = resource->heap_memory;
 425
 426     if (!p)
 427         return;
 428
 429     heap_free(*(--p));
 430     resource->heap_memory = NULL;
 431 }
 432
 433 GLbitfield wined3d_resource_gl_storage_flags(const struct wined3d_resource *resource)
 434 {
 435     uint32_t access = resource->access;
 436     GLbitfield flags = 0;
 437
 438     if (resource->usage & WINED3DUSAGE_DYNAMIC)
 439         flags |= GL_CLIENT_STORAGE_BIT;
 440     if (access & WINED3D_RESOURCE_ACCESS_MAP_W)
 441         flags |= GL_MAP_WRITE_BIT;
 442     if (access & WINED3D_RESOURCE_ACCESS_MAP_R)
 443         flags |= GL_MAP_READ_BIT;
 444
 445     return flags;
 446 }
 447
 448 GLbitfield wined3d_resource_gl_map_flags(DWORD d3d_flags)
 449 {
 450     GLbitfield ret = 0;
 451
 452     if (d3d_flags & WINED3D_MAP_WRITE)
 453         ret |= GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT;
 454     if (d3d_flags & WINED3D_MAP_READ)
 455         ret |= GL_MAP_READ_BIT;
 456     else
 457         ret |= GL_MAP_UNSYNCHRONIZED_BIT;
 458
 459     return ret;
 460 }
 461
 462 GLenum wined3d_resource_gl_legacy_map_flags(DWORD d3d_flags)
 463 {
 464     switch (d3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE))
 465     {
 466         case WINED3D_MAP_READ:
 467             return GL_READ_ONLY_ARB;
 468
 469         case WINED3D_MAP_WRITE:
 470             return GL_WRITE_ONLY_ARB;
 471
 472         default:
 473             return GL_READ_WRITE_ARB;
 474     }
 475 }
 476
 477 BOOL wined3d_resource_is_offscreen(struct wined3d_resource *resource)
 478 {
 479     struct wined3d_swapchain *swapchain;
 480
 481     /* Only 2D texture resources can be onscreen. */
 482     if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
 483         return TRUE;
 484
 485     /* Not on a swapchain - must be offscreen */
 486     if (!(swapchain = texture_from_resource(resource)->swapchain))
 487         return TRUE;
 488
 489     /* The front buffer is always onscreen */
 490     if (resource == &swapchain->front_buffer->resource)
 491         return FALSE;
 492
 493     /* If the swapchain is rendered to an FBO, the backbuffer is
 494      * offscreen, otherwise onscreen */
 495     return swapchain->render_to_fbo;
 496 }
 497
 498 void wined3d_resource_update_draw_binding(struct wined3d_resource *resource)
 499 {
 500     const struct wined3d_d3d_info *d3d_info = &resource->device->adapter->d3d_info;
 501
 502     if (!wined3d_resource_is_offscreen(resource) || wined3d_settings.offscreen_rendering_mode != ORM_FBO)
 503     {
 504         resource->draw_binding = WINED3D_LOCATION_DRAWABLE;
 505     }
 506     else if (resource->multisample_type)
 507     {
 508         resource->draw_binding = d3d_info->multisample_draw_location;
 509     }
 510     else if (resource->gl_type == WINED3D_GL_RES_TYPE_RB)
 511     {
 512         resource->draw_binding = WINED3D_LOCATION_RB_RESOLVED;
 513     }
 514     else
 515     {
 516         resource->draw_binding = WINED3D_LOCATION_TEXTURE_RGB;
 517     }
 518 }
 519
 520 const struct wined3d_format *wined3d_resource_get_decompress_format(const struct wined3d_resource *resource)
 521 {
 522     const struct wined3d_adapter *adapter = resource->device->adapter;
 523     if (resource->format_flags & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE)
 524             && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL))
 525         return wined3d_get_format(adapter, WINED3DFMT_B8G8R8A8_UNORM_SRGB, resource->bind_flags);
 526     return wined3d_get_format(adapter, WINED3DFMT_B8G8R8A8_UNORM, resource->bind_flags);
 527 }
 528
 529 unsigned int wined3d_resource_get_sample_count(const struct wined3d_resource *resource)
 530 {
 531     const struct wined3d_format *format = resource->format;
 532
 533     /* TODO: NVIDIA expose their Coverage Sample Anti-Aliasing (CSAA)
 534      * feature through type == MULTISAMPLE_XX and quality != 0. This could
 535      * be mapped to GL_NV_framebuffer_multisample_coverage.
 536      *
 537      * AMD have a similar feature called Enhanced Quality Anti-Aliasing
 538      * (EQAA), but it does not have an equivalent OpenGL extension. */
 539
 540     /* We advertise as many WINED3D_MULTISAMPLE_NON_MASKABLE quality
 541      * levels as the count of advertised multisample types for the texture
 542      * format. */
 543     if (resource->multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE)
 544     {
 545         unsigned int i, count = 0;
 546
 547         for (i = 0; i < sizeof(format->multisample_types) * CHAR_BIT; ++i)
 548         {
 549             if (format->multisample_types & 1u << i)
 550             {
 551                 if (resource->multisample_quality == count++)
 552                     break;
 553             }
 554         }
 555         return i + 1;
 556     }
 557
 558     return resource->multisample_type;
 559 }
 560
 561 VkAccessFlags vk_access_mask_from_bind_flags(uint32_t bind_flags)
 562 {
 563     VkAccessFlags flags = 0;
 564
 565     if (bind_flags & WINED3D_BIND_VERTEX_BUFFER)
 566         flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 567     if (bind_flags & WINED3D_BIND_INDEX_BUFFER)
 568         flags |= VK_ACCESS_INDEX_READ_BIT;
 569     if (bind_flags & WINED3D_BIND_CONSTANT_BUFFER)
 570         flags |= VK_ACCESS_UNIFORM_READ_BIT;
 571     if (bind_flags & WINED3D_BIND_SHADER_RESOURCE)
 572         flags |= VK_ACCESS_SHADER_READ_BIT;
 573     if (bind_flags & WINED3D_BIND_UNORDERED_ACCESS)
 574         flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
 575     if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
 576         flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
 577     if (bind_flags & WINED3D_BIND_RENDER_TARGET)
 578         flags |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 579     if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
 580         flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 581     if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
 582         flags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
 583
 584     return flags;
 585 }
 586
 587 VkPipelineStageFlags vk_pipeline_stage_mask_from_bind_flags(uint32_t bind_flags)
 588 {
 589     VkPipelineStageFlags flags = 0;
 590
 591     if (bind_flags & (WINED3D_BIND_VERTEX_BUFFER | WINED3D_BIND_INDEX_BUFFER))
 592         flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
 593     if (bind_flags & (WINED3D_BIND_CONSTANT_BUFFER | WINED3D_BIND_SHADER_RESOURCE | WINED3D_BIND_UNORDERED_ACCESS))
 594         flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
 595                 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
 596                 | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 597     if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
 598         flags |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
 599     if (bind_flags & WINED3D_BIND_RENDER_TARGET)
 600         flags |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 601     if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
 602         flags |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
 603     if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
 604         flags |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
 605
 606     return flags;
 607 }