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