dlls/wined3d/view.c

   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 "config.h"
  21 #include "wine/port.h"
  22
  23 #include "wined3d_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  26
  27 #define WINED3D_VIEW_CUBE_ARRAY (WINED3D_VIEW_TEXTURE_CUBE | WINED3D_VIEW_TEXTURE_ARRAY)
  28
  29 static BOOL is_stencil_view_format(const struct wined3d_format *format)
  30 {
  31     return format->id == WINED3DFMT_X24_TYPELESS_G8_UINT
  32             || format->id == WINED3DFMT_X32_TYPELESS_G8X24_UINT;
  33 }
  34
  35 static GLenum get_texture_view_target(const struct wined3d_gl_info *gl_info,
  36         const struct wined3d_view_desc *desc, const struct wined3d_texture *texture)
  37 {
  38     static const struct
  39     {
  40         GLenum texture_target;
  41         unsigned int view_flags;
  42         GLenum view_target;
  43         enum wined3d_gl_extension extension;
  44     }
  45     view_types[] =
  46     {
  47         {GL_TEXTURE_CUBE_MAP,  0,                          GL_TEXTURE_CUBE_MAP},
  48         {GL_TEXTURE_RECTANGLE, 0,                          GL_TEXTURE_RECTANGLE},
  49         {GL_TEXTURE_2D,        0,                          GL_TEXTURE_2D},
  50         {GL_TEXTURE_2D,        WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
  51         {GL_TEXTURE_2D_ARRAY,  0,                          GL_TEXTURE_2D},
  52         {GL_TEXTURE_2D_ARRAY,  WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
  53         {GL_TEXTURE_2D_ARRAY,  WINED3D_VIEW_TEXTURE_CUBE,  GL_TEXTURE_CUBE_MAP},
  54         {GL_TEXTURE_2D_ARRAY,  WINED3D_VIEW_CUBE_ARRAY,    GL_TEXTURE_CUBE_MAP_ARRAY, ARB_TEXTURE_CUBE_MAP_ARRAY},
  55         {GL_TEXTURE_3D,        0,                          GL_TEXTURE_3D},
  56     };
  57     unsigned int i;
  58
  59     for (i = 0; i < ARRAY_SIZE(view_types); ++i)
  60     {
  61         if (view_types[i].texture_target != texture->target || view_types[i].view_flags != desc->flags)
  62             continue;
  63         if (gl_info->supported[view_types[i].extension])
  64             return view_types[i].view_target;
  65
  66         FIXME("Extension %#x not supported.\n", view_types[i].extension);
  67     }
  68
  69     FIXME("Unhandled view flags %#x for texture target %#x.\n", desc->flags, texture->target);
  70     return texture->target;
  71 }
  72
  73 static const struct wined3d_format *validate_resource_view(const struct wined3d_view_desc *desc,
  74         struct wined3d_resource *resource, BOOL mip_slice, BOOL allow_srgb_toggle)
  75 {
  76     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
  77     const struct wined3d_format *format;
  78
  79     format = wined3d_get_format(gl_info, desc->format_id, resource->usage);
  80     if (resource->type == WINED3D_RTYPE_BUFFER && (desc->flags & WINED3D_VIEW_BUFFER_RAW))
  81     {
  82         if (format->id != WINED3DFMT_R32_TYPELESS)
  83         {
  84             WARN("Invalid format %s for raw buffer view.\n", debug_d3dformat(format->id));
  85             return NULL;
  86         }
  87
  88         format = wined3d_get_format(gl_info, WINED3DFMT_R32_UINT, resource->usage);
  89     }
  90
  91     if (wined3d_format_is_typeless(format))
  92     {
  93         WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(format->id));
  94         return NULL;
  95     }
  96
  97     if (resource->type == WINED3D_RTYPE_BUFFER)
  98     {
  99         struct wined3d_buffer *buffer = buffer_from_resource(resource);
 100         unsigned int buffer_size, element_size;
 101
 102         if (buffer->desc.structure_byte_stride)
 103         {
 104             if (desc->format_id != WINED3DFMT_UNKNOWN)
 105             {
 106                 WARN("Invalid format %s for structured buffer view.\n", debug_d3dformat(desc->format_id));
 107                 return NULL;
 108             }
 109
 110             format = wined3d_get_format(gl_info, WINED3DFMT_R32_UINT, resource->usage);
 111             element_size = buffer->desc.structure_byte_stride;
 112         }
 113         else
 114         {
 115             element_size = format->byte_count;
 116         }
 117
 118         if (!element_size)
 119             return NULL;
 120
 121         buffer_size = buffer->resource.size / element_size;
 122         if (desc->u.buffer.start_idx >= buffer_size
 123                 || desc->u.buffer.count > buffer_size - desc->u.buffer.start_idx)
 124             return NULL;
 125     }
 126     else
 127     {
 128         struct wined3d_texture *texture = texture_from_resource(resource);
 129         unsigned int depth_or_layer_count;
 130
 131         if (resource->format->id != format->id && !wined3d_format_is_typeless(resource->format)
 132                 && (!allow_srgb_toggle || !wined3d_formats_are_srgb_variants(resource->format->id, format->id)))
 133         {
 134             WARN("Trying to create incompatible view for non typeless format %s.\n",
 135                     debug_d3dformat(format->id));
 136             return NULL;
 137         }
 138
 139         if (mip_slice && resource->type == WINED3D_RTYPE_TEXTURE_3D)
 140             depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
 141         else
 142             depth_or_layer_count = texture->layer_count;
 143
 144         if (!desc->u.texture.level_count
 145                 || (mip_slice && desc->u.texture.level_count != 1)
 146                 || desc->u.texture.level_idx >= texture->level_count
 147                 || desc->u.texture.level_count > texture->level_count - desc->u.texture.level_idx
 148                 || !desc->u.texture.layer_count
 149                 || desc->u.texture.layer_idx >= depth_or_layer_count
 150                 || desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx)
 151             return NULL;
 152     }
 153
 154     return format;
 155 }
 156
 157 static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target,
 158         const struct wined3d_view_desc *desc, struct wined3d_texture *texture,
 159         const struct wined3d_format *view_format)
 160 {
 161     const struct wined3d_gl_info *gl_info;
 162     unsigned int layer_idx, layer_count;
 163     struct wined3d_context *context;
 164     GLuint texture_name;
 165
 166     view->target = view_target;
 167
 168     context = context_acquire(texture->resource.device, NULL, 0);
 169     gl_info = context->gl_info;
 170
 171     if (!gl_info->supported[ARB_TEXTURE_VIEW])
 172     {
 173         context_release(context);
 174         FIXME("OpenGL implementation does not support texture views.\n");
 175         return;
 176     }
 177
 178     wined3d_texture_prepare_texture(texture, context, FALSE);
 179     texture_name = wined3d_texture_get_texture_name(texture, context, FALSE);
 180
 181     layer_idx = desc->u.texture.layer_idx;
 182     layer_count = desc->u.texture.layer_count;
 183     if (view_target == GL_TEXTURE_3D && (layer_idx || layer_count != 1))
 184     {
 185         FIXME("Depth slice (%u-%u) not supported.\n", layer_idx, layer_count);
 186         layer_idx = 0;
 187         layer_count = 1;
 188     }
 189
 190     gl_info->gl_ops.gl.p_glGenTextures(1, &view->name);
 191     GL_EXTCALL(glTextureView(view->name, view->target, texture_name, view_format->glInternal,
 192             desc->u.texture.level_idx, desc->u.texture.level_count,
 193             layer_idx, layer_count));
 194     checkGLcall("Create texture view");
 195
 196     if (is_stencil_view_format(view_format))
 197     {
 198         static const GLint swizzle[] = {GL_ZERO, GL_RED, GL_ZERO, GL_ZERO};
 199
 200         if (!gl_info->supported[ARB_STENCIL_TEXTURING])
 201         {
 202             context_release(context);
 203             FIXME("OpenGL implementation does not support stencil texturing.\n");
 204             return;
 205         }
 206
 207         context_bind_texture(context, view->target, view->name);
 208         gl_info->gl_ops.gl.p_glTexParameteriv(view->target, GL_TEXTURE_SWIZZLE_RGBA, swizzle);
 209         gl_info->gl_ops.gl.p_glTexParameteri(view->target, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
 210         checkGLcall("Initialize stencil view");
 211
 212         context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
 213         context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
 214     }
 215
 216     context_release(context);
 217 }
 218
 219 static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_context *context,
 220         struct wined3d_buffer *buffer, const struct wined3d_format *view_format,
 221         unsigned int offset, unsigned int size)
 222 {
 223     const struct wined3d_gl_info *gl_info = context->gl_info;
 224
 225     if (!gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
 226     {
 227         FIXME("OpenGL implementation does not support buffer textures.\n");
 228         return;
 229     }
 230
 231     if ((offset & (gl_info->limits.texture_buffer_offset_alignment - 1)))
 232     {
 233         FIXME("Buffer offset %u is not %u byte aligned.\n",
 234                 offset, gl_info->limits.texture_buffer_offset_alignment);
 235         return;
 236     }
 237
 238     wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER);
 239
 240     view->target = GL_TEXTURE_BUFFER;
 241     gl_info->gl_ops.gl.p_glGenTextures(1, &view->name);
 242
 243     context_bind_texture(context, GL_TEXTURE_BUFFER, view->name);
 244     if (gl_info->supported[ARB_TEXTURE_BUFFER_RANGE])
 245     {
 246         GL_EXTCALL(glTexBufferRange(GL_TEXTURE_BUFFER, view_format->glInternal,
 247                 buffer->buffer_object, offset, size));
 248     }
 249     else
 250     {
 251         if (offset || size != buffer->resource.size)
 252             FIXME("OpenGL implementation does not support ARB_texture_buffer_range.\n");
 253         GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, view_format->glInternal, buffer->buffer_object));
 254     }
 255     checkGLcall("Create buffer texture");
 256
 257     context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
 258     context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
 259 }
 260
 261 static void get_buffer_view_range(const struct wined3d_buffer *buffer,
 262         const struct wined3d_view_desc *desc, const struct wined3d_format *view_format,
 263         unsigned int *offset, unsigned int *size)
 264 {
 265     if (desc->format_id == WINED3DFMT_UNKNOWN)
 266     {
 267         *offset = desc->u.buffer.start_idx * buffer->desc.structure_byte_stride;
 268         *size = desc->u.buffer.count * buffer->desc.structure_byte_stride;
 269     }
 270     else
 271     {
 272         *offset = desc->u.buffer.start_idx * view_format->byte_count;
 273         *size = desc->u.buffer.count * view_format->byte_count;
 274     }
 275 }
 276
 277 static void create_buffer_view(struct wined3d_gl_view *view, struct wined3d_context *context,
 278         const struct wined3d_view_desc *desc, struct wined3d_buffer *buffer,
 279         const struct wined3d_format *view_format)
 280 {
 281     unsigned int offset, size;
 282
 283     get_buffer_view_range(buffer, desc, view_format, &offset, &size);
 284     create_buffer_texture(view, context, buffer, view_format, offset, size);
 285 }
 286
 287 static void wined3d_view_invalidate_location(struct wined3d_resource *resource,
 288         const struct wined3d_view_desc *desc, DWORD location)
 289 {
 290     unsigned int i, sub_resource_idx, layer_count;
 291     struct wined3d_texture *texture;
 292
 293     if (resource->type == WINED3D_RTYPE_BUFFER)
 294     {
 295         wined3d_buffer_invalidate_location(buffer_from_resource(resource), location);
 296         return;
 297     }
 298
 299     texture = texture_from_resource(resource);
 300
 301     sub_resource_idx = desc->u.texture.layer_idx * texture->level_count + desc->u.texture.level_idx;
 302     layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? desc->u.texture.layer_count : 1;
 303     for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
 304         wined3d_texture_invalidate_location(texture, sub_resource_idx, location);
 305 }
 306
 307 ULONG CDECL wined3d_rendertarget_view_incref(struct wined3d_rendertarget_view *view)
 308 {
 309     ULONG refcount = InterlockedIncrement(&view->refcount);
 310
 311     TRACE("%p increasing refcount to %u.\n", view, refcount);
 312
 313     return refcount;
 314 }
 315
 316 static void wined3d_rendertarget_view_destroy_object(void *object)
 317 {
 318     struct wined3d_rendertarget_view *view = object;
 319     struct wined3d_device *device = view->resource->device;
 320
 321     if (view->gl_view.name)
 322     {
 323         const struct wined3d_gl_info *gl_info;
 324         struct wined3d_context *context;
 325
 326         context = context_acquire(device, NULL, 0);
 327         gl_info = context->gl_info;
 328         context_gl_resource_released(device, view->gl_view.name, FALSE);
 329         gl_info->gl_ops.gl.p_glDeleteTextures(1, &view->gl_view.name);
 330         checkGLcall("glDeleteTextures");
 331         context_release(context);
 332     }
 333
 334     HeapFree(GetProcessHeap(), 0, view);
 335 }
 336
 337 ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *view)
 338 {
 339     ULONG refcount = InterlockedDecrement(&view->refcount);
 340
 341     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 342
 343     if (!refcount)
 344     {
 345         struct wined3d_resource *resource = view->resource;
 346         struct wined3d_device *device = resource->device;
 347
 348         /* Call wined3d_object_destroyed() before releasing the resource,
 349          * since releasing the resource may end up destroying the parent. */
 350         view->parent_ops->wined3d_object_destroyed(view->parent);
 351         wined3d_cs_destroy_object(device->cs, wined3d_rendertarget_view_destroy_object, view);
 352         wined3d_resource_decref(resource);
 353     }
 354
 355     return refcount;
 356 }
 357
 358 void * CDECL wined3d_rendertarget_view_get_parent(const struct wined3d_rendertarget_view *view)
 359 {
 360     TRACE("view %p.\n", view);
 361
 362     return view->parent;
 363 }
 364
 365 void * CDECL wined3d_rendertarget_view_get_sub_resource_parent(const struct wined3d_rendertarget_view *view)
 366 {
 367     struct wined3d_texture *texture;
 368
 369     TRACE("view %p.\n", view);
 370
 371     if (view->resource->type == WINED3D_RTYPE_BUFFER)
 372         return wined3d_buffer_get_parent(buffer_from_resource(view->resource));
 373
 374     texture = texture_from_resource(view->resource);
 375
 376     return texture->sub_resources[view->sub_resource_idx].parent;
 377 }
 378
 379 void CDECL wined3d_rendertarget_view_set_parent(struct wined3d_rendertarget_view *view, void *parent)
 380 {
 381     TRACE("view %p, parent %p.\n", view, parent);
 382
 383     view->parent = parent;
 384 }
 385
 386 struct wined3d_resource * CDECL wined3d_rendertarget_view_get_resource(const struct wined3d_rendertarget_view *view)
 387 {
 388     TRACE("view %p.\n", view);
 389
 390     return view->resource;
 391 }
 392
 393 void wined3d_rendertarget_view_get_drawable_size(const struct wined3d_rendertarget_view *view,
 394         const struct wined3d_context *context, unsigned int *width, unsigned int *height)
 395 {
 396     const struct wined3d_texture *texture;
 397
 398     if (view->resource->type != WINED3D_RTYPE_TEXTURE_2D)
 399     {
 400         *width = view->width;
 401         *height = view->height;
 402         return;
 403     }
 404
 405     texture = texture_from_resource(view->resource);
 406     if (texture->swapchain)
 407     {
 408         /* The drawable size of an onscreen drawable is the surface size.
 409          * (Actually: The window size, but the surface is created in window
 410          * size.) */
 411         *width = texture->resource.width;
 412         *height = texture->resource.height;
 413     }
 414     else if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
 415     {
 416         const struct wined3d_swapchain *swapchain = context->swapchain;
 417
 418         /* The drawable size of a backbuffer / aux buffer offscreen target is
 419          * the size of the current context's drawable, which is the size of
 420          * the back buffer of the swapchain the active context belongs to. */
 421         *width = swapchain->desc.backbuffer_width;
 422         *height = swapchain->desc.backbuffer_height;
 423     }
 424     else
 425     {
 426         unsigned int level_idx = view->sub_resource_idx % texture->level_count;
 427
 428         /* The drawable size of an FBO target is the OpenGL texture size,
 429          * which is the power of two size. */
 430         *width = wined3d_texture_get_level_pow2_width(texture, level_idx);
 431         *height = wined3d_texture_get_level_pow2_height(texture, level_idx);
 432     }
 433 }
 434
 435 void wined3d_rendertarget_view_prepare_location(struct wined3d_rendertarget_view *view,
 436         struct wined3d_context *context, DWORD location)
 437 {
 438     struct wined3d_resource *resource = view->resource;
 439     unsigned int i, sub_resource_idx, layer_count;
 440     struct wined3d_texture *texture;
 441
 442     if (resource->type == WINED3D_RTYPE_BUFFER)
 443     {
 444         FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
 445         return;
 446     }
 447
 448     texture = texture_from_resource(resource);
 449     sub_resource_idx = view->sub_resource_idx;
 450     layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
 451     for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
 452         wined3d_texture_prepare_location(texture, sub_resource_idx, context, location);
 453 }
 454
 455 void wined3d_rendertarget_view_load_location(struct wined3d_rendertarget_view *view,
 456         struct wined3d_context *context, DWORD location)
 457 {
 458     struct wined3d_resource *resource = view->resource;
 459     unsigned int i, sub_resource_idx, layer_count;
 460     struct wined3d_texture *texture;
 461
 462     if (resource->type == WINED3D_RTYPE_BUFFER)
 463     {
 464         wined3d_buffer_load_location(buffer_from_resource(resource), context, location);
 465         return;
 466     }
 467
 468     texture = texture_from_resource(resource);
 469     sub_resource_idx = view->sub_resource_idx;
 470     layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
 471     for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
 472         wined3d_texture_load_location(texture, sub_resource_idx, context, location);
 473 }
 474
 475 void wined3d_rendertarget_view_validate_location(struct wined3d_rendertarget_view *view, DWORD location)
 476 {
 477     struct wined3d_resource *resource = view->resource;
 478     unsigned int i, sub_resource_idx, layer_count;
 479     struct wined3d_texture *texture;
 480
 481     if (resource->type == WINED3D_RTYPE_BUFFER)
 482     {
 483         FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
 484         return;
 485     }
 486
 487     texture = texture_from_resource(resource);
 488     sub_resource_idx = view->sub_resource_idx;
 489     layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
 490     for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
 491         wined3d_texture_validate_location(texture, sub_resource_idx, location);
 492 }
 493
 494 void wined3d_rendertarget_view_invalidate_location(struct wined3d_rendertarget_view *view, DWORD location)
 495 {
 496     wined3d_view_invalidate_location(view->resource, &view->desc, location);
 497 }
 498
 499 static void wined3d_render_target_view_cs_init(void *object)
 500 {
 501     struct wined3d_rendertarget_view *view = object;
 502     struct wined3d_resource *resource = view->resource;
 503     const struct wined3d_view_desc *desc = &view->desc;
 504
 505     if (resource->type == WINED3D_RTYPE_BUFFER)
 506     {
 507         FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
 508     }
 509     else
 510     {
 511         struct wined3d_texture *texture = texture_from_resource(resource);
 512         unsigned int depth_or_layer_count;
 513
 514         if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
 515             depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
 516         else
 517             depth_or_layer_count = texture->layer_count;
 518
 519         if (resource->format->id != view->format->id
 520                 || (view->layer_count != 1 && view->layer_count != depth_or_layer_count))
 521         {
 522             if (resource->format->gl_view_class != view->format->gl_view_class)
 523             {
 524                 FIXME("Render target view not supported, resource format %s, view format %s.\n",
 525                         debug_d3dformat(resource->format->id), debug_d3dformat(view->format->id));
 526                 return;
 527             }
 528             if (texture->swapchain && texture->swapchain->desc.backbuffer_count > 1)
 529             {
 530                 FIXME("Swapchain views not supported.\n");
 531                 return;
 532             }
 533
 534             create_texture_view(&view->gl_view, texture->target, desc, texture, view->format);
 535         }
 536     }
 537 }
 538
 539 static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view,
 540         const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
 541         void *parent, const struct wined3d_parent_ops *parent_ops)
 542 {
 543     BOOL allow_srgb_toggle = FALSE;
 544
 545     view->refcount = 1;
 546     view->parent = parent;
 547     view->parent_ops = parent_ops;
 548
 549     if (resource->type != WINED3D_RTYPE_BUFFER)
 550     {
 551         struct wined3d_texture *texture = texture_from_resource(resource);
 552
 553         if (texture->swapchain)
 554             allow_srgb_toggle = TRUE;
 555     }
 556     if (!(view->format = validate_resource_view(desc, resource, TRUE, allow_srgb_toggle)))
 557         return E_INVALIDARG;
 558     view->format_flags = view->format->flags[resource->gl_type];
 559     view->desc = *desc;
 560
 561     if (resource->type == WINED3D_RTYPE_BUFFER)
 562     {
 563         view->sub_resource_idx = 0;
 564         view->layer_count = 1;
 565         view->width = desc->u.buffer.count;
 566         view->height = 1;
 567     }
 568     else
 569     {
 570         struct wined3d_texture *texture = texture_from_resource(resource);
 571
 572         view->sub_resource_idx = desc->u.texture.level_idx;
 573         if (resource->type != WINED3D_RTYPE_TEXTURE_3D)
 574             view->sub_resource_idx += desc->u.texture.layer_idx * texture->level_count;
 575         view->layer_count = desc->u.texture.layer_count;
 576         view->width = wined3d_texture_get_level_width(texture, desc->u.texture.level_idx);
 577         view->height = wined3d_texture_get_level_height(texture, desc->u.texture.level_idx);
 578     }
 579
 580     wined3d_resource_incref(view->resource = resource);
 581
 582     wined3d_cs_init_object(resource->device->cs, wined3d_render_target_view_cs_init, view);
 583
 584     return WINED3D_OK;
 585 }
 586
 587 HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_view_desc *desc,
 588         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 589         struct wined3d_rendertarget_view **view)
 590 {
 591     struct wined3d_rendertarget_view *object;
 592     HRESULT hr;
 593
 594     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 595             desc, resource, parent, parent_ops, view);
 596
 597     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 598         return E_OUTOFMEMORY;
 599
 600     if (FAILED(hr = wined3d_rendertarget_view_init(object, desc, resource, parent, parent_ops)))
 601     {
 602         HeapFree(GetProcessHeap(), 0, object);
 603         WARN("Failed to initialise view, hr %#x.\n", hr);
 604         return hr;
 605     }
 606
 607     TRACE("Created render target view %p.\n", object);
 608     *view = object;
 609
 610     return hr;
 611 }
 612
 613 HRESULT CDECL wined3d_rendertarget_view_create_from_sub_resource(struct wined3d_texture *texture,
 614         unsigned int sub_resource_idx, void *parent, const struct wined3d_parent_ops *parent_ops,
 615         struct wined3d_rendertarget_view **view)
 616 {
 617     struct wined3d_view_desc desc;
 618
 619     TRACE("texture %p, sub_resource_idx %u, parent %p, parent_ops %p, view %p.\n",
 620             texture, sub_resource_idx, parent, parent_ops, view);
 621
 622     desc.format_id = texture->resource.format->id;
 623     desc.flags = 0;
 624     desc.u.texture.level_idx = sub_resource_idx % texture->level_count;
 625     desc.u.texture.level_count = 1;
 626     desc.u.texture.layer_idx = sub_resource_idx / texture->level_count;
 627     desc.u.texture.layer_count = 1;
 628
 629     return wined3d_rendertarget_view_create(&desc, &texture->resource, parent, parent_ops, view);
 630 }
 631
 632 ULONG CDECL wined3d_shader_resource_view_incref(struct wined3d_shader_resource_view *view)
 633 {
 634     ULONG refcount = InterlockedIncrement(&view->refcount);
 635
 636     TRACE("%p increasing refcount to %u.\n", view, refcount);
 637
 638     return refcount;
 639 }
 640
 641 static void wined3d_shader_resource_view_destroy_object(void *object)
 642 {
 643     struct wined3d_shader_resource_view *view = object;
 644
 645     if (view->gl_view.name)
 646     {
 647         const struct wined3d_gl_info *gl_info;
 648         struct wined3d_context *context;
 649
 650         context = context_acquire(view->resource->device, NULL, 0);
 651         gl_info = context->gl_info;
 652         gl_info->gl_ops.gl.p_glDeleteTextures(1, &view->gl_view.name);
 653         checkGLcall("glDeleteTextures");
 654         context_release(context);
 655     }
 656
 657     HeapFree(GetProcessHeap(), 0, view);
 658 }
 659
 660 ULONG CDECL wined3d_shader_resource_view_decref(struct wined3d_shader_resource_view *view)
 661 {
 662     ULONG refcount = InterlockedDecrement(&view->refcount);
 663
 664     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 665
 666     if (!refcount)
 667     {
 668         struct wined3d_resource *resource = view->resource;
 669         struct wined3d_device *device = resource->device;
 670
 671         /* Call wined3d_object_destroyed() before releasing the resource,
 672          * since releasing the resource may end up destroying the parent. */
 673         view->parent_ops->wined3d_object_destroyed(view->parent);
 674         wined3d_cs_destroy_object(device->cs, wined3d_shader_resource_view_destroy_object, view);
 675         wined3d_resource_decref(resource);
 676     }
 677
 678     return refcount;
 679 }
 680
 681 void * CDECL wined3d_shader_resource_view_get_parent(const struct wined3d_shader_resource_view *view)
 682 {
 683     TRACE("view %p.\n", view);
 684
 685     return view->parent;
 686 }
 687
 688 static void wined3d_shader_resource_view_cs_init(void *object)
 689 {
 690     struct wined3d_shader_resource_view *view = object;
 691     struct wined3d_resource *resource = view->resource;
 692     const struct wined3d_format *view_format;
 693     const struct wined3d_gl_info *gl_info;
 694     const struct wined3d_view_desc *desc;
 695     GLenum view_target;
 696
 697     view_format = view->format;
 698     gl_info = &resource->device->adapter->gl_info;
 699     desc = &view->desc;
 700
 701     if (resource->type == WINED3D_RTYPE_BUFFER)
 702     {
 703         struct wined3d_buffer *buffer = buffer_from_resource(resource);
 704         struct wined3d_context *context;
 705
 706         context = context_acquire(resource->device, NULL, 0);
 707         create_buffer_view(&view->gl_view, context, desc, buffer, view_format);
 708         context_release(context);
 709     }
 710     else
 711     {
 712         struct wined3d_texture *texture = texture_from_resource(resource);
 713
 714         view_target = get_texture_view_target(gl_info, desc, texture);
 715
 716         if (resource->format->id == view_format->id && texture->target == view_target
 717                 && !desc->u.texture.level_idx && desc->u.texture.level_count == texture->level_count
 718                 && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture->layer_count
 719                 && !is_stencil_view_format(view_format))
 720         {
 721             TRACE("Creating identity shader resource view.\n");
 722         }
 723         else if (texture->swapchain && texture->swapchain->desc.backbuffer_count > 1)
 724         {
 725             FIXME("Swapchain shader resource views not supported.\n");
 726         }
 727         else if (resource->format->typeless_id == view_format->typeless_id
 728                 && resource->format->gl_view_class == view_format->gl_view_class)
 729         {
 730             create_texture_view(&view->gl_view, view_target, desc, texture, view_format);
 731         }
 732         else if (wined3d_format_is_depth_view(resource->format->id, view_format->id))
 733         {
 734             create_texture_view(&view->gl_view, view_target, desc, texture, resource->format);
 735         }
 736         else
 737         {
 738             FIXME("Shader resource view not supported, resource format %s, view format %s.\n",
 739                     debug_d3dformat(resource->format->id), debug_d3dformat(view_format->id));
 740         }
 741     }
 742 }
 743
 744 static HRESULT wined3d_shader_resource_view_init(struct wined3d_shader_resource_view *view,
 745         const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
 746         void *parent, const struct wined3d_parent_ops *parent_ops)
 747 {
 748     view->refcount = 1;
 749     view->parent = parent;
 750     view->parent_ops = parent_ops;
 751
 752     if (!(view->format = validate_resource_view(desc, resource, FALSE, FALSE)))
 753         return E_INVALIDARG;
 754     view->desc = *desc;
 755
 756     wined3d_resource_incref(view->resource = resource);
 757
 758     wined3d_cs_init_object(resource->device->cs, wined3d_shader_resource_view_cs_init, view);
 759
 760     return WINED3D_OK;
 761 }
 762
 763 HRESULT CDECL wined3d_shader_resource_view_create(const struct wined3d_view_desc *desc,
 764         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 765         struct wined3d_shader_resource_view **view)
 766 {
 767     struct wined3d_shader_resource_view *object;
 768     HRESULT hr;
 769
 770     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 771             desc, resource, parent, parent_ops, view);
 772
 773     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 774         return E_OUTOFMEMORY;
 775
 776     if (FAILED(hr = wined3d_shader_resource_view_init(object, desc, resource, parent, parent_ops)))
 777     {
 778         HeapFree(GetProcessHeap(), 0, object);
 779         WARN("Failed to initialise view, hr %#x.\n", hr);
 780         return hr;
 781     }
 782
 783     TRACE("Created shader resource view %p.\n", object);
 784     *view = object;
 785
 786     return WINED3D_OK;
 787 }
 788
 789 void wined3d_shader_resource_view_bind(struct wined3d_shader_resource_view *view,
 790         unsigned int unit, struct wined3d_sampler *sampler, struct wined3d_context *context)
 791 {
 792     const struct wined3d_gl_info *gl_info = context->gl_info;
 793     struct wined3d_texture *texture;
 794
 795     context_active_texture(context, gl_info, unit);
 796
 797     if (view->gl_view.name)
 798     {
 799         context_bind_texture(context, view->gl_view.target, view->gl_view.name);
 800         wined3d_sampler_bind(sampler, unit, NULL, context);
 801         return;
 802     }
 803
 804     if (view->resource->type == WINED3D_RTYPE_BUFFER)
 805     {
 806         FIXME("Buffer shader resources not supported.\n");
 807         return;
 808     }
 809
 810     texture = wined3d_texture_from_resource(view->resource);
 811     wined3d_texture_bind(texture, context, FALSE);
 812     wined3d_sampler_bind(sampler, unit, texture, context);
 813 }
 814
 815 /* Context activation is done by the caller. */
 816 static void shader_resource_view_bind_and_dirtify(struct wined3d_shader_resource_view *view,
 817         struct wined3d_context *context)
 818 {
 819     if (context->active_texture < ARRAY_SIZE(context->rev_tex_unit_map))
 820     {
 821         DWORD active_sampler = context->rev_tex_unit_map[context->active_texture];
 822         if (active_sampler != WINED3D_UNMAPPED_STAGE)
 823             context_invalidate_state(context, STATE_SAMPLER(active_sampler));
 824     }
 825     /* FIXME: Ideally we'd only do this when touching a binding that's used by
 826      * a shader. */
 827     context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
 828     context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
 829
 830     context_bind_texture(context, view->gl_view.target, view->gl_view.name);
 831 }
 832
 833 void shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view)
 834 {
 835     struct wined3d_texture *texture = texture_from_resource(view->resource);
 836     unsigned int i, j, layer_count, level_count, base_level, max_level;
 837     const struct wined3d_gl_info *gl_info;
 838     struct wined3d_context *context;
 839     struct gl_texture *gl_tex;
 840     DWORD location;
 841     BOOL srgb;
 842
 843     TRACE("view %p.\n", view);
 844
 845     context = context_acquire(view->resource->device, NULL, 0);
 846     gl_info = context->gl_info;
 847     layer_count = view->desc.u.texture.layer_count;
 848     level_count = view->desc.u.texture.level_count;
 849     base_level = view->desc.u.texture.level_idx;
 850     max_level = base_level + level_count - 1;
 851
 852     srgb = !!(texture->flags & WINED3D_TEXTURE_IS_SRGB);
 853     location = srgb ? WINED3D_LOCATION_TEXTURE_SRGB : WINED3D_LOCATION_TEXTURE_RGB;
 854     for (i = 0; i < layer_count; ++i)
 855         wined3d_texture_load_location(texture, i * level_count + base_level, context, location);
 856
 857     if (view->gl_view.name)
 858     {
 859         shader_resource_view_bind_and_dirtify(view, context);
 860     }
 861     else
 862     {
 863         wined3d_texture_bind_and_dirtify(texture, context, srgb);
 864         gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, base_level);
 865         gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, max_level);
 866     }
 867
 868     if (gl_info->supported[ARB_SAMPLER_OBJECTS])
 869         GL_EXTCALL(glBindSampler(context->active_texture, 0));
 870     gl_tex = wined3d_texture_get_gl_texture(texture, srgb);
 871     if (context->d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
 872     {
 873         gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_SRGB_DECODE_EXT,
 874                 GL_SKIP_DECODE_EXT);
 875         gl_tex->sampler_desc.srgb_decode = FALSE;
 876     }
 877
 878     gl_info->fbo_ops.glGenerateMipmap(texture->target);
 879     checkGLcall("glGenerateMipMap()");
 880
 881     for (i = 0; i < layer_count; ++i)
 882     {
 883         for (j = base_level + 1; j <= max_level; ++j)
 884         {
 885             wined3d_texture_validate_location(texture, i * level_count + j, location);
 886             wined3d_texture_invalidate_location(texture, i * level_count + j, ~location);
 887         }
 888     }
 889
 890     if (!view->gl_view.name)
 891     {
 892         gl_tex->base_level = base_level;
 893         gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, texture->level_count - 1);
 894     }
 895
 896     context_release(context);
 897 }
 898
 899 void CDECL wined3d_shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view)
 900 {
 901     struct wined3d_texture *texture;
 902
 903     TRACE("view %p.\n", view);
 904
 905     if (view->resource->type == WINED3D_RTYPE_BUFFER)
 906     {
 907         WARN("Called on buffer resource %p.\n", view->resource);
 908         return;
 909     }
 910
 911     texture = texture_from_resource(view->resource);
 912     if (!(texture->flags & WINED3D_TEXTURE_GENERATE_MIPMAPS))
 913     {
 914         WARN("Texture without the WINED3D_TEXTURE_GENERATE_MIPMAPS flag, ignoring.\n");
 915         return;
 916     }
 917
 918     wined3d_cs_emit_generate_mipmaps(view->resource->device->cs, view);
 919 }
 920
 921 ULONG CDECL wined3d_unordered_access_view_incref(struct wined3d_unordered_access_view *view)
 922 {
 923     ULONG refcount = InterlockedIncrement(&view->refcount);
 924
 925     TRACE("%p increasing refcount to %u.\n", view, refcount);
 926
 927     return refcount;
 928 }
 929
 930 static void wined3d_unordered_access_view_destroy_object(void *object)
 931 {
 932     struct wined3d_unordered_access_view *view = object;
 933
 934     if (view->gl_view.name || view->counter_bo)
 935     {
 936         const struct wined3d_gl_info *gl_info;
 937         struct wined3d_context *context;
 938
 939         context = context_acquire(view->resource->device, NULL, 0);
 940         gl_info = context->gl_info;
 941         if (view->gl_view.name)
 942             gl_info->gl_ops.gl.p_glDeleteTextures(1, &view->gl_view.name);
 943         if (view->counter_bo)
 944             GL_EXTCALL(glDeleteBuffers(1, &view->counter_bo));
 945         checkGLcall("delete resources");
 946         context_release(context);
 947     }
 948
 949     HeapFree(GetProcessHeap(), 0, view);
 950 }
 951
 952 ULONG CDECL wined3d_unordered_access_view_decref(struct wined3d_unordered_access_view *view)
 953 {
 954     ULONG refcount = InterlockedDecrement(&view->refcount);
 955
 956     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 957
 958     if (!refcount)
 959     {
 960         struct wined3d_resource *resource = view->resource;
 961         struct wined3d_device *device = resource->device;
 962
 963         /* Call wined3d_object_destroyed() before releasing the resource,
 964          * since releasing the resource may end up destroying the parent. */
 965         view->parent_ops->wined3d_object_destroyed(view->parent);
 966         wined3d_cs_destroy_object(device->cs, wined3d_unordered_access_view_destroy_object, view);
 967         wined3d_resource_decref(resource);
 968     }
 969
 970     return refcount;
 971 }
 972
 973 void * CDECL wined3d_unordered_access_view_get_parent(const struct wined3d_unordered_access_view *view)
 974 {
 975     TRACE("view %p.\n", view);
 976
 977     return view->parent;
 978 }
 979
 980 void wined3d_unordered_access_view_invalidate_location(struct wined3d_unordered_access_view *view,
 981         DWORD location)
 982 {
 983     wined3d_view_invalidate_location(view->resource, &view->desc, location);
 984 }
 985
 986 void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_view *view,
 987         const struct wined3d_uvec4 *clear_value, struct wined3d_context *context)
 988 {
 989     const struct wined3d_gl_info *gl_info = context->gl_info;
 990     const struct wined3d_format *format;
 991     struct wined3d_resource *resource;
 992     struct wined3d_buffer *buffer;
 993     unsigned int offset, size;
 994
 995     resource = view->resource;
 996     if (resource->type != WINED3D_RTYPE_BUFFER)
 997     {
 998         FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type));
 999         return;
1000     }
1001
1002     if (!gl_info->supported[ARB_CLEAR_BUFFER_OBJECT])
1003     {
1004         FIXME("OpenGL implementation does not support ARB_clear_buffer_object.\n");
1005         return;
1006     }
1007
1008     format = view->format;
1009     if (format->id != WINED3DFMT_R32_UINT && format->id != WINED3DFMT_R32_SINT
1010             && format->id != WINED3DFMT_R32G32B32A32_UINT
1011             && format->id != WINED3DFMT_R32G32B32A32_SINT)
1012     {
1013         FIXME("Not implemented for format %s.\n", debug_d3dformat(format->id));
1014         return;
1015     }
1016
1017     buffer = buffer_from_resource(resource);
1018     wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER);
1019     wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_BUFFER);
1020
1021     get_buffer_view_range(buffer, &view->desc, format, &offset, &size);
1022     context_bind_bo(context, buffer->buffer_type_hint, buffer->buffer_object);
1023     GL_EXTCALL(glClearBufferSubData(buffer->buffer_type_hint, format->glInternal,
1024             offset, size, format->glFormat, format->glType, clear_value));
1025     checkGLcall("clear unordered access view");
1026 }
1027
1028 void wined3d_unordered_access_view_set_counter(struct wined3d_unordered_access_view *view,
1029         unsigned int value)
1030 {
1031     const struct wined3d_gl_info *gl_info;
1032     struct wined3d_context *context;
1033
1034     if (!view->counter_bo)
1035         return;
1036
1037     context = context_acquire(view->resource->device, NULL, 0);
1038     gl_info = context->gl_info;
1039     GL_EXTCALL(glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, view->counter_bo));
1040     GL_EXTCALL(glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(value), &value));
1041     checkGLcall("set atomic counter");
1042     context_release(context);
1043 }
1044
1045 void wined3d_unordered_access_view_copy_counter(struct wined3d_unordered_access_view *view,
1046         struct wined3d_buffer *buffer, unsigned int offset, struct wined3d_context *context)
1047 {
1048     struct wined3d_bo_address dst, src;
1049     DWORD dst_location;
1050
1051     if (!view->counter_bo)
1052         return;
1053
1054     dst_location = wined3d_buffer_get_memory(buffer, &dst, buffer->locations);
1055     dst.addr += offset;
1056
1057     src.buffer_object = view->counter_bo;
1058     src.addr = NULL;
1059
1060     context_copy_bo_address(context, &dst, buffer->buffer_type_hint,
1061             &src, GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint));
1062
1063     wined3d_buffer_invalidate_location(buffer, ~dst_location);
1064 }
1065
1066 static void wined3d_unordered_access_view_cs_init(void *object)
1067 {
1068     struct wined3d_unordered_access_view *view = object;
1069     struct wined3d_resource *resource = view->resource;
1070     struct wined3d_view_desc *desc = &view->desc;
1071     const struct wined3d_gl_info *gl_info;
1072
1073     gl_info = &resource->device->adapter->gl_info;
1074
1075     if (resource->type == WINED3D_RTYPE_BUFFER)
1076     {
1077         struct wined3d_buffer *buffer = buffer_from_resource(resource);
1078         struct wined3d_context *context;
1079
1080         context = context_acquire(resource->device, NULL, 0);
1081         gl_info = context->gl_info;
1082         create_buffer_view(&view->gl_view, context, desc, buffer, view->format);
1083         if (desc->flags & (WINED3D_VIEW_BUFFER_COUNTER | WINED3D_VIEW_BUFFER_APPEND))
1084         {
1085             static const GLuint initial_value = 0;
1086             GL_EXTCALL(glGenBuffers(1, &view->counter_bo));
1087             GL_EXTCALL(glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, view->counter_bo));
1088             GL_EXTCALL(glBufferData(GL_ATOMIC_COUNTER_BUFFER,
1089                     sizeof(initial_value), &initial_value, GL_STATIC_DRAW));
1090             checkGLcall("create atomic counter buffer");
1091         }
1092         context_release(context);
1093     }
1094     else
1095     {
1096         struct wined3d_texture *texture = texture_from_resource(resource);
1097         unsigned int depth_or_layer_count;
1098
1099         if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
1100             depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
1101         else
1102             depth_or_layer_count = texture->layer_count;
1103
1104         if (desc->u.texture.layer_idx || desc->u.texture.layer_count != depth_or_layer_count)
1105         {
1106             create_texture_view(&view->gl_view, get_texture_view_target(gl_info, desc, texture),
1107                     desc, texture, view->format);
1108         }
1109     }
1110 }
1111
1112 static HRESULT wined3d_unordered_access_view_init(struct wined3d_unordered_access_view *view,
1113         const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
1114         void *parent, const struct wined3d_parent_ops *parent_ops)
1115 {
1116     view->refcount = 1;
1117     view->parent = parent;
1118     view->parent_ops = parent_ops;
1119
1120     if (!(view->format = validate_resource_view(desc, resource, TRUE, FALSE)))
1121         return E_INVALIDARG;
1122     view->desc = *desc;
1123
1124     wined3d_resource_incref(view->resource = resource);
1125
1126     wined3d_cs_init_object(resource->device->cs, wined3d_unordered_access_view_cs_init, view);
1127
1128     return WINED3D_OK;
1129 }
1130
1131 HRESULT CDECL wined3d_unordered_access_view_create(const struct wined3d_view_desc *desc,
1132         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
1133         struct wined3d_unordered_access_view **view)
1134 {
1135     struct wined3d_unordered_access_view *object;
1136     HRESULT hr;
1137
1138     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
1139             desc, resource, parent, parent_ops, view);
1140
1141     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1142         return E_OUTOFMEMORY;
1143
1144     if (FAILED(hr = wined3d_unordered_access_view_init(object, desc, resource, parent, parent_ops)))
1145     {
1146         HeapFree(GetProcessHeap(), 0, object);
1147         WARN("Failed to initialise view, hr %#x.\n", hr);
1148         return hr;
1149     }
1150
1151     TRACE("Created unordered access view %p.\n", object);
1152     *view = object;
1153
1154     return WINED3D_OK;
1155 }