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 ULONG CDECL wined3d_rendertarget_view_incref(struct wined3d_rendertarget_view *view)
  28 {
  29     ULONG refcount = InterlockedIncrement(&view->refcount);
  30
  31     TRACE("%p increasing refcount to %u.\n", view, refcount);
  32
  33     return refcount;
  34 }
  35
  36 static void wined3d_rendertarget_view_destroy_object(void *object)
  37 {
  38     HeapFree(GetProcessHeap(), 0, object);
  39 }
  40
  41 ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *view)
  42 {
  43     ULONG refcount = InterlockedDecrement(&view->refcount);
  44
  45     TRACE("%p decreasing refcount to %u.\n", view, refcount);
  46
  47     if (!refcount)
  48     {
  49         struct wined3d_resource *resource = view->resource;
  50         struct wined3d_device *device = resource->device;
  51
  52         /* Call wined3d_object_destroyed() before releasing the resource,
  53          * since releasing the resource may end up destroying the parent. */
  54         view->parent_ops->wined3d_object_destroyed(view->parent);
  55         wined3d_cs_emit_destroy_object(device->cs, wined3d_rendertarget_view_destroy_object, view);
  56         wined3d_resource_decref(resource);
  57     }
  58
  59     return refcount;
  60 }
  61
  62 void * CDECL wined3d_rendertarget_view_get_parent(const struct wined3d_rendertarget_view *view)
  63 {
  64     TRACE("view %p.\n", view);
  65
  66     return view->parent;
  67 }
  68
  69 void * CDECL wined3d_rendertarget_view_get_sub_resource_parent(const struct wined3d_rendertarget_view *view)
  70 {
  71     struct wined3d_texture *texture;
  72
  73     TRACE("view %p.\n", view);
  74
  75     if (view->resource->type == WINED3D_RTYPE_BUFFER)
  76         return wined3d_buffer_get_parent(buffer_from_resource(view->resource));
  77
  78     texture = texture_from_resource(view->resource);
  79
  80     return texture->sub_resources[view->sub_resource_idx].parent;
  81 }
  82
  83 void CDECL wined3d_rendertarget_view_set_parent(struct wined3d_rendertarget_view *view, void *parent)
  84 {
  85     TRACE("view %p, parent %p.\n", view, parent);
  86
  87     view->parent = parent;
  88 }
  89
  90 struct wined3d_resource * CDECL wined3d_rendertarget_view_get_resource(const struct wined3d_rendertarget_view *view)
  91 {
  92     TRACE("view %p.\n", view);
  93
  94     return view->resource;
  95 }
  96
  97 static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view,
  98         const struct wined3d_rendertarget_view_desc *desc, struct wined3d_resource *resource,
  99         void *parent, const struct wined3d_parent_ops *parent_ops)
 100 {
 101     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
 102
 103     view->refcount = 1;
 104     view->parent = parent;
 105     view->parent_ops = parent_ops;
 106
 107     view->format = wined3d_get_format(gl_info, desc->format_id);
 108     view->format_flags = view->format->flags[resource->gl_type];
 109
 110     if (wined3d_format_is_typeless(view->format))
 111     {
 112         WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view->format->id));
 113         return E_INVALIDARG;
 114     }
 115
 116     if (resource->type == WINED3D_RTYPE_BUFFER)
 117     {
 118         view->sub_resource_idx = 0;
 119         view->buffer_offset = desc->u.buffer.start_idx;
 120         view->width = desc->u.buffer.count;
 121         view->height = 1;
 122         view->depth = 1;
 123     }
 124     else
 125     {
 126         struct wined3d_texture *texture = texture_from_resource(resource);
 127         unsigned int depth_or_layer_count;
 128
 129         if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
 130             depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
 131         else
 132             depth_or_layer_count = texture->layer_count;
 133
 134         if (desc->u.texture.level_idx >= texture->level_count
 135                 || desc->u.texture.layer_idx >= depth_or_layer_count
 136                 || !desc->u.texture.layer_count
 137                 || desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx)
 138             return E_INVALIDARG;
 139
 140         view->sub_resource_idx = desc->u.texture.level_idx;
 141         if (resource->type != WINED3D_RTYPE_TEXTURE_3D)
 142             view->sub_resource_idx += desc->u.texture.layer_idx * texture->level_count;
 143         view->buffer_offset = 0;
 144         view->width = wined3d_texture_get_level_width(texture, desc->u.texture.level_idx);
 145         view->height = wined3d_texture_get_level_height(texture, desc->u.texture.level_idx);
 146         view->depth = desc->u.texture.layer_count;
 147     }
 148     wined3d_resource_incref(view->resource = resource);
 149
 150     return WINED3D_OK;
 151 }
 152
 153 HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_rendertarget_view_desc *desc,
 154         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 155         struct wined3d_rendertarget_view **view)
 156 {
 157     struct wined3d_rendertarget_view *object;
 158     HRESULT hr;
 159
 160     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 161             desc, resource, parent, parent_ops, view);
 162
 163     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 164         return E_OUTOFMEMORY;
 165
 166     if (FAILED(hr = wined3d_rendertarget_view_init(object, desc, resource, parent, parent_ops)))
 167     {
 168         HeapFree(GetProcessHeap(), 0, object);
 169         WARN("Failed to initialise view, hr %#x.\n", hr);
 170         return hr;
 171     }
 172
 173     TRACE("Created render target view %p.\n", object);
 174     *view = object;
 175
 176     return hr;
 177 }
 178
 179 HRESULT CDECL wined3d_rendertarget_view_create_from_sub_resource(struct wined3d_texture *texture,
 180         unsigned int sub_resource_idx, void *parent, const struct wined3d_parent_ops *parent_ops,
 181         struct wined3d_rendertarget_view **view)
 182 {
 183     struct wined3d_rendertarget_view_desc desc;
 184
 185     TRACE("texture %p, sub_resource_idx %u, parent %p, parent_ops %p, view %p.\n",
 186             texture, sub_resource_idx, parent, parent_ops, view);
 187
 188     desc.format_id = texture->resource.format->id;
 189     desc.u.texture.level_idx = sub_resource_idx % texture->level_count;
 190     desc.u.texture.layer_idx = sub_resource_idx / texture->level_count;
 191     desc.u.texture.layer_count = 1;
 192
 193     return wined3d_rendertarget_view_create(&desc, &texture->resource, parent, parent_ops, view);
 194 }
 195
 196 ULONG CDECL wined3d_shader_resource_view_incref(struct wined3d_shader_resource_view *view)
 197 {
 198     ULONG refcount = InterlockedIncrement(&view->refcount);
 199
 200     TRACE("%p increasing refcount to %u.\n", view, refcount);
 201
 202     return refcount;
 203 }
 204
 205 static void wined3d_shader_resource_view_destroy_object(void *object)
 206 {
 207     struct wined3d_shader_resource_view *view = object;
 208
 209     if (view->object)
 210     {
 211         const struct wined3d_gl_info *gl_info;
 212         struct wined3d_context *context;
 213
 214         context = context_acquire(view->resource->device, NULL);
 215         gl_info = context->gl_info;
 216         gl_info->gl_ops.gl.p_glDeleteTextures(1, &view->object);
 217         checkGLcall("glDeleteTextures");
 218         context_release(context);
 219     }
 220
 221     HeapFree(GetProcessHeap(), 0, view);
 222 }
 223
 224 ULONG CDECL wined3d_shader_resource_view_decref(struct wined3d_shader_resource_view *view)
 225 {
 226     ULONG refcount = InterlockedDecrement(&view->refcount);
 227
 228     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 229
 230     if (!refcount)
 231     {
 232         struct wined3d_resource *resource = view->resource;
 233         struct wined3d_device *device = resource->device;
 234
 235         /* Call wined3d_object_destroyed() before releasing the resource,
 236          * since releasing the resource may end up destroying the parent. */
 237         view->parent_ops->wined3d_object_destroyed(view->parent);
 238         wined3d_cs_emit_destroy_object(device->cs, wined3d_shader_resource_view_destroy_object, view);
 239         wined3d_resource_decref(resource);
 240     }
 241
 242     return refcount;
 243 }
 244
 245 void * CDECL wined3d_shader_resource_view_get_parent(const struct wined3d_shader_resource_view *view)
 246 {
 247     TRACE("view %p.\n", view);
 248
 249     return view->parent;
 250 }
 251
 252 static void wined3d_shader_resource_view_create_texture_view(struct wined3d_shader_resource_view *view,
 253         const struct wined3d_shader_resource_view_desc *desc, struct wined3d_texture *texture,
 254         const struct wined3d_format *view_format)
 255 {
 256     const struct wined3d_gl_info *gl_info;
 257     struct wined3d_context *context;
 258     struct gl_texture *gl_texture;
 259
 260     context = context_acquire(texture->resource.device, NULL);
 261     gl_info = context->gl_info;
 262
 263     if (!gl_info->supported[ARB_TEXTURE_VIEW])
 264     {
 265         context_release(context);
 266         FIXME("OpenGL implementation does not support texture views.\n");
 267         return;
 268     }
 269
 270     wined3d_texture_prepare_texture(texture, context, FALSE);
 271     gl_texture = wined3d_texture_get_gl_texture(texture, FALSE);
 272
 273     gl_info->gl_ops.gl.p_glGenTextures(1, &view->object);
 274     GL_EXTCALL(glTextureView(view->object, view->target, gl_texture->name, view_format->glInternal,
 275             desc->u.texture.level_idx, desc->u.texture.level_count,
 276             desc->u.texture.layer_idx, desc->u.texture.layer_count));
 277     checkGLcall("Create texture view");
 278
 279     context_release(context);
 280 }
 281
 282 static HRESULT wined3d_shader_resource_view_init(struct wined3d_shader_resource_view *view,
 283         const struct wined3d_shader_resource_view_desc *desc, struct wined3d_resource *resource,
 284         void *parent, const struct wined3d_parent_ops *parent_ops)
 285 {
 286     static const struct
 287     {
 288         GLenum texture_target;
 289         unsigned int view_flags;
 290         GLenum view_target;
 291     }
 292     view_types[] =
 293     {
 294         {GL_TEXTURE_2D,       0,                          GL_TEXTURE_2D},
 295         {GL_TEXTURE_2D,       WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
 296         {GL_TEXTURE_2D_ARRAY, 0,                          GL_TEXTURE_2D},
 297         {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY},
 298         {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_CUBE,  GL_TEXTURE_CUBE_MAP},
 299         {GL_TEXTURE_3D,       0,                          GL_TEXTURE_3D},
 300     };
 301
 302     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
 303     const struct wined3d_format *view_format;
 304
 305     view_format = wined3d_get_format(gl_info, desc->format_id);
 306     if (wined3d_format_is_typeless(view_format))
 307     {
 308         WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view_format->id));
 309         return E_INVALIDARG;
 310     }
 311
 312     view->refcount = 1;
 313     view->parent = parent;
 314     view->parent_ops = parent_ops;
 315
 316     view->target = GL_NONE;
 317     view->object = 0;
 318
 319     if (resource->type == WINED3D_RTYPE_BUFFER)
 320     {
 321         FIXME("Buffer shader resource views not supported.\n");
 322     }
 323     else
 324     {
 325         struct wined3d_texture *texture = texture_from_resource(resource);
 326         unsigned int i;
 327
 328         if (!desc->u.texture.level_count
 329                 || desc->u.texture.level_idx >= texture->level_count
 330                 || desc->u.texture.level_count > texture->level_count - desc->u.texture.level_idx
 331                 || !desc->u.texture.layer_count
 332                 || desc->u.texture.layer_idx >= texture->layer_count
 333                 || desc->u.texture.layer_count > texture->layer_count - desc->u.texture.layer_idx)
 334             return E_INVALIDARG;
 335
 336         view->target = texture->target;
 337         for (i = 0; i < ARRAY_SIZE(view_types); ++i)
 338         {
 339             if (view_types[i].texture_target == texture->target && view_types[i].view_flags == desc->flags)
 340             {
 341                 view->target = view_types[i].view_target;
 342                 break;
 343             }
 344         }
 345         if (i == ARRAY_SIZE(view_types))
 346             FIXME("Unhandled view flags %#x for texture target %#x.\n", desc->flags, texture->target);
 347
 348         if (resource->format->id == view_format->id && texture->target == view->target
 349                 && !desc->u.texture.level_idx && desc->u.texture.level_count == texture->level_count
 350                 && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture->layer_count)
 351         {
 352             TRACE("Creating identity shader resource view.\n");
 353         }
 354         else if (texture->swapchain && texture->swapchain->desc.backbuffer_count > 1)
 355         {
 356             FIXME("Swapchain shader resource views not supported.\n");
 357         }
 358         else if (resource->format->typeless_id == view_format->typeless_id
 359                 && resource->format->gl_view_class == view_format->gl_view_class)
 360         {
 361             wined3d_shader_resource_view_create_texture_view(view, desc, texture, view_format);
 362         }
 363         else
 364         {
 365             FIXME("Shader resource view not supported, resource format %s, view format %s.\n",
 366                     debug_d3dformat(resource->format->id), debug_d3dformat(view_format->id));
 367         }
 368     }
 369     wined3d_resource_incref(view->resource = resource);
 370
 371     return WINED3D_OK;
 372 }
 373
 374 HRESULT CDECL wined3d_shader_resource_view_create(const struct wined3d_shader_resource_view_desc *desc,
 375         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 376         struct wined3d_shader_resource_view **view)
 377 {
 378     struct wined3d_shader_resource_view *object;
 379     HRESULT hr;
 380
 381     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 382             desc, resource, parent, parent_ops, view);
 383
 384     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 385         return E_OUTOFMEMORY;
 386
 387     if (FAILED(hr = wined3d_shader_resource_view_init(object, desc, resource, parent, parent_ops)))
 388     {
 389         HeapFree(GetProcessHeap(), 0, object);
 390         WARN("Failed to initialise view, hr %#x.\n", hr);
 391         return hr;
 392     }
 393
 394     TRACE("Created shader resource view %p.\n", object);
 395     *view = object;
 396
 397     return WINED3D_OK;
 398 }
 399
 400 void wined3d_shader_resource_view_bind(struct wined3d_shader_resource_view *view,
 401         struct wined3d_context *context)
 402 {
 403     struct wined3d_texture *texture;
 404
 405     if (view->object)
 406     {
 407         context_bind_texture(context, view->target, view->object);
 408         return;
 409     }
 410
 411     if (view->resource->type == WINED3D_RTYPE_BUFFER)
 412     {
 413         FIXME("Buffer shader resources not supported.\n");
 414         return;
 415     }
 416
 417     texture = wined3d_texture_from_resource(view->resource);
 418     wined3d_texture_bind(texture, context, FALSE);
 419 }
 420
 421 ULONG CDECL wined3d_unordered_access_view_incref(struct wined3d_unordered_access_view *view)
 422 {
 423     ULONG refcount = InterlockedIncrement(&view->refcount);
 424
 425     TRACE("%p increasing refcount to %u.\n", view, refcount);
 426
 427     return refcount;
 428 }
 429
 430 static void wined3d_unordered_access_view_destroy_object(void *object)
 431 {
 432     HeapFree(GetProcessHeap(), 0, object);
 433 }
 434
 435 ULONG CDECL wined3d_unordered_access_view_decref(struct wined3d_unordered_access_view *view)
 436 {
 437     ULONG refcount = InterlockedDecrement(&view->refcount);
 438
 439     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 440
 441     if (!refcount)
 442     {
 443         struct wined3d_resource *resource = view->resource;
 444         struct wined3d_device *device = resource->device;
 445
 446         /* Call wined3d_object_destroyed() before releasing the resource,
 447          * since releasing the resource may end up destroying the parent. */
 448         view->parent_ops->wined3d_object_destroyed(view->parent);
 449         wined3d_cs_emit_destroy_object(device->cs, wined3d_unordered_access_view_destroy_object, view);
 450         wined3d_resource_decref(resource);
 451     }
 452
 453     return refcount;
 454 }
 455
 456 void * CDECL wined3d_unordered_access_view_get_parent(const struct wined3d_unordered_access_view *view)
 457 {
 458     TRACE("view %p.\n", view);
 459
 460     return view->parent;
 461 }
 462
 463 static HRESULT wined3d_unordered_access_view_init(struct wined3d_unordered_access_view *view,
 464         const struct wined3d_unordered_access_view_desc *desc, struct wined3d_resource *resource,
 465         void *parent, const struct wined3d_parent_ops *parent_ops)
 466 {
 467     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
 468
 469     view->refcount = 1;
 470     view->parent = parent;
 471     view->parent_ops = parent_ops;
 472
 473     view->format = wined3d_get_format(gl_info, desc->format_id);
 474
 475     if (wined3d_format_is_typeless(view->format))
 476     {
 477         WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view->format->id));
 478         return E_INVALIDARG;
 479     }
 480
 481     if (resource->type != WINED3D_RTYPE_BUFFER)
 482     {
 483         struct wined3d_texture *texture = texture_from_resource(resource);
 484         unsigned int depth_or_layer_count;
 485
 486         if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
 487             depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx);
 488         else
 489             depth_or_layer_count = texture->layer_count;
 490
 491         if (desc->u.texture.level_idx >= texture->level_count
 492                 || desc->u.texture.layer_idx >= depth_or_layer_count
 493                 || !desc->u.texture.layer_count
 494                 || desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx)
 495             return E_INVALIDARG;
 496     }
 497     wined3d_resource_incref(view->resource = resource);
 498
 499     return WINED3D_OK;
 500 }
 501
 502 HRESULT CDECL wined3d_unordered_access_view_create(const struct wined3d_unordered_access_view_desc *desc,
 503         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 504         struct wined3d_unordered_access_view **view)
 505 {
 506     struct wined3d_unordered_access_view *object;
 507     HRESULT hr;
 508
 509     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 510             desc, resource, parent, parent_ops, view);
 511
 512     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 513         return E_OUTOFMEMORY;
 514
 515     if (FAILED(hr = wined3d_unordered_access_view_init(object, desc, resource, parent, parent_ops)))
 516     {
 517         HeapFree(GetProcessHeap(), 0, object);
 518         WARN("Failed to initialise view, hr %#x.\n", hr);
 519         return hr;
 520     }
 521
 522     TRACE("Created unordered access view %p.\n", object);
 523     *view = object;
 524
 525     return WINED3D_OK;
 526 }