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 "wined3d_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  27 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  28
  29 static void resource_check_usage(uint32_t usage, unsigned int access)
  30 {
  31     static const uint32_t handled = WINED3DUSAGE_DYNAMIC
  32             | WINED3DUSAGE_STATICDECL
  33             | WINED3DUSAGE_OVERLAY
  34             | WINED3DUSAGE_SCRATCH
  35             | WINED3DUSAGE_MANAGED
  36             | WINED3DUSAGE_PRIVATE
  37             | WINED3DUSAGE_LEGACY_CUBEMAP
  38             | ~WINED3DUSAGE_MASK;
  39
  40     /* Write-only CPU access is supposed to result in write-combined mappings
  41      * being returned. OpenGL doesn't give us explicit control over that, but
  42      * the hints and access flags we set for typical access patterns on
  43      * dynamic resources should in theory have the same effect on the OpenGL
  44      * driver. */
  45
  46     if (usage & ~handled)
  47         FIXME("Unhandled usage flags %#x.\n", usage & ~handled);
  48     if (usage & WINED3DUSAGE_DYNAMIC && access & WINED3D_RESOURCE_ACCESS_MAP_R)
  49         WARN_(d3d_perf)("WINED3DUSAGE_DYNAMIC used with WINED3D_RESOURCE_ACCESS_MAP_R.\n");
  50 }
  51
  52 HRESULT resource_init(struct wined3d_resource *resource, struct wined3d_device *device,
  53         enum wined3d_resource_type type, const struct wined3d_format *format,
  54         enum wined3d_multisample_type multisample_type, unsigned int multisample_quality, uint32_t usage,
  55         unsigned int bind_flags, unsigned int access, unsigned int width, unsigned int height, unsigned int depth,
  56         unsigned int size, void *parent, const struct wined3d_parent_ops *parent_ops,
  57         const struct wined3d_resource_ops *resource_ops)
  58 {
  59     const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
  60     enum wined3d_gl_resource_type base_type = WINED3D_GL_RES_TYPE_COUNT;
  61     enum wined3d_gl_resource_type gl_type = WINED3D_GL_RES_TYPE_COUNT;
  62     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
  63     BOOL tex_2d_ok = FALSE;
  64     unsigned int i;
  65
  66     static const struct
  67     {
  68         enum wined3d_resource_type type;
  69         DWORD cube_usage;
  70         enum wined3d_gl_resource_type gl_type;
  71     }
  72     resource_types[] =
  73     {
  74         {WINED3D_RTYPE_BUFFER,      0,                              WINED3D_GL_RES_TYPE_BUFFER},
  75         {WINED3D_RTYPE_TEXTURE_1D,  0,                              WINED3D_GL_RES_TYPE_TEX_1D},
  76         {WINED3D_RTYPE_TEXTURE_2D,  0,                              WINED3D_GL_RES_TYPE_TEX_2D},
  77         {WINED3D_RTYPE_TEXTURE_2D,  0,                              WINED3D_GL_RES_TYPE_TEX_RECT},
  78         {WINED3D_RTYPE_TEXTURE_2D,  0,                              WINED3D_GL_RES_TYPE_RB},
  79         {WINED3D_RTYPE_TEXTURE_2D,  WINED3DUSAGE_LEGACY_CUBEMAP,    WINED3D_GL_RES_TYPE_TEX_CUBE},
  80         {WINED3D_RTYPE_TEXTURE_3D,  0,                              WINED3D_GL_RES_TYPE_TEX_3D},
  81     };
  82
  83     resource_check_usage(usage, access);
  84
  85     if (usage & WINED3DUSAGE_SCRATCH && access & WINED3D_RESOURCE_ACCESS_GPU)
  86     {
  87         ERR("Trying to create a scratch resource with access flags %s.\n",
  88                 wined3d_debug_resource_access(access));
  89         return WINED3DERR_INVALIDCALL;
  90     }
  91
  92     if (bind_flags & (WINED3D_BIND_RENDER_TARGET | WINED3D_BIND_DEPTH_STENCIL))
  93     {
  94         if ((access & (WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_GPU)) != WINED3D_RESOURCE_ACCESS_GPU)
  95         {
  96             WARN("Bind flags %s are incompatible with resource access %s.\n",
  97                     wined3d_debug_bind_flags(bind_flags), wined3d_debug_resource_access(access));
  98             return WINED3DERR_INVALIDCALL;
  99         }
 100
 101         /* Dynamic and managed usages are incompatible with GPU writes. */
 102         if (usage & (WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_MANAGED))
 103         {
 104             WARN("Bind flags %s are incompatible with resource usage %s.\n",
 105                     wined3d_debug_bind_flags(bind_flags), debug_d3dusage(usage));
 106             return WINED3DERR_INVALIDCALL;
 107         }
 108     }
 109
 110     if (!size)
 111         ERR("Attempting to create a zero-sized resource.\n");
 112
 113     for (i = 0; i < ARRAY_SIZE(resource_types); ++i)
 114     {
 115         if (resource_types[i].type != type
 116                 || resource_types[i].cube_usage != (usage & WINED3DUSAGE_LEGACY_CUBEMAP))
 117             continue;
 118
 119         gl_type = resource_types[i].gl_type;
 120         if (base_type == WINED3D_GL_RES_TYPE_COUNT)
 121             base_type = gl_type;
 122
 123         if (type == WINED3D_RTYPE_BUFFER)
 124             break;
 125
 126         if ((bind_flags & WINED3D_BIND_RENDER_TARGET)
 127                 && !(format->caps[gl_type] & WINED3D_FORMAT_CAP_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->caps[gl_type] & WINED3D_FORMAT_CAP_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->caps[gl_type] & WINED3D_FORMAT_CAP_TEXTURE))
 140         {
 141             WARN("Format %s cannot be used for texturing.\n", debug_d3dformat(format->id));
 142             continue;
 143         }
 144         if (((width & (width - 1)) || (height & (height - 1)))
 145                 && !d3d_info->texture_npot
 146                 && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT]
 147                 && gl_type == WINED3D_GL_RES_TYPE_TEX_2D)
 148         {
 149             TRACE("Skipping 2D texture type to try texture rectangle.\n");
 150             tex_2d_ok = TRUE;
 151             continue;
 152         }
 153         break;
 154     }
 155
 156     if (base_type != WINED3D_GL_RES_TYPE_COUNT && i == ARRAY_SIZE(resource_types))
 157     {
 158         if (tex_2d_ok)
 159         {
 160             /* Non power of 2 texture and rectangle textures or renderbuffers do not work.
 161              * Use 2D textures, the texture code will pad to a power of 2 size. */
 162             gl_type = WINED3D_GL_RES_TYPE_TEX_2D;
 163         }
 164         else if (usage & WINED3DUSAGE_SCRATCH)
 165         {
 166             /* Needed for proper format information. */
 167             gl_type = base_type;
 168         }
 169         else
 170         {
 171             WARN("Did not find a suitable GL resource type for resource type %s.\n",
 172                     debug_d3dresourcetype(type));
 173             return WINED3DERR_INVALIDCALL;
 174         }
 175     }
 176
 177     if (base_type != WINED3D_GL_RES_TYPE_COUNT
 178             && (format->attrs & (WINED3D_FORMAT_ATTR_BLOCKS | WINED3D_FORMAT_ATTR_BLOCKS_NO_VERIFY))
 179             == WINED3D_FORMAT_ATTR_BLOCKS)
 180     {
 181         UINT width_mask = format->block_width - 1;
 182         UINT height_mask = format->block_height - 1;
 183         if (width & width_mask || height & height_mask)
 184             return WINED3DERR_INVALIDCALL;
 185     }
 186
 187     resource->ref = 1;
 188     resource->device = device;
 189     resource->type = type;
 190     resource->gl_type = gl_type;
 191     resource->format = format;
 192     resource->format_attrs = format->attrs;
 193     if (gl_type < WINED3D_GL_RES_TYPE_COUNT)
 194         resource->format_caps = format->caps[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_attrs & WINED3D_FORMAT_ATTR_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     /* Check that we have enough video ram left */
 214     if (!(access & WINED3D_RESOURCE_ACCESS_CPU) && usage & WINED3DUSAGE_VIDMEM_ACCOUNTING)
 215     {
 216         if (size > wined3d_device_get_available_texture_mem(device))
 217         {
 218             ERR("Out of adapter memory.\n");
 219             return WINED3DERR_OUTOFVIDEOMEMORY;
 220         }
 221         adapter_adjust_memory(device->adapter, size);
 222     }
 223
 224     if (!(usage & WINED3DUSAGE_PRIVATE))
 225         device_resource_add(device, resource);
 226
 227     return WINED3D_OK;
 228 }
 229
 230 static void wined3d_resource_destroy_object(void *object)
 231 {
 232     struct wined3d_resource *resource = object;
 233
 234     TRACE("resource %p.\n", resource);
 235
 236     wined3d_resource_free_sysmem(resource);
 237     context_resource_released(resource->device, resource);
 238 }
 239
 240 void resource_cleanup(struct wined3d_resource *resource)
 241 {
 242     TRACE("Cleaning up resource %p.\n", resource);
 243
 244     if (!(resource->access & WINED3D_RESOURCE_ACCESS_CPU) && resource->usage & WINED3DUSAGE_VIDMEM_ACCOUNTING)
 245     {
 246         TRACE("Decrementing device memory pool by %u.\n", resource->size);
 247         adapter_adjust_memory(resource->device->adapter, (INT64)0 - resource->size);
 248     }
 249
 250     if (!(resource->usage & WINED3DUSAGE_PRIVATE))
 251         device_resource_released(resource->device, resource);
 252
 253     wined3d_resource_reference(resource);
 254     wined3d_cs_destroy_object(resource->device->cs, wined3d_resource_destroy_object, resource);
 255 }
 256
 257 void resource_unload(struct wined3d_resource *resource)
 258 {
 259     if (resource->map_count)
 260         ERR("Resource %p is being unloaded while mapped.\n", resource);
 261 }
 262
 263 unsigned int CDECL wined3d_resource_set_priority(struct wined3d_resource *resource, unsigned int priority)
 264 {
 265     unsigned int prev;
 266
 267     if (!(resource->usage & WINED3DUSAGE_MANAGED))
 268     {
 269         WARN("Called on non-managed resource %p, ignoring.\n", resource);
 270         return 0;
 271     }
 272
 273     prev = resource->priority;
 274     resource->priority = priority;
 275     TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev);
 276     return prev;
 277 }
 278
 279 unsigned int CDECL wined3d_resource_get_priority(const struct wined3d_resource *resource)
 280 {
 281     TRACE("resource %p, returning %u.\n", resource, resource->priority);
 282     return resource->priority;
 283 }
 284
 285 void * CDECL wined3d_resource_get_parent(const struct wined3d_resource *resource)
 286 {
 287     return resource->parent;
 288 }
 289
 290 void CDECL wined3d_resource_set_parent(struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
 291 {
 292     resource->parent = parent;
 293     resource->parent_ops = parent_ops;
 294 }
 295
 296 void CDECL wined3d_resource_get_desc(const struct wined3d_resource *resource, struct wined3d_resource_desc *desc)
 297 {
 298     desc->resource_type = resource->type;
 299     desc->format = resource->format->id;
 300     desc->multisample_type = resource->multisample_type;
 301     desc->multisample_quality = resource->multisample_quality;
 302     desc->usage = resource->usage;
 303     desc->bind_flags = resource->bind_flags;
 304     desc->access = resource->access;
 305     desc->width = resource->width;
 306     desc->height = resource->height;
 307     desc->depth = resource->depth;
 308     desc->size = resource->size;
 309 }
 310
 311 HRESULT CDECL wined3d_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx,
 312         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, uint32_t flags)
 313 {
 314     TRACE("resource %p, sub_resource_idx %u, map_desc %p, box %s, flags %#x.\n",
 315             resource, sub_resource_idx, map_desc, debug_box(box), flags);
 316
 317     return wined3d_device_context_map(&resource->device->cs->c, resource, sub_resource_idx, map_desc, box, flags);
 318 }
 319
 320 HRESULT CDECL wined3d_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx)
 321 {
 322     TRACE("resource %p, sub_resource_idx %u.\n", resource, sub_resource_idx);
 323
 324     return wined3d_device_context_unmap(&resource->device->cs->c, resource, sub_resource_idx);
 325 }
 326
 327 void CDECL wined3d_resource_preload(struct wined3d_resource *resource)
 328 {
 329     wined3d_cs_emit_preload_resource(resource->device->cs, resource);
 330 }
 331
 332 static BOOL wined3d_resource_allocate_sysmem(struct wined3d_resource *resource)
 333 {
 334     void **p;
 335     SIZE_T align = RESOURCE_ALIGNMENT - 1 + sizeof(*p);
 336     void *mem;
 337
 338     if (!(mem = heap_alloc_zero(resource->size + align)))
 339     {
 340         ERR("Failed to allocate system memory.\n");
 341         return FALSE;
 342     }
 343
 344     p = (void **)(((ULONG_PTR)mem + align) & ~(RESOURCE_ALIGNMENT - 1)) - 1;
 345     *p = mem;
 346
 347     resource->heap_memory = ++p;
 348
 349     return TRUE;
 350 }
 351
 352 BOOL wined3d_resource_prepare_sysmem(struct wined3d_resource *resource)
 353 {
 354     if (resource->heap_memory)
 355         return TRUE;
 356
 357     return wined3d_resource_allocate_sysmem(resource);
 358 }
 359
 360 void wined3d_resource_free_sysmem(struct wined3d_resource *resource)
 361 {
 362     void **p = resource->heap_memory;
 363
 364     if (!p)
 365         return;
 366
 367     heap_free(*(--p));
 368     resource->heap_memory = NULL;
 369 }
 370
 371 GLbitfield wined3d_resource_gl_storage_flags(const struct wined3d_resource *resource)
 372 {
 373     uint32_t access = resource->access;
 374     GLbitfield flags = 0;
 375
 376     if (resource->usage & WINED3DUSAGE_DYNAMIC)
 377         flags |= GL_CLIENT_STORAGE_BIT;
 378     if (!(access & WINED3D_RESOURCE_ACCESS_CPU))
 379     {
 380         if (access & WINED3D_RESOURCE_ACCESS_MAP_W)
 381             flags |= GL_MAP_WRITE_BIT;
 382         if (access & WINED3D_RESOURCE_ACCESS_MAP_R)
 383             flags |= GL_MAP_READ_BIT;
 384     }
 385
 386     return flags;
 387 }
 388
 389 GLbitfield wined3d_resource_gl_map_flags(const struct wined3d_bo_gl *bo, DWORD d3d_flags)
 390 {
 391     GLbitfield ret = 0;
 392
 393     if (d3d_flags & WINED3D_MAP_WRITE)
 394     {
 395         ret |= GL_MAP_WRITE_BIT;
 396         if (!bo->b.coherent)
 397             ret |= GL_MAP_FLUSH_EXPLICIT_BIT;
 398     }
 399     if (d3d_flags & WINED3D_MAP_READ)
 400         ret |= GL_MAP_READ_BIT;
 401     else
 402         ret |= GL_MAP_UNSYNCHRONIZED_BIT;
 403
 404     return ret;
 405 }
 406
 407 GLenum wined3d_resource_gl_legacy_map_flags(DWORD d3d_flags)
 408 {
 409     switch (d3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE))
 410     {
 411         case WINED3D_MAP_READ:
 412             return GL_READ_ONLY_ARB;
 413
 414         case WINED3D_MAP_WRITE:
 415             return GL_WRITE_ONLY_ARB;
 416
 417         default:
 418             return GL_READ_WRITE_ARB;
 419     }
 420 }
 421
 422 BOOL wined3d_resource_is_offscreen(struct wined3d_resource *resource)
 423 {
 424     struct wined3d_swapchain *swapchain;
 425
 426     /* Only 2D texture resources can be onscreen. */
 427     if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
 428         return TRUE;
 429
 430     /* Not on a swapchain - must be offscreen */
 431     if (!(swapchain = texture_from_resource(resource)->swapchain))
 432         return TRUE;
 433
 434     /* The front buffer is always onscreen */
 435     if (resource == &swapchain->front_buffer->resource)
 436         return FALSE;
 437
 438     /* If the swapchain is rendered to an FBO, the backbuffer is
 439      * offscreen, otherwise onscreen */
 440     return wined3d_settings.offscreen_rendering_mode == ORM_FBO;
 441 }
 442
 443 void wined3d_resource_update_draw_binding(struct wined3d_resource *resource)
 444 {
 445     const struct wined3d_d3d_info *d3d_info = &resource->device->adapter->d3d_info;
 446
 447     if (!wined3d_resource_is_offscreen(resource) || wined3d_settings.offscreen_rendering_mode != ORM_FBO)
 448     {
 449         resource->draw_binding = WINED3D_LOCATION_DRAWABLE;
 450     }
 451     else if (resource->multisample_type)
 452     {
 453         resource->draw_binding = d3d_info->multisample_draw_location;
 454     }
 455     else if (resource->gl_type == WINED3D_GL_RES_TYPE_RB)
 456     {
 457         resource->draw_binding = WINED3D_LOCATION_RB_RESOLVED;
 458     }
 459     else
 460     {
 461         resource->draw_binding = WINED3D_LOCATION_TEXTURE_RGB;
 462     }
 463 }
 464
 465 const struct wined3d_format *wined3d_resource_get_decompress_format(const struct wined3d_resource *resource)
 466 {
 467     const struct wined3d_adapter *adapter = resource->device->adapter;
 468     if (resource->format_caps & (WINED3D_FORMAT_CAP_SRGB_READ | WINED3D_FORMAT_CAP_SRGB_WRITE)
 469             && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL))
 470         return wined3d_get_format(adapter, WINED3DFMT_B8G8R8A8_UNORM_SRGB, resource->bind_flags);
 471     return wined3d_get_format(adapter, WINED3DFMT_B8G8R8A8_UNORM, resource->bind_flags);
 472 }
 473
 474 unsigned int wined3d_resource_get_sample_count(const struct wined3d_resource *resource)
 475 {
 476     const struct wined3d_format *format = resource->format;
 477
 478     /* TODO: NVIDIA expose their Coverage Sample Anti-Aliasing (CSAA)
 479      * feature through type == MULTISAMPLE_XX and quality != 0. This could
 480      * be mapped to GL_NV_framebuffer_multisample_coverage.
 481      *
 482      * AMD have a similar feature called Enhanced Quality Anti-Aliasing
 483      * (EQAA), but it does not have an equivalent OpenGL extension. */
 484
 485     /* We advertise as many WINED3D_MULTISAMPLE_NON_MASKABLE quality
 486      * levels as the count of advertised multisample types for the texture
 487      * format. */
 488     if (resource->multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE)
 489     {
 490         unsigned int i, count = 0;
 491
 492         for (i = 0; i < sizeof(format->multisample_types) * CHAR_BIT; ++i)
 493         {
 494             if (format->multisample_types & 1u << i)
 495             {
 496                 if (resource->multisample_quality == count++)
 497                     break;
 498             }
 499         }
 500         return i + 1;
 501     }
 502
 503     return resource->multisample_type;
 504 }
 505
 506 HRESULT wined3d_resource_check_box_dimensions(struct wined3d_resource *resource,
 507         unsigned int sub_resource_idx, const struct wined3d_box *box)
 508 {
 509     const struct wined3d_format *format = resource->format;
 510     struct wined3d_sub_resource_desc desc;
 511     unsigned int width_mask, height_mask;
 512
 513     wined3d_resource_get_sub_resource_desc(resource, sub_resource_idx, &desc);
 514
 515     if (box->left >= box->right || box->right > desc.width
 516             || box->top >= box->bottom || box->bottom > desc.height
 517             || box->front >= box->back || box->back > desc.depth)
 518     {
 519         WARN("Box %s is invalid.\n", debug_box(box));
 520         return WINEDDERR_INVALIDRECT;
 521     }
 522
 523     if (resource->format_attrs & WINED3D_FORMAT_ATTR_BLOCKS)
 524     {
 525         /* This assumes power of two block sizes, but NPOT block sizes would
 526          * be silly anyway.
 527          *
 528          * This also assumes that the format's block depth is 1. */
 529         width_mask = format->block_width - 1;
 530         height_mask = format->block_height - 1;
 531
 532         if ((box->left & width_mask) || (box->top & height_mask)
 533                 || (box->right & width_mask && box->right != desc.width)
 534                 || (box->bottom & height_mask && box->bottom != desc.height))
 535         {
 536             WARN("Box %s is misaligned for %ux%u blocks.\n", debug_box(box), format->block_width, format->block_height);
 537             return WINED3DERR_INVALIDCALL;
 538         }
 539     }
 540
 541     return WINED3D_OK;
 542 }
 543
 544 VkAccessFlags vk_access_mask_from_bind_flags(uint32_t bind_flags)
 545 {
 546     VkAccessFlags flags = 0;
 547
 548     if (bind_flags & WINED3D_BIND_VERTEX_BUFFER)
 549         flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 550     if (bind_flags & WINED3D_BIND_INDEX_BUFFER)
 551         flags |= VK_ACCESS_INDEX_READ_BIT;
 552     if (bind_flags & WINED3D_BIND_CONSTANT_BUFFER)
 553         flags |= VK_ACCESS_UNIFORM_READ_BIT;
 554     if (bind_flags & WINED3D_BIND_SHADER_RESOURCE)
 555         flags |= VK_ACCESS_SHADER_READ_BIT;
 556     if (bind_flags & WINED3D_BIND_UNORDERED_ACCESS)
 557         flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
 558     if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
 559         flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
 560     if (bind_flags & WINED3D_BIND_RENDER_TARGET)
 561         flags |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 562     if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
 563         flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 564     if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
 565         flags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
 566
 567     return flags;
 568 }
 569
 570 VkPipelineStageFlags vk_pipeline_stage_mask_from_bind_flags(uint32_t bind_flags)
 571 {
 572     VkPipelineStageFlags flags = 0;
 573
 574     if (bind_flags & (WINED3D_BIND_VERTEX_BUFFER | WINED3D_BIND_INDEX_BUFFER))
 575         flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
 576     if (bind_flags & (WINED3D_BIND_CONSTANT_BUFFER | WINED3D_BIND_SHADER_RESOURCE | WINED3D_BIND_UNORDERED_ACCESS))
 577         flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
 578                 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
 579                 | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 580     if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
 581         flags |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
 582     if (bind_flags & WINED3D_BIND_RENDER_TARGET)
 583         flags |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 584     if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
 585         flags |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
 586     if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
 587         flags |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
 588
 589     return flags;
 590 }
 591
 592 void *resource_offset_map_pointer(struct wined3d_resource *resource, unsigned int sub_resource_idx,
 593         uint8_t *base_memory, const struct wined3d_box *box)
 594 {
 595     const struct wined3d_format *format = resource->format;
 596     unsigned int row_pitch, slice_pitch;
 597
 598     wined3d_resource_get_sub_resource_map_pitch(resource, sub_resource_idx, &row_pitch, &slice_pitch);
 599
 600     if ((resource->format_attrs & (WINED3D_FORMAT_ATTR_BLOCKS | WINED3D_FORMAT_ATTR_BROKEN_PITCH))
 601             == WINED3D_FORMAT_ATTR_BLOCKS)
 602     {
 603         /* Compressed textures are block based, so calculate the offset of
 604          * the block that contains the top-left pixel of the mapped box. */
 605         return base_memory
 606                 + (box->front * slice_pitch)
 607                 + ((box->top / format->block_height) * row_pitch)
 608                 + ((box->left / format->block_width) * format->block_byte_count);
 609     }
 610     else
 611     {
 612         return base_memory
 613                 + (box->front * slice_pitch)
 614                 + (box->top * row_pitch)
 615                 + (box->left * format->byte_count);
 616     }
 617 }
 618
 619 void wined3d_resource_memory_colour_fill(struct wined3d_resource *resource,
 620         const struct wined3d_map_desc *map, const struct wined3d_color *colour,
 621         const struct wined3d_box *box, bool full_subresource)
 622 {
 623     const struct wined3d_format *format = resource->format;
 624     unsigned int w, h, d, x, y, z, bpp;
 625     uint8_t *dst, *dst2;
 626     uint32_t c[4];
 627
 628     /* Fast and simple path for setting everything to zero. The C library's memset is
 629      * more sophisticated than our code below. Also this works for block formats, which
 630      * we still need to zero-initialize for newly created resources. */
 631     if (full_subresource && !colour->r && !colour->g && !colour->b && !colour->a)
 632     {
 633         memset(map->data, 0, map->slice_pitch * box->back);
 634         return;
 635     }
 636
 637     w = box->right - box->left;
 638     h = box->bottom - box->top;
 639     d = box->back - box->front;
 640
 641     dst = (uint8_t *)map->data
 642             + (box->front * map->slice_pitch)
 643             + ((box->top / format->block_height) * map->row_pitch)
 644             + ((box->left / format->block_width) * format->block_byte_count);
 645
 646     wined3d_format_convert_from_float(format, colour, c);
 647     bpp = format->byte_count;
 648
 649     switch (bpp)
 650     {
 651         case 1:
 652             for (x = 0; x < w; ++x)
 653             {
 654                 dst[x] = c[0];
 655             }
 656             break;
 657
 658         case 2:
 659             for (x = 0; x < w; ++x)
 660             {
 661                 ((uint16_t *)dst)[x] = c[0];
 662             }
 663             break;
 664
 665         case 3:
 666         {
 667             dst2 = dst;
 668             for (x = 0; x < w; ++x, dst2 += 3)
 669             {
 670                 dst2[0] = (c[0]      ) & 0xff;
 671                 dst2[1] = (c[0] >>  8) & 0xff;
 672                 dst2[2] = (c[0] >> 16) & 0xff;
 673             }
 674             break;
 675         }
 676         case 4:
 677             for (x = 0; x < w; ++x)
 678             {
 679                 ((uint32_t *)dst)[x] = c[0];
 680             }
 681             break;
 682
 683         case 8:
 684         case 12:
 685         case 16:
 686             for (x = 0; x < w; ++x)
 687                 memcpy(((uint8_t *)map->data) + x * bpp, c, bpp);
 688             break;
 689
 690         default:
 691             FIXME("Not implemented for bpp %u.\n", bpp);
 692             return;
 693     }
 694
 695     dst2 = dst;
 696     for (y = 1; y < h; ++y)
 697     {
 698         dst2 += map->row_pitch;
 699         memcpy(dst2, dst, w * bpp);
 700     }
 701
 702     dst2 = dst;
 703     for (z = 1; z < d; ++z)
 704     {
 705         dst2 += map->slice_pitch;
 706         memcpy(dst2, dst, w * h * bpp);
 707     }
 708
 709 }