dlls/wined3d/view.c

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