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 static BOOL is_stencil_view_format(const struct wined3d_format *format)
  28 {
  29     return format->id == WINED3DFMT_X24_TYPELESS_G8_UINT
  30             || format->id == WINED3DFMT_X32_TYPELESS_G8X24_UINT;
  31 }
  32
  33 static GLenum get_texture_view_target(const struct wined3d_view_desc *desc,
  34         const struct wined3d_texture *texture)
  35 {
  36     static const struct
  37     {
  38         GLenum texture_target;
  39         unsigned int view_flags;
  40         GLenum view_target;
  41     }
  42     view_types[] =
  43     {
  44         {GL_TEXTURE_2D,       0,                          GL_TEXTURE_2D},
  45         {GL_TEXTURE_2D,       WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
  46         {GL_TEXTURE_2D_ARRAY, 0,                          GL_TEXTURE_2D},
  47         {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
  48         {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_CUBE,  GL_TEXTURE_CUBE_MAP},
  49         {GL_TEXTURE_3D,       0,                          GL_TEXTURE_3D},
  50     };
  51     unsigned int i;
  52
  53     for (i = 0; i < ARRAY_SIZE(view_types); ++i)
  54     {
  55         if (view_types[i].texture_target == texture->target && view_types[i].view_flags == desc->flags)
  56             return view_types[i].view_target;
  57     }
  58
  59     FIXME("Unhandled view flags %#x for texture target %#x.\n", desc->flags, texture->target);
  60     return texture->target;
  61 }
  62
  63 static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target,
  64         const struct wined3d_view_desc *desc, struct wined3d_texture *texture,
  65         const struct wined3d_format *view_format)
  66 {
  67     const struct wined3d_gl_info *gl_info;
  68     unsigned int layer_idx, layer_count;
  69     struct wined3d_context *context;
  70     struct gl_texture *gl_texture;
  71
  72     view->target = view_target;
  73
  74     context = context_acquire(texture->resource.device, NULL);
  75     gl_info = context->gl_info;
  76
  77     if (!gl_info->supported[ARB_TEXTURE_VIEW])
  78     {
  79         context_release(context);
  80         FIXME("OpenGL implementation does not support texture views.\n");
  81         return;
  82     }
  83
  84     wined3d_texture_prepare_texture(texture, context, FALSE);
  85     gl_texture = wined3d_texture_get_gl_texture(texture, FALSE);
  86
  87     layer_idx = desc->u.texture.layer_idx;
  88     layer_count = desc->u.texture.layer_count;
  89     if (view_target == GL_TEXTURE_3D && (layer_idx || layer_count != 1))
  90     {
  91         FIXME("Depth slice (%u-%u) not supported.\n", layer_idx, layer_count);
  92         layer_idx = 0;
  93         layer_count = 1;
  94     }
  95
  96     gl_info->gl_ops.gl.p_glGenTextures(1, &view->name);
  97     GL_EXTCALL(glTextureView(view->name, view->target, gl_texture->name, view_format->glInternal,
  98             desc->u.texture.level_idx, desc->u.texture.level_count,
  99             layer_idx, layer_count));
 100     checkGLcall("Create texture view");
 101
 102     if (is_stencil_view_format(view_format))
 103     {
 104         static const GLint swizzle[] = {GL_ZERO, GL_RED, GL_ZERO, GL_ZERO};
 105
 106         if (!gl_info->supported[ARB_STENCIL_TEXTURING])
 107         {
 108             context_release(context);
 109             FIXME("OpenGL implementation does not support stencil texturing.\n");
 110             return;
 111         }
 112
 113         context_bind_texture(context, view->target, view->name);
 114         gl_info->gl_ops.gl.p_glTexParameteriv(view->target, GL_TEXTURE_SWIZZLE_RGBA, swizzle);
 115         gl_info->gl_ops.gl.p_glTexParameteri(view->target, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
 116         checkGLcall("Initialize stencil view");
 117
 118         context_invalidate_state(context, STATE_SHADER_RESOURCE_BINDING);
 119     }
 120
 121     context_release(context);
 122 }
 123
 124 static void create_buffer_texture(struct wined3d_gl_view *view,
 125         struct wined3d_buffer *buffer, const struct wined3d_format *view_format)
 126 {
 127     const struct wined3d_gl_info *gl_info;
 128     struct wined3d_context *context;
 129
 130     context = context_acquire(buffer->resource.device, NULL);
 131     gl_info = context->gl_info;
 132     if (!gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
 133     {
 134         FIXME("OpenGL implementation does not support buffer textures.\n");
 135         context_release(context);
 136         return;
 137     }
 138
 139     wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER);
 140
 141     view->target = GL_TEXTURE_BUFFER;
 142     gl_info->gl_ops.gl.p_glGenTextures(1, &view->name);
 143
 144     context_bind_texture(context, GL_TEXTURE_BUFFER, view->name);
 145     GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, view_format->glInternal, buffer->buffer_object));
 146     checkGLcall("Create buffer texture");
 147
 148     context_invalidate_state(context, STATE_SHADER_RESOURCE_BINDING);
 149
 150     context_release(context);
 151 }
 152
 153 ULONG CDECL wined3d_rendertarget_view_incref(struct wined3d_rendertarget_view *view)
 154 {
 155     ULONG refcount = InterlockedIncrement(&view->refcount);
 156
 157     TRACE("%p increasing refcount to %u.\n", view, refcount);
 158
 159     return refcount;
 160 }
 161
 162 static void wined3d_rendertarget_view_destroy_object(void *object)
 163 {
 164     HeapFree(GetProcessHeap(), 0, object);
 165 }
 166
 167 ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *view)
 168 {
 169     ULONG refcount = InterlockedDecrement(&view->refcount);
 170
 171     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 172
 173     if (!refcount)
 174     {
 175         struct wined3d_resource *resource = view->resource;
 176         struct wined3d_device *device = resource->device;
 177
 178         /* Call wined3d_object_destroyed() before releasing the resource,
 179          * since releasing the resource may end up destroying the parent. */
 180         view->parent_ops->wined3d_object_destroyed(view->parent);
 181         wined3d_cs_emit_destroy_object(device->cs, wined3d_rendertarget_view_destroy_object, view);
 182         wined3d_resource_decref(resource);
 183     }
 184
 185     return refcount;
 186 }
 187
 188 void * CDECL wined3d_rendertarget_view_get_parent(const struct wined3d_rendertarget_view *view)
 189 {
 190     TRACE("view %p.\n", view);
 191
 192     return view->parent;
 193 }
 194
 195 void * CDECL wined3d_rendertarget_view_get_sub_resource_parent(const struct wined3d_rendertarget_view *view)
 196 {
 197     struct wined3d_texture *texture;
 198
 199     TRACE("view %p.\n", view);
 200
 201     if (view->resource->type == WINED3D_RTYPE_BUFFER)
 202         return wined3d_buffer_get_parent(buffer_from_resource(view->resource));
 203
 204     texture = texture_from_resource(view->resource);
 205
 206     return texture->sub_resources[view->sub_resource_idx].parent;
 207 }
 208
 209 void CDECL wined3d_rendertarget_view_set_parent(struct wined3d_rendertarget_view *view, void *parent)
 210 {
 211     TRACE("view %p, parent %p.\n", view, parent);
 212
 213     view->parent = parent;
 214 }
 215
 216 struct wined3d_resource * CDECL wined3d_rendertarget_view_get_resource(const struct wined3d_rendertarget_view *view)
 217 {
 218     TRACE("view %p.\n", view);
 219
 220     return view->resource;
 221 }
 222
 223 void wined3d_rendertarget_view_get_drawable_size(const struct wined3d_rendertarget_view *view,
 224         const struct wined3d_context *context, unsigned int *width, unsigned int *height)
 225 {
 226     const struct wined3d_texture *texture;
 227
 228     if (view->resource->type != WINED3D_RTYPE_TEXTURE_2D)
 229     {
 230         FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(view->resource->type));
 231         *width = 0;
 232         *height = 0;
 233         return;
 234     }
 235
 236     texture = texture_from_resource(view->resource);
 237     if (texture->swapchain)
 238     {
 239         /* The drawable size of an onscreen drawable is the surface size.
 240          * (Actually: The window size, but the surface is created in window
 241          * size.) */
 242         *width = context->current_rt.texture->resource.width;
 243         *height = context->current_rt.texture->resource.height;
 244     }
 245     else if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
 246     {
 247         const struct wined3d_swapchain *swapchain = context->swapchain;
 248
 249         /* The drawable size of a backbuffer / aux buffer offscreen target is
 250          * the size of the current context's drawable, which is the size of
 251          * the back buffer of the swapchain the active context belongs to. */
 252         *width = swapchain->desc.backbuffer_width;
 253         *height = swapchain->desc.backbuffer_height;
 254     }
 255     else
 256     {
 257         struct wined3d_surface *rt;
 258
 259         /* The drawable size of an FBO target is the OpenGL texture size,
 260          * which is the power of two size. */
 261         rt = context->current_rt.texture->sub_resources[context->current_rt.sub_resource_idx].u.surface;
 262         *width = wined3d_texture_get_level_pow2_width(rt->container, rt->texture_level);
 263         *height = wined3d_texture_get_level_pow2_height(rt->container, rt->texture_level);
 264     }
 265 }
 266
 267 static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view,
 268         const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
 269         void *parent, const struct wined3d_parent_ops *parent_ops)
 270 {
 271     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
 272
 273     view->refcount = 1;
 274     view->parent = parent;
 275     view->parent_ops = parent_ops;
 276
 277     view->format = wined3d_get_format(gl_info, desc->format_id, resource->usage);
 278     view->format_flags = view->format->flags[resource->gl_type];
 279
 280     if (wined3d_format_is_typeless(view->format))
 281     {
 282         WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view->format->id));
 283         return E_INVALIDARG;
 284     }
 285
 286     if (resource->type == WINED3D_RTYPE_BUFFER)
 287     {
 288         view->sub_resource_idx = 0;
 289         view->buffer_offset = desc->u.buffer.start_idx;
 290         view->width = desc->u.buffer.count;
 291         view->height = 1;
 292         view->depth = 1;
 293     }
 294     else
 295     {
 296         struct wined3d_texture *texture = texture_from_resource(resource);
 297         unsigned int depth_or_layer_count;
 298
 299         if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
 300             depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
 301         else
 302             depth_or_layer_count = texture->layer_count;
 303
 304         if (desc->u.texture.level_idx >= texture->level_count
 305                 || desc->u.texture.level_count != 1
 306                 || desc->u.texture.layer_idx >= depth_or_layer_count
 307                 || !desc->u.texture.layer_count
 308                 || desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx)
 309             return E_INVALIDARG;
 310
 311         view->sub_resource_idx = desc->u.texture.level_idx;
 312         if (resource->type != WINED3D_RTYPE_TEXTURE_3D)
 313             view->sub_resource_idx += desc->u.texture.layer_idx * texture->level_count;
 314         view->buffer_offset = 0;
 315         view->width = wined3d_texture_get_level_width(texture, desc->u.texture.level_idx);
 316         view->height = wined3d_texture_get_level_height(texture, desc->u.texture.level_idx);
 317         view->depth = desc->u.texture.layer_count;
 318     }
 319     wined3d_resource_incref(view->resource = resource);
 320
 321     return WINED3D_OK;
 322 }
 323
 324 HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_view_desc *desc,
 325         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 326         struct wined3d_rendertarget_view **view)
 327 {
 328     struct wined3d_rendertarget_view *object;
 329     HRESULT hr;
 330
 331     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 332             desc, resource, parent, parent_ops, view);
 333
 334     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 335         return E_OUTOFMEMORY;
 336
 337     if (FAILED(hr = wined3d_rendertarget_view_init(object, desc, resource, parent, parent_ops)))
 338     {
 339         HeapFree(GetProcessHeap(), 0, object);
 340         WARN("Failed to initialise view, hr %#x.\n", hr);
 341         return hr;
 342     }
 343
 344     TRACE("Created render target view %p.\n", object);
 345     *view = object;
 346
 347     return hr;
 348 }
 349
 350 HRESULT CDECL wined3d_rendertarget_view_create_from_sub_resource(struct wined3d_texture *texture,
 351         unsigned int sub_resource_idx, void *parent, const struct wined3d_parent_ops *parent_ops,
 352         struct wined3d_rendertarget_view **view)
 353 {
 354     struct wined3d_view_desc desc;
 355
 356     TRACE("texture %p, sub_resource_idx %u, parent %p, parent_ops %p, view %p.\n",
 357             texture, sub_resource_idx, parent, parent_ops, view);
 358
 359     desc.format_id = texture->resource.format->id;
 360     desc.flags = 0;
 361     desc.u.texture.level_idx = sub_resource_idx % texture->level_count;
 362     desc.u.texture.level_count = 1;
 363     desc.u.texture.layer_idx = sub_resource_idx / texture->level_count;
 364     desc.u.texture.layer_count = 1;
 365
 366     return wined3d_rendertarget_view_create(&desc, &texture->resource, parent, parent_ops, view);
 367 }
 368
 369 ULONG CDECL wined3d_shader_resource_view_incref(struct wined3d_shader_resource_view *view)
 370 {
 371     ULONG refcount = InterlockedIncrement(&view->refcount);
 372
 373     TRACE("%p increasing refcount to %u.\n", view, refcount);
 374
 375     return refcount;
 376 }
 377
 378 static void wined3d_shader_resource_view_destroy_object(void *object)
 379 {
 380     struct wined3d_shader_resource_view *view = object;
 381
 382     if (view->gl_view.name)
 383     {
 384         const struct wined3d_gl_info *gl_info;
 385         struct wined3d_context *context;
 386
 387         context = context_acquire(view->resource->device, NULL);
 388         gl_info = context->gl_info;
 389         gl_info->gl_ops.gl.p_glDeleteTextures(1, &view->gl_view.name);
 390         checkGLcall("glDeleteTextures");
 391         context_release(context);
 392     }
 393
 394     HeapFree(GetProcessHeap(), 0, view);
 395 }
 396
 397 ULONG CDECL wined3d_shader_resource_view_decref(struct wined3d_shader_resource_view *view)
 398 {
 399     ULONG refcount = InterlockedDecrement(&view->refcount);
 400
 401     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 402
 403     if (!refcount)
 404     {
 405         struct wined3d_resource *resource = view->resource;
 406         struct wined3d_device *device = resource->device;
 407
 408         /* Call wined3d_object_destroyed() before releasing the resource,
 409          * since releasing the resource may end up destroying the parent. */
 410         view->parent_ops->wined3d_object_destroyed(view->parent);
 411         wined3d_cs_emit_destroy_object(device->cs, wined3d_shader_resource_view_destroy_object, view);
 412         wined3d_resource_decref(resource);
 413     }
 414
 415     return refcount;
 416 }
 417
 418 void * CDECL wined3d_shader_resource_view_get_parent(const struct wined3d_shader_resource_view *view)
 419 {
 420     TRACE("view %p.\n", view);
 421
 422     return view->parent;
 423 }
 424
 425 static HRESULT wined3d_shader_resource_view_init(struct wined3d_shader_resource_view *view,
 426         const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
 427         void *parent, const struct wined3d_parent_ops *parent_ops)
 428 {
 429     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
 430     const struct wined3d_format *view_format;
 431     GLenum view_target;
 432
 433     view_format = wined3d_get_format(gl_info, desc->format_id, resource->usage);
 434     if (wined3d_format_is_typeless(view_format)
 435             && !(view_format->id == WINED3DFMT_R32_TYPELESS && (desc->flags & WINED3D_VIEW_BUFFER_RAW)))
 436     {
 437         WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view_format->id));
 438         return E_INVALIDARG;
 439     }
 440
 441     view->refcount = 1;
 442     view->parent = parent;
 443     view->parent_ops = parent_ops;
 444
 445     if (resource->type == WINED3D_RTYPE_BUFFER)
 446     {
 447         struct wined3d_buffer *buffer = buffer_from_resource(resource);
 448
 449         if (desc->format_id == WINED3DFMT_UNKNOWN)
 450         {
 451             FIXME("Structured buffer views not supported.\n");
 452         }
 453         else if (desc->flags & WINED3D_VIEW_BUFFER_RAW)
 454         {
 455             FIXME("Raw buffer views not supported.\n");
 456         }
 457         else
 458         {
 459             /* FIXME: Support for buffer offsets can be implemented using ARB_texture_buffer_range. */
 460             if (desc->u.buffer.start_idx
 461                     || desc->u.buffer.count * view_format->byte_count != buffer->resource.size)
 462             {
 463                 FIXME("Ignoring buffer range %u-%u.\n", desc->u.buffer.start_idx, desc->u.buffer.count);
 464             }
 465
 466             create_buffer_texture(&view->gl_view, buffer, view_format);
 467         }
 468     }
 469     else
 470     {
 471         struct wined3d_texture *texture = texture_from_resource(resource);
 472
 473         if (!desc->u.texture.level_count
 474                 || desc->u.texture.level_idx >= texture->level_count
 475                 || desc->u.texture.level_count > texture->level_count - desc->u.texture.level_idx
 476                 || !desc->u.texture.layer_count
 477                 || desc->u.texture.layer_idx >= texture->layer_count
 478                 || desc->u.texture.layer_count > texture->layer_count - desc->u.texture.layer_idx)
 479             return E_INVALIDARG;
 480
 481         view_target = get_texture_view_target(desc, texture);
 482
 483         if (resource->format->id == view_format->id && texture->target == view_target
 484                 && !desc->u.texture.level_idx && desc->u.texture.level_count == texture->level_count
 485                 && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture->layer_count
 486                 && !is_stencil_view_format(view_format))
 487         {
 488             TRACE("Creating identity shader resource view.\n");
 489         }
 490         else if (texture->swapchain && texture->swapchain->desc.backbuffer_count > 1)
 491         {
 492             FIXME("Swapchain shader resource views not supported.\n");
 493         }
 494         else if (resource->format->typeless_id == view_format->typeless_id
 495                 && resource->format->gl_view_class == view_format->gl_view_class)
 496         {
 497             create_texture_view(&view->gl_view, view_target, desc, texture, view_format);
 498         }
 499         else
 500         {
 501             FIXME("Shader resource view not supported, resource format %s, view format %s.\n",
 502                     debug_d3dformat(resource->format->id), debug_d3dformat(view_format->id));
 503         }
 504     }
 505     wined3d_resource_incref(view->resource = resource);
 506
 507     return WINED3D_OK;
 508 }
 509
 510 HRESULT CDECL wined3d_shader_resource_view_create(const struct wined3d_view_desc *desc,
 511         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 512         struct wined3d_shader_resource_view **view)
 513 {
 514     struct wined3d_shader_resource_view *object;
 515     HRESULT hr;
 516
 517     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 518             desc, resource, parent, parent_ops, view);
 519
 520     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 521         return E_OUTOFMEMORY;
 522
 523     if (FAILED(hr = wined3d_shader_resource_view_init(object, desc, resource, parent, parent_ops)))
 524     {
 525         HeapFree(GetProcessHeap(), 0, object);
 526         WARN("Failed to initialise view, hr %#x.\n", hr);
 527         return hr;
 528     }
 529
 530     TRACE("Created shader resource view %p.\n", object);
 531     *view = object;
 532
 533     return WINED3D_OK;
 534 }
 535
 536 void wined3d_shader_resource_view_bind(struct wined3d_shader_resource_view *view,
 537         struct wined3d_context *context)
 538 {
 539     struct wined3d_texture *texture;
 540
 541     if (view->gl_view.name)
 542     {
 543         context_bind_texture(context, view->gl_view.target, view->gl_view.name);
 544         return;
 545     }
 546
 547     if (view->resource->type == WINED3D_RTYPE_BUFFER)
 548     {
 549         FIXME("Buffer shader resources not supported.\n");
 550         return;
 551     }
 552
 553     texture = wined3d_texture_from_resource(view->resource);
 554     wined3d_texture_bind(texture, context, FALSE);
 555 }
 556
 557 ULONG CDECL wined3d_unordered_access_view_incref(struct wined3d_unordered_access_view *view)
 558 {
 559     ULONG refcount = InterlockedIncrement(&view->refcount);
 560
 561     TRACE("%p increasing refcount to %u.\n", view, refcount);
 562
 563     return refcount;
 564 }
 565
 566 static void wined3d_unordered_access_view_destroy_object(void *object)
 567 {
 568     HeapFree(GetProcessHeap(), 0, object);
 569 }
 570
 571 ULONG CDECL wined3d_unordered_access_view_decref(struct wined3d_unordered_access_view *view)
 572 {
 573     ULONG refcount = InterlockedDecrement(&view->refcount);
 574
 575     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 576
 577     if (!refcount)
 578     {
 579         struct wined3d_resource *resource = view->resource;
 580         struct wined3d_device *device = resource->device;
 581
 582         /* Call wined3d_object_destroyed() before releasing the resource,
 583          * since releasing the resource may end up destroying the parent. */
 584         view->parent_ops->wined3d_object_destroyed(view->parent);
 585         wined3d_cs_emit_destroy_object(device->cs, wined3d_unordered_access_view_destroy_object, view);
 586         wined3d_resource_decref(resource);
 587     }
 588
 589     return refcount;
 590 }
 591
 592 void * CDECL wined3d_unordered_access_view_get_parent(const struct wined3d_unordered_access_view *view)
 593 {
 594     TRACE("view %p.\n", view);
 595
 596     return view->parent;
 597 }
 598
 599 void wined3d_unordered_access_view_invalidate_location(struct wined3d_unordered_access_view *view,
 600         DWORD location)
 601 {
 602     struct wined3d_resource *resource = view->resource;
 603     unsigned int i, sub_resource_idx, layer_count;
 604     struct wined3d_texture *texture;
 605
 606     if (resource->type == WINED3D_RTYPE_BUFFER)
 607     {
 608         FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type));
 609         return;
 610     }
 611
 612     texture = texture_from_resource(resource);
 613
 614     sub_resource_idx = view->layer_idx * texture->level_count + view->level_idx;
 615     layer_count = (resource->type != WINED3D_RTYPE_TEXTURE_3D) ? view->layer_count : 1;
 616     for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
 617         wined3d_texture_invalidate_location(texture, sub_resource_idx, location);
 618 }
 619
 620 static HRESULT wined3d_unordered_access_view_init(struct wined3d_unordered_access_view *view,
 621         const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
 622         void *parent, const struct wined3d_parent_ops *parent_ops)
 623 {
 624     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
 625
 626     view->refcount = 1;
 627     view->parent = parent;
 628     view->parent_ops = parent_ops;
 629
 630     view->format = wined3d_get_format(gl_info, desc->format_id, resource->usage);
 631
 632     if (wined3d_format_is_typeless(view->format)
 633             && !(view->format->id == WINED3DFMT_R32_TYPELESS && (desc->flags & WINED3D_VIEW_BUFFER_RAW)))
 634     {
 635         WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view->format->id));
 636         return E_INVALIDARG;
 637     }
 638
 639     if (resource->type == WINED3D_RTYPE_BUFFER)
 640     {
 641         FIXME("Buffer unordered access views not supported.\n");
 642     }
 643     else
 644     {
 645         struct wined3d_texture *texture = texture_from_resource(resource);
 646         unsigned int depth_or_layer_count;
 647
 648         if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
 649             depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
 650         else
 651             depth_or_layer_count = texture->layer_count;
 652
 653         if (desc->u.texture.level_idx >= texture->level_count
 654                 || desc->u.texture.level_count != 1
 655                 || desc->u.texture.layer_idx >= depth_or_layer_count
 656                 || !desc->u.texture.layer_count
 657                 || desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx)
 658             return E_INVALIDARG;
 659
 660         if (desc->u.texture.layer_idx || desc->u.texture.layer_count != depth_or_layer_count)
 661         {
 662             create_texture_view(&view->gl_view, get_texture_view_target(desc, texture),
 663                     desc, texture, view->format);
 664         }
 665
 666         view->layer_idx = desc->u.texture.layer_idx;
 667         view->layer_count = desc->u.texture.layer_count;
 668         view->level_idx = desc->u.texture.level_idx;
 669     }
 670     wined3d_resource_incref(view->resource = resource);
 671
 672     return WINED3D_OK;
 673 }
 674
 675 HRESULT CDECL wined3d_unordered_access_view_create(const struct wined3d_view_desc *desc,
 676         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 677         struct wined3d_unordered_access_view **view)
 678 {
 679     struct wined3d_unordered_access_view *object;
 680     HRESULT hr;
 681
 682     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 683             desc, resource, parent, parent_ops, view);
 684
 685     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 686         return E_OUTOFMEMORY;
 687
 688     if (FAILED(hr = wined3d_unordered_access_view_init(object, desc, resource, parent, parent_ops)))
 689     {
 690         HeapFree(GetProcessHeap(), 0, object);
 691         WARN("Failed to initialise view, hr %#x.\n", hr);
 692         return hr;
 693     }
 694
 695     TRACE("Created unordered access view %p.\n", object);
 696     *view = object;
 697
 698     return WINED3D_OK;
 699 }