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