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