dlls/d3d11/view.c

   1 /*
   2  * Copyright 2009 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 #define NONAMELESSUNION
  24 #include "d3d11_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  27
  28 static HRESULT set_dsdesc_from_resource(D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11Resource *resource)
  29 {
  30     D3D11_RESOURCE_DIMENSION dimension;
  31
  32     ID3D11Resource_GetType(resource, &dimension);
  33
  34     desc->Flags = 0;
  35
  36     switch (dimension)
  37     {
  38         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
  39         {
  40             D3D11_TEXTURE1D_DESC texture_desc;
  41             ID3D11Texture1D *texture;
  42
  43             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture)))
  44             {
  45                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D.\n");
  46                 return E_INVALIDARG;
  47             }
  48
  49             ID3D11Texture1D_GetDesc(texture, &texture_desc);
  50             ID3D11Texture1D_Release(texture);
  51
  52             desc->Format = texture_desc.Format;
  53             if (texture_desc.ArraySize == 1)
  54             {
  55                 desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1D;
  56                 desc->u.Texture1D.MipSlice = 0;
  57             }
  58             else
  59             {
  60                 desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1DARRAY;
  61                 desc->u.Texture1DArray.MipSlice = 0;
  62                 desc->u.Texture1DArray.FirstArraySlice = 0;
  63                 desc->u.Texture1DArray.ArraySize = 1;
  64             }
  65
  66             return S_OK;
  67         }
  68
  69         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
  70         {
  71             D3D11_TEXTURE2D_DESC texture_desc;
  72             ID3D11Texture2D *texture;
  73
  74             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
  75             {
  76                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
  77                 return E_INVALIDARG;
  78             }
  79
  80             ID3D11Texture2D_GetDesc(texture, &texture_desc);
  81             ID3D11Texture2D_Release(texture);
  82
  83             desc->Format = texture_desc.Format;
  84             if (texture_desc.ArraySize == 1)
  85             {
  86                 if (texture_desc.SampleDesc.Count == 1)
  87                 {
  88                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
  89                     desc->u.Texture2D.MipSlice = 0;
  90                 }
  91                 else
  92                 {
  93                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
  94                 }
  95             }
  96             else
  97             {
  98                 if (texture_desc.SampleDesc.Count == 1)
  99                 {
 100                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
 101                     desc->u.Texture2DArray.MipSlice = 0;
 102                     desc->u.Texture2DArray.FirstArraySlice = 0;
 103                     desc->u.Texture2DArray.ArraySize = 1;
 104                 }
 105                 else
 106                 {
 107                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY;
 108                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 109                     desc->u.Texture2DMSArray.ArraySize = 1;
 110                 }
 111             }
 112
 113             return S_OK;
 114         }
 115
 116         default:
 117             FIXME("Unhandled resource dimension %#x.\n", dimension);
 118         case D3D11_RESOURCE_DIMENSION_BUFFER:
 119         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 120             return E_INVALIDARG;
 121     }
 122 }
 123
 124 static HRESULT set_rtdesc_from_resource(D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11Resource *resource)
 125 {
 126     D3D11_RESOURCE_DIMENSION dimension;
 127     HRESULT hr;
 128
 129     ID3D11Resource_GetType(resource, &dimension);
 130
 131     switch(dimension)
 132     {
 133         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 134         {
 135             ID3D11Texture1D *texture;
 136             D3D11_TEXTURE1D_DESC texture_desc;
 137
 138             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture);
 139             if (FAILED(hr))
 140             {
 141                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D?\n");
 142                 return E_INVALIDARG;
 143             }
 144
 145             ID3D11Texture1D_GetDesc(texture, &texture_desc);
 146             ID3D11Texture1D_Release(texture);
 147
 148             desc->Format = texture_desc.Format;
 149             if (texture_desc.ArraySize == 1)
 150             {
 151                 desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1D;
 152                 desc->u.Texture1D.MipSlice = 0;
 153             }
 154             else
 155             {
 156                 desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1DARRAY;
 157                 desc->u.Texture1DArray.MipSlice = 0;
 158                 desc->u.Texture1DArray.FirstArraySlice = 0;
 159                 desc->u.Texture1DArray.ArraySize = 1;
 160             }
 161
 162             return S_OK;
 163         }
 164
 165         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 166         {
 167             ID3D11Texture2D *texture;
 168             D3D11_TEXTURE2D_DESC texture_desc;
 169
 170             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture);
 171             if (FAILED(hr))
 172             {
 173                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D?\n");
 174                 return E_INVALIDARG;
 175             }
 176
 177             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 178             ID3D11Texture2D_Release(texture);
 179
 180             desc->Format = texture_desc.Format;
 181             if (texture_desc.ArraySize == 1)
 182             {
 183                 if (texture_desc.SampleDesc.Count == 1)
 184                 {
 185                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
 186                     desc->u.Texture2D.MipSlice = 0;
 187                 }
 188                 else
 189                 {
 190                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
 191                 }
 192             }
 193             else
 194             {
 195                 if (texture_desc.SampleDesc.Count == 1)
 196                 {
 197                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
 198                     desc->u.Texture2DArray.MipSlice = 0;
 199                     desc->u.Texture2DArray.FirstArraySlice = 0;
 200                     desc->u.Texture2DArray.ArraySize = 1;
 201                 }
 202                 else
 203                 {
 204                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY;
 205                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 206                     desc->u.Texture2DMSArray.ArraySize = 1;
 207                 }
 208             }
 209
 210             return S_OK;
 211         }
 212
 213         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 214         {
 215             ID3D11Texture3D *texture;
 216             D3D11_TEXTURE3D_DESC texture_desc;
 217
 218             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture);
 219             if (FAILED(hr))
 220             {
 221                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D?\n");
 222                 return E_INVALIDARG;
 223             }
 224
 225             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 226             ID3D11Texture3D_Release(texture);
 227
 228             desc->Format = texture_desc.Format;
 229             desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;
 230             desc->u.Texture3D.MipSlice = 0;
 231             desc->u.Texture3D.FirstWSlice = 0;
 232             desc->u.Texture3D.WSize = 1;
 233
 234             return S_OK;
 235         }
 236
 237         default:
 238             FIXME("Unhandled resource dimension %#x.\n", dimension);
 239             return E_INVALIDARG;
 240     }
 241 }
 242
 243 static HRESULT set_srdesc_from_resource(D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11Resource *resource)
 244 {
 245     D3D11_RESOURCE_DIMENSION dimension;
 246
 247     ID3D11Resource_GetType(resource, &dimension);
 248
 249     switch (dimension)
 250     {
 251         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 252         {
 253             D3D11_TEXTURE1D_DESC texture_desc;
 254             ID3D11Texture1D *texture;
 255
 256             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture)))
 257             {
 258                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D.\n");
 259                 return E_INVALIDARG;
 260             }
 261
 262             ID3D11Texture1D_GetDesc(texture, &texture_desc);
 263             ID3D11Texture1D_Release(texture);
 264
 265             desc->Format = texture_desc.Format;
 266             if (texture_desc.ArraySize == 1)
 267             {
 268                 desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
 269                 desc->u.Texture1D.MostDetailedMip = 0;
 270                 desc->u.Texture1D.MipLevels = texture_desc.MipLevels;
 271             }
 272             else
 273             {
 274                 desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY;
 275                 desc->u.Texture1DArray.MostDetailedMip = 0;
 276                 desc->u.Texture1DArray.MipLevels = texture_desc.MipLevels;
 277                 desc->u.Texture1DArray.FirstArraySlice = 0;
 278                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
 279             }
 280
 281             return S_OK;
 282         }
 283
 284         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 285         {
 286             D3D11_TEXTURE2D_DESC texture_desc;
 287             ID3D11Texture2D *texture;
 288
 289             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
 290             {
 291                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
 292                 return E_INVALIDARG;
 293             }
 294
 295             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 296             ID3D11Texture2D_Release(texture);
 297
 298             desc->Format = texture_desc.Format;
 299             if (texture_desc.ArraySize == 1)
 300             {
 301                 if (texture_desc.SampleDesc.Count == 1)
 302                 {
 303                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
 304                     desc->u.Texture2D.MostDetailedMip = 0;
 305                     desc->u.Texture2D.MipLevels = texture_desc.MipLevels;
 306                 }
 307                 else
 308                 {
 309                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
 310                 }
 311             }
 312             else
 313             {
 314                 if (texture_desc.SampleDesc.Count == 1)
 315                 {
 316                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
 317                     desc->u.Texture2DArray.MostDetailedMip = 0;
 318                     desc->u.Texture2DArray.MipLevels = texture_desc.MipLevels;
 319                     desc->u.Texture2DArray.FirstArraySlice = 0;
 320                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 321                 }
 322                 else
 323                 {
 324                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY;
 325                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 326                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 327                 }
 328             }
 329
 330             return S_OK;
 331         }
 332
 333         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 334         {
 335             D3D11_TEXTURE3D_DESC texture_desc;
 336             ID3D11Texture3D *texture;
 337
 338             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture)))
 339             {
 340                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D.\n");
 341                 return E_INVALIDARG;
 342             }
 343
 344             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 345             ID3D11Texture3D_Release(texture);
 346
 347             desc->Format = texture_desc.Format;
 348             desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
 349             desc->u.Texture3D.MostDetailedMip = 0;
 350             desc->u.Texture3D.MipLevels = texture_desc.MipLevels;
 351
 352             return S_OK;
 353         }
 354
 355         default:
 356             FIXME("Unhandled resource dimension %#x.\n", dimension);
 357         case D3D11_RESOURCE_DIMENSION_BUFFER:
 358             return E_INVALIDARG;
 359     }
 360 }
 361
 362 /* ID3D11DepthStencilView methods */
 363
 364 static inline struct d3d_depthstencil_view *impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
 365 {
 366     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D11DepthStencilView_iface);
 367 }
 368
 369 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_QueryInterface(ID3D11DepthStencilView *iface,
 370         REFIID riid, void **object)
 371 {
 372     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 373
 374     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 375
 376     if (IsEqualGUID(riid, &IID_ID3D11DepthStencilView)
 377             || IsEqualGUID(riid, &IID_ID3D11View)
 378             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 379             || IsEqualGUID(riid, &IID_IUnknown))
 380     {
 381         ID3D11DepthStencilView_AddRef(iface);
 382         *object = iface;
 383         return S_OK;
 384     }
 385
 386     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilView)
 387             || IsEqualGUID(riid, &IID_ID3D10View)
 388             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 389     {
 390         ID3D10DepthStencilView_AddRef(&view->ID3D10DepthStencilView_iface);
 391         *object = &view->ID3D10DepthStencilView_iface;
 392         return S_OK;
 393     }
 394
 395     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 396
 397     *object = NULL;
 398     return E_NOINTERFACE;
 399 }
 400
 401 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_AddRef(ID3D11DepthStencilView *iface)
 402 {
 403     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 404     ULONG refcount = InterlockedIncrement(&view->refcount);
 405
 406     TRACE("%p increasing refcount to %u.\n", view, refcount);
 407
 408     return refcount;
 409 }
 410
 411 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_Release(ID3D11DepthStencilView *iface)
 412 {
 413     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 414     ULONG refcount = InterlockedDecrement(&view->refcount);
 415
 416     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 417
 418     if (!refcount)
 419     {
 420         wined3d_mutex_lock();
 421         wined3d_rendertarget_view_decref(view->wined3d_view);
 422         ID3D11Resource_Release(view->resource);
 423         ID3D11Device_Release(view->device);
 424         wined3d_private_store_cleanup(&view->private_store);
 425         wined3d_mutex_unlock();
 426         HeapFree(GetProcessHeap(), 0, view);
 427     }
 428
 429     return refcount;
 430 }
 431
 432 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDevice(ID3D11DepthStencilView *iface,
 433         ID3D11Device **device)
 434 {
 435     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 436
 437     TRACE("iface %p, device %p.\n", iface, device);
 438
 439     *device = view->device;
 440     ID3D11Device_AddRef(*device);
 441 }
 442
 443 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_GetPrivateData(ID3D11DepthStencilView *iface,
 444         REFGUID guid, UINT *data_size, void *data)
 445 {
 446     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 447
 448     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 449
 450     return d3d_get_private_data(&view->private_store, guid, data_size, data);
 451 }
 452
 453 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateData(ID3D11DepthStencilView *iface,
 454         REFGUID guid, UINT data_size, const void *data)
 455 {
 456     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 457
 458     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 459
 460     return d3d_set_private_data(&view->private_store, guid, data_size, data);
 461 }
 462
 463 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateDataInterface(ID3D11DepthStencilView *iface,
 464         REFGUID guid, const IUnknown *data)
 465 {
 466     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 467
 468     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 469
 470     return d3d_set_private_data_interface(&view->private_store, guid, data);
 471 }
 472
 473 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetResource(ID3D11DepthStencilView *iface,
 474         ID3D11Resource **resource)
 475 {
 476     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 477
 478     TRACE("iface %p, resource %p.\n", iface, resource);
 479
 480     *resource = view->resource;
 481     ID3D11Resource_AddRef(*resource);
 482 }
 483
 484 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDesc(ID3D11DepthStencilView *iface,
 485         D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
 486 {
 487     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 488
 489     TRACE("iface %p, desc %p.\n", iface, desc);
 490
 491     *desc = view->desc;
 492 }
 493
 494 static const struct ID3D11DepthStencilViewVtbl d3d11_depthstencil_view_vtbl =
 495 {
 496     /* IUnknown methods */
 497     d3d11_depthstencil_view_QueryInterface,
 498     d3d11_depthstencil_view_AddRef,
 499     d3d11_depthstencil_view_Release,
 500     /* ID3D11DeviceChild methods */
 501     d3d11_depthstencil_view_GetDevice,
 502     d3d11_depthstencil_view_GetPrivateData,
 503     d3d11_depthstencil_view_SetPrivateData,
 504     d3d11_depthstencil_view_SetPrivateDataInterface,
 505     /* ID3D11View methods */
 506     d3d11_depthstencil_view_GetResource,
 507     /* ID3D11DepthStencilView methods */
 508     d3d11_depthstencil_view_GetDesc,
 509 };
 510
 511 /* ID3D10DepthStencilView methods */
 512
 513 static inline struct d3d_depthstencil_view *impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
 514 {
 515     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D10DepthStencilView_iface);
 516 }
 517
 518 /* IUnknown methods */
 519
 520 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_QueryInterface(ID3D10DepthStencilView *iface,
 521         REFIID riid, void **object)
 522 {
 523     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 524
 525     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 526
 527     return d3d11_depthstencil_view_QueryInterface(&view->ID3D11DepthStencilView_iface, riid, object);
 528 }
 529
 530 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_AddRef(ID3D10DepthStencilView *iface)
 531 {
 532     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 533
 534     TRACE("iface %p.\n", iface);
 535
 536     return d3d11_depthstencil_view_AddRef(&view->ID3D11DepthStencilView_iface);
 537 }
 538
 539 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_Release(ID3D10DepthStencilView *iface)
 540 {
 541     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 542
 543     TRACE("iface %p.\n", iface);
 544
 545     return d3d11_depthstencil_view_Release(&view->ID3D11DepthStencilView_iface);
 546 }
 547
 548 /* ID3D10DeviceChild methods */
 549
 550 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDevice(ID3D10DepthStencilView *iface, ID3D10Device **device)
 551 {
 552     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 553
 554     TRACE("iface %p, device %p.\n", iface, device);
 555
 556     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
 557 }
 558
 559 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_GetPrivateData(ID3D10DepthStencilView *iface,
 560         REFGUID guid, UINT *data_size, void *data)
 561 {
 562     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 563
 564     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 565             iface, debugstr_guid(guid), data_size, data);
 566
 567     return d3d_get_private_data(&view->private_store, guid, data_size, data);
 568 }
 569
 570 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateData(ID3D10DepthStencilView *iface,
 571         REFGUID guid, UINT data_size, const void *data)
 572 {
 573     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 574
 575     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 576             iface, debugstr_guid(guid), data_size, data);
 577
 578     return d3d_set_private_data(&view->private_store, guid, data_size, data);
 579 }
 580
 581 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateDataInterface(ID3D10DepthStencilView *iface,
 582         REFGUID guid, const IUnknown *data)
 583 {
 584     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 585
 586     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 587
 588     return d3d_set_private_data_interface(&view->private_store, guid, data);
 589 }
 590
 591 /* ID3D10View methods */
 592
 593 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetResource(ID3D10DepthStencilView *iface,
 594         ID3D10Resource **resource)
 595 {
 596     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 597
 598     TRACE("iface %p, resource %p.\n", iface, resource);
 599
 600     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
 601 }
 602
 603 /* ID3D10DepthStencilView methods */
 604
 605 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDesc(ID3D10DepthStencilView *iface,
 606         D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
 607 {
 608     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 609     const D3D11_DEPTH_STENCIL_VIEW_DESC *d3d11_desc = &view->desc;
 610
 611     TRACE("iface %p, desc %p.\n", iface, desc);
 612
 613     desc->Format = d3d11_desc->Format;
 614     desc->ViewDimension = (D3D10_DSV_DIMENSION)d3d11_desc->ViewDimension;
 615     memcpy(&desc->u, &d3d11_desc->u, sizeof(desc->u));
 616 }
 617
 618 static const struct ID3D10DepthStencilViewVtbl d3d10_depthstencil_view_vtbl =
 619 {
 620     /* IUnknown methods */
 621     d3d10_depthstencil_view_QueryInterface,
 622     d3d10_depthstencil_view_AddRef,
 623     d3d10_depthstencil_view_Release,
 624     /* ID3D10DeviceChild methods */
 625     d3d10_depthstencil_view_GetDevice,
 626     d3d10_depthstencil_view_GetPrivateData,
 627     d3d10_depthstencil_view_SetPrivateData,
 628     d3d10_depthstencil_view_SetPrivateDataInterface,
 629     /* ID3D10View methods */
 630     d3d10_depthstencil_view_GetResource,
 631     /* ID3D10DepthStencilView methods */
 632     d3d10_depthstencil_view_GetDesc,
 633 };
 634
 635 static void wined3d_depth_stencil_view_desc_from_d3d11(struct wined3d_rendertarget_view_desc *wined3d_desc,
 636         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
 637 {
 638     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
 639
 640     if (desc->Flags)
 641         FIXME("Unhandled depth stencil view flags %#x.\n", desc->Flags);
 642
 643     switch (desc->ViewDimension)
 644     {
 645         case D3D11_DSV_DIMENSION_TEXTURE1D:
 646             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
 647             wined3d_desc->u.texture.layer_idx = 0;
 648             wined3d_desc->u.texture.layer_count = 1;
 649             break;
 650
 651         case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
 652             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
 653             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
 654             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
 655             break;
 656
 657         case D3D11_DSV_DIMENSION_TEXTURE2D:
 658             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
 659             wined3d_desc->u.texture.layer_idx = 0;
 660             wined3d_desc->u.texture.layer_count = 1;
 661             break;
 662
 663         case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
 664             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
 665             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
 666             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
 667             break;
 668
 669         case D3D11_DSV_DIMENSION_TEXTURE2DMS:
 670             wined3d_desc->u.texture.level_idx = 0;
 671             wined3d_desc->u.texture.layer_idx = 0;
 672             wined3d_desc->u.texture.layer_count = 1;
 673             break;
 674
 675         case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
 676             wined3d_desc->u.texture.level_idx = 0;
 677             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
 678             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
 679             break;
 680
 681         default:
 682             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
 683             wined3d_desc->u.texture.level_idx = 0;
 684             wined3d_desc->u.texture.layer_idx = 0;
 685             wined3d_desc->u.texture.layer_count = 1;
 686             break;
 687     }
 688 }
 689
 690 static HRESULT d3d_depthstencil_view_init(struct d3d_depthstencil_view *view, struct d3d_device *device,
 691         ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
 692 {
 693     struct wined3d_rendertarget_view_desc wined3d_desc;
 694     struct wined3d_resource *wined3d_resource;
 695     HRESULT hr;
 696
 697     view->ID3D11DepthStencilView_iface.lpVtbl = &d3d11_depthstencil_view_vtbl;
 698     view->ID3D10DepthStencilView_iface.lpVtbl = &d3d10_depthstencil_view_vtbl;
 699     view->refcount = 1;
 700
 701     if (!desc)
 702     {
 703         if (FAILED(hr = set_dsdesc_from_resource(&view->desc, resource)))
 704             return hr;
 705     }
 706     else
 707     {
 708         view->desc = *desc;
 709     }
 710
 711     wined3d_mutex_lock();
 712     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
 713     {
 714         wined3d_mutex_unlock();
 715         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
 716         return E_FAIL;
 717     }
 718
 719     wined3d_depth_stencil_view_desc_from_d3d11(&wined3d_desc, &view->desc);
 720     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
 721             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
 722     {
 723         wined3d_mutex_unlock();
 724         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
 725         return hr;
 726     }
 727
 728     wined3d_private_store_init(&view->private_store);
 729     wined3d_mutex_unlock();
 730     view->resource = resource;
 731     ID3D11Resource_AddRef(resource);
 732     view->device = &device->ID3D11Device_iface;
 733     ID3D11Device_AddRef(view->device);
 734
 735     return S_OK;
 736 }
 737
 738 HRESULT d3d_depthstencil_view_create(struct d3d_device *device, ID3D11Resource *resource,
 739         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, struct d3d_depthstencil_view **view)
 740 {
 741     struct d3d_depthstencil_view *object;
 742     HRESULT hr;
 743
 744     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 745         return E_OUTOFMEMORY;
 746
 747     if (FAILED(hr = d3d_depthstencil_view_init(object, device, resource, desc)))
 748     {
 749         WARN("Failed to initialize depthstencil view, hr %#x.\n", hr);
 750         HeapFree(GetProcessHeap(), 0, object);
 751         return hr;
 752     }
 753
 754     TRACE("Created depthstencil view %p.\n", object);
 755     *view = object;
 756
 757     return S_OK;
 758 }
 759
 760 struct d3d_depthstencil_view *unsafe_impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
 761 {
 762     if (!iface)
 763         return NULL;
 764     assert(iface->lpVtbl == &d3d11_depthstencil_view_vtbl);
 765
 766     return impl_from_ID3D11DepthStencilView(iface);
 767 }
 768
 769 struct d3d_depthstencil_view *unsafe_impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
 770 {
 771     if (!iface)
 772         return NULL;
 773     assert(iface->lpVtbl == &d3d10_depthstencil_view_vtbl);
 774
 775     return impl_from_ID3D10DepthStencilView(iface);
 776 }
 777
 778 /* ID3D11RenderTargetView methods */
 779
 780 static inline struct d3d_rendertarget_view *impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
 781 {
 782     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D11RenderTargetView_iface);
 783 }
 784
 785 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_QueryInterface(ID3D11RenderTargetView *iface,
 786         REFIID riid, void **object)
 787 {
 788     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 789
 790     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 791
 792     if (IsEqualGUID(riid, &IID_ID3D11RenderTargetView)
 793             || IsEqualGUID(riid, &IID_ID3D11View)
 794             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 795             || IsEqualGUID(riid, &IID_IUnknown))
 796     {
 797         ID3D11RenderTargetView_AddRef(iface);
 798         *object = iface;
 799         return S_OK;
 800     }
 801
 802     if (IsEqualGUID(riid, &IID_ID3D10RenderTargetView)
 803             || IsEqualGUID(riid, &IID_ID3D10View)
 804             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 805     {
 806         ID3D10RenderTargetView_AddRef(&view->ID3D10RenderTargetView_iface);
 807         *object = &view->ID3D10RenderTargetView_iface;
 808         return S_OK;
 809     }
 810
 811     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 812
 813     *object = NULL;
 814     return E_NOINTERFACE;
 815 }
 816
 817 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_AddRef(ID3D11RenderTargetView *iface)
 818 {
 819     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 820     ULONG refcount = InterlockedIncrement(&view->refcount);
 821
 822     TRACE("%p increasing refcount to %u.\n", view, refcount);
 823
 824     return refcount;
 825 }
 826
 827 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_Release(ID3D11RenderTargetView *iface)
 828 {
 829     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 830     ULONG refcount = InterlockedDecrement(&view->refcount);
 831
 832     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 833
 834     if (!refcount)
 835     {
 836         wined3d_mutex_lock();
 837         wined3d_rendertarget_view_decref(view->wined3d_view);
 838         ID3D11Resource_Release(view->resource);
 839         ID3D11Device_Release(view->device);
 840         wined3d_private_store_cleanup(&view->private_store);
 841         wined3d_mutex_unlock();
 842         HeapFree(GetProcessHeap(), 0, view);
 843     }
 844
 845     return refcount;
 846 }
 847
 848 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDevice(ID3D11RenderTargetView *iface,
 849         ID3D11Device **device)
 850 {
 851     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 852
 853     TRACE("iface %p, device %p.\n", iface, device);
 854
 855     *device = view->device;
 856     ID3D11Device_AddRef(*device);
 857 }
 858
 859 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_GetPrivateData(ID3D11RenderTargetView *iface,
 860         REFGUID guid, UINT *data_size, void *data)
 861 {
 862     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 863
 864     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 865
 866     return d3d_get_private_data(&view->private_store, guid, data_size, data);
 867 }
 868
 869 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateData(ID3D11RenderTargetView *iface,
 870         REFGUID guid, UINT data_size, const void *data)
 871 {
 872     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 873
 874     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 875
 876     return d3d_set_private_data(&view->private_store, guid, data_size, data);
 877 }
 878
 879 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateDataInterface(ID3D11RenderTargetView *iface,
 880         REFGUID guid, const IUnknown *data)
 881 {
 882     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 883
 884     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 885
 886     return d3d_set_private_data_interface(&view->private_store, guid, data);
 887 }
 888
 889 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetResource(ID3D11RenderTargetView *iface,
 890         ID3D11Resource **resource)
 891 {
 892     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 893
 894     TRACE("iface %p, resource %p.\n", iface, resource);
 895
 896     *resource = view->resource;
 897     ID3D11Resource_AddRef(*resource);
 898 }
 899
 900 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDesc(ID3D11RenderTargetView *iface,
 901         D3D11_RENDER_TARGET_VIEW_DESC *desc)
 902 {
 903     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 904
 905     TRACE("iface %p, desc %p.\n", iface, desc);
 906
 907     *desc = view->desc;
 908 }
 909
 910 static const struct ID3D11RenderTargetViewVtbl d3d11_rendertarget_view_vtbl =
 911 {
 912     /* IUnknown methods */
 913     d3d11_rendertarget_view_QueryInterface,
 914     d3d11_rendertarget_view_AddRef,
 915     d3d11_rendertarget_view_Release,
 916     /* ID3D11DeviceChild methods */
 917     d3d11_rendertarget_view_GetDevice,
 918     d3d11_rendertarget_view_GetPrivateData,
 919     d3d11_rendertarget_view_SetPrivateData,
 920     d3d11_rendertarget_view_SetPrivateDataInterface,
 921     /* ID3D11View methods */
 922     d3d11_rendertarget_view_GetResource,
 923     /* ID3D11RenderTargetView methods */
 924     d3d11_rendertarget_view_GetDesc,
 925 };
 926
 927 /* ID3D10RenderTargetView methods */
 928
 929 static inline struct d3d_rendertarget_view *impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
 930 {
 931     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D10RenderTargetView_iface);
 932 }
 933
 934 /* IUnknown methods */
 935
 936 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_QueryInterface(ID3D10RenderTargetView *iface,
 937         REFIID riid, void **object)
 938 {
 939     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 940
 941     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 942
 943     return d3d11_rendertarget_view_QueryInterface(&view->ID3D11RenderTargetView_iface, riid, object);
 944 }
 945
 946 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_AddRef(ID3D10RenderTargetView *iface)
 947 {
 948     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 949
 950     TRACE("iface %p.\n", iface);
 951
 952     return d3d11_rendertarget_view_AddRef(&view->ID3D11RenderTargetView_iface);
 953 }
 954
 955 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_Release(ID3D10RenderTargetView *iface)
 956 {
 957     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 958
 959     TRACE("iface %p.\n", iface);
 960
 961     return d3d11_rendertarget_view_Release(&view->ID3D11RenderTargetView_iface);
 962 }
 963
 964 /* ID3D10DeviceChild methods */
 965
 966 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDevice(ID3D10RenderTargetView *iface, ID3D10Device **device)
 967 {
 968     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 969
 970     TRACE("iface %p, device %p.\n", iface, device);
 971
 972     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
 973 }
 974
 975 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_GetPrivateData(ID3D10RenderTargetView *iface,
 976         REFGUID guid, UINT *data_size, void *data)
 977 {
 978     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 979
 980     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 981             iface, debugstr_guid(guid), data_size, data);
 982
 983     return d3d_get_private_data(&view->private_store, guid, data_size, data);
 984 }
 985
 986 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateData(ID3D10RenderTargetView *iface,
 987         REFGUID guid, UINT data_size, const void *data)
 988 {
 989     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 990
 991     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 992             iface, debugstr_guid(guid), data_size, data);
 993
 994     return d3d_set_private_data(&view->private_store, guid, data_size, data);
 995 }
 996
 997 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateDataInterface(ID3D10RenderTargetView *iface,
 998         REFGUID guid, const IUnknown *data)
 999 {
1000     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1001
1002     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1003
1004     return d3d_set_private_data_interface(&view->private_store, guid, data);
1005 }
1006
1007 /* ID3D10View methods */
1008
1009 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTargetView *iface,
1010         ID3D10Resource **resource)
1011 {
1012     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1013
1014     TRACE("iface %p, resource %p\n", iface, resource);
1015
1016     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1017 }
1018
1019 /* ID3D10RenderTargetView methods */
1020
1021 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDesc(ID3D10RenderTargetView *iface,
1022         D3D10_RENDER_TARGET_VIEW_DESC *desc)
1023 {
1024     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1025
1026     TRACE("iface %p, desc %p\n", iface, desc);
1027
1028     memcpy(desc, &view->desc, sizeof(*desc));
1029 }
1030
1031 static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl =
1032 {
1033     /* IUnknown methods */
1034     d3d10_rendertarget_view_QueryInterface,
1035     d3d10_rendertarget_view_AddRef,
1036     d3d10_rendertarget_view_Release,
1037     /* ID3D10DeviceChild methods */
1038     d3d10_rendertarget_view_GetDevice,
1039     d3d10_rendertarget_view_GetPrivateData,
1040     d3d10_rendertarget_view_SetPrivateData,
1041     d3d10_rendertarget_view_SetPrivateDataInterface,
1042     /* ID3D10View methods */
1043     d3d10_rendertarget_view_GetResource,
1044     /* ID3D10RenderTargetView methods */
1045     d3d10_rendertarget_view_GetDesc,
1046 };
1047
1048 static void wined3d_rendertarget_view_desc_from_d3d11(struct wined3d_rendertarget_view_desc *wined3d_desc,
1049         const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1050 {
1051     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1052
1053     switch (desc->ViewDimension)
1054     {
1055         case D3D11_RTV_DIMENSION_BUFFER:
1056             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
1057             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
1058             break;
1059
1060         case D3D11_RTV_DIMENSION_TEXTURE1D:
1061             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1062             wined3d_desc->u.texture.layer_idx = 0;
1063             wined3d_desc->u.texture.layer_count = 1;
1064             break;
1065
1066         case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
1067             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1068             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1069             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1070             break;
1071
1072         case D3D11_RTV_DIMENSION_TEXTURE2D:
1073             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1074             wined3d_desc->u.texture.layer_idx = 0;
1075             wined3d_desc->u.texture.layer_count = 1;
1076             break;
1077
1078         case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
1079             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1080             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1081             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1082             break;
1083
1084         case D3D11_RTV_DIMENSION_TEXTURE2DMS:
1085             wined3d_desc->u.texture.level_idx = 0;
1086             wined3d_desc->u.texture.layer_idx = 0;
1087             wined3d_desc->u.texture.layer_count = 1;
1088             break;
1089
1090         case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
1091             wined3d_desc->u.texture.level_idx = 0;
1092             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1093             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1094             break;
1095
1096         case D3D11_RTV_DIMENSION_TEXTURE3D:
1097             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
1098             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
1099             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
1100             break;
1101
1102         default:
1103             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1104             wined3d_desc->u.texture.level_idx = 0;
1105             wined3d_desc->u.texture.layer_idx = 0;
1106             wined3d_desc->u.texture.layer_count = 1;
1107             break;
1108     }
1109 }
1110
1111 static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, struct d3d_device *device,
1112         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1113 {
1114     struct wined3d_rendertarget_view_desc wined3d_desc;
1115     struct wined3d_resource *wined3d_resource;
1116     HRESULT hr;
1117
1118     view->ID3D11RenderTargetView_iface.lpVtbl = &d3d11_rendertarget_view_vtbl;
1119     view->ID3D10RenderTargetView_iface.lpVtbl = &d3d10_rendertarget_view_vtbl;
1120     view->refcount = 1;
1121
1122     if (!desc)
1123     {
1124         HRESULT hr = set_rtdesc_from_resource(&view->desc, resource);
1125         if (FAILED(hr)) return hr;
1126     }
1127     else
1128     {
1129         view->desc = *desc;
1130     }
1131
1132     wined3d_mutex_lock();
1133     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1134     {
1135         wined3d_mutex_unlock();
1136         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1137         return E_FAIL;
1138     }
1139
1140     wined3d_rendertarget_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1141     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1142             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
1143     {
1144         wined3d_mutex_unlock();
1145         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1146         return hr;
1147     }
1148
1149     wined3d_private_store_init(&view->private_store);
1150     wined3d_mutex_unlock();
1151     view->resource = resource;
1152     ID3D11Resource_AddRef(resource);
1153     view->device = &device->ID3D11Device_iface;
1154     ID3D11Device_AddRef(view->device);
1155
1156     return S_OK;
1157 }
1158
1159 HRESULT d3d_rendertarget_view_create(struct d3d_device *device, ID3D11Resource *resource,
1160         const D3D11_RENDER_TARGET_VIEW_DESC *desc, struct d3d_rendertarget_view **view)
1161 {
1162     struct d3d_rendertarget_view *object;
1163     HRESULT hr;
1164
1165     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1166         return E_OUTOFMEMORY;
1167
1168     if (FAILED(hr = d3d_rendertarget_view_init(object, device, resource, desc)))
1169     {
1170         WARN("Failed to initialize rendertarget view, hr %#x.\n", hr);
1171         HeapFree(GetProcessHeap(), 0, object);
1172         return hr;
1173     }
1174
1175     TRACE("Created rendertarget view %p.\n", object);
1176     *view = object;
1177
1178     return S_OK;
1179 }
1180
1181 struct d3d_rendertarget_view *unsafe_impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
1182 {
1183     if (!iface)
1184         return NULL;
1185     assert(iface->lpVtbl == &d3d11_rendertarget_view_vtbl);
1186
1187     return impl_from_ID3D11RenderTargetView(iface);
1188 }
1189
1190 struct d3d_rendertarget_view *unsafe_impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1191 {
1192     if (!iface)
1193         return NULL;
1194     assert(iface->lpVtbl == &d3d10_rendertarget_view_vtbl);
1195
1196     return impl_from_ID3D10RenderTargetView(iface);
1197 }
1198
1199 /* ID3D11ShaderResourceView methods */
1200
1201 static inline struct d3d_shader_resource_view *impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
1202 {
1203     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D11ShaderResourceView_iface);
1204 }
1205
1206 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_QueryInterface(ID3D11ShaderResourceView *iface,
1207         REFIID riid, void **object)
1208 {
1209     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1210
1211     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1212
1213     if (IsEqualGUID(riid, &IID_ID3D11ShaderResourceView)
1214             || IsEqualGUID(riid, &IID_ID3D11View)
1215             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1216             || IsEqualGUID(riid, &IID_IUnknown))
1217     {
1218         ID3D11ShaderResourceView_AddRef(iface);
1219         *object = iface;
1220         return S_OK;
1221     }
1222
1223     if (IsEqualGUID(riid, &IID_ID3D10ShaderResourceView1)
1224             || IsEqualGUID(riid, &IID_ID3D10ShaderResourceView)
1225             || IsEqualGUID(riid, &IID_ID3D10View)
1226             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1227     {
1228         ID3D10ShaderResourceView1_AddRef(&view->ID3D10ShaderResourceView1_iface);
1229         *object = &view->ID3D10ShaderResourceView1_iface;
1230         return S_OK;
1231     }
1232
1233     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1234
1235     *object = NULL;
1236     return E_NOINTERFACE;
1237 }
1238
1239 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_AddRef(ID3D11ShaderResourceView *iface)
1240 {
1241     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1242     ULONG refcount = InterlockedIncrement(&view->refcount);
1243
1244     TRACE("%p increasing refcount to %u.\n", view, refcount);
1245
1246     return refcount;
1247 }
1248
1249 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_Release(ID3D11ShaderResourceView *iface)
1250 {
1251     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1252     ULONG refcount = InterlockedDecrement(&view->refcount);
1253
1254     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1255
1256     if (!refcount)
1257     {
1258         wined3d_mutex_lock();
1259         wined3d_shader_resource_view_decref(view->wined3d_view);
1260         ID3D11Resource_Release(view->resource);
1261         ID3D11Device_Release(view->device);
1262         wined3d_private_store_cleanup(&view->private_store);
1263         wined3d_mutex_unlock();
1264         HeapFree(GetProcessHeap(), 0, view);
1265     }
1266
1267     return refcount;
1268 }
1269
1270 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDevice(ID3D11ShaderResourceView *iface,
1271         ID3D11Device **device)
1272 {
1273     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1274
1275     TRACE("iface %p, device %p.\n", iface, device);
1276
1277     *device = view->device;
1278     ID3D11Device_AddRef(*device);
1279 }
1280
1281 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_GetPrivateData(ID3D11ShaderResourceView *iface,
1282         REFGUID guid, UINT *data_size, void *data)
1283 {
1284     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1285
1286     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1287
1288     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1289 }
1290
1291 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateData(ID3D11ShaderResourceView *iface,
1292         REFGUID guid, UINT data_size, const void *data)
1293 {
1294     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1295
1296     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1297
1298     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1299 }
1300
1301 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateDataInterface(ID3D11ShaderResourceView *iface,
1302         REFGUID guid, const IUnknown *data)
1303 {
1304     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1305
1306     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1307
1308     return d3d_set_private_data_interface(&view->private_store, guid, data);
1309 }
1310
1311 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetResource(ID3D11ShaderResourceView *iface,
1312         ID3D11Resource **resource)
1313 {
1314     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1315
1316     TRACE("iface %p, resource %p.\n", iface, resource);
1317
1318     *resource = view->resource;
1319     ID3D11Resource_AddRef(*resource);
1320 }
1321
1322 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDesc(ID3D11ShaderResourceView *iface,
1323         D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
1324 {
1325     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1326
1327     TRACE("iface %p, desc %p.\n", iface, desc);
1328
1329     *desc = view->desc;
1330 }
1331
1332 static const struct ID3D11ShaderResourceViewVtbl d3d11_shader_resource_view_vtbl =
1333 {
1334     /* IUnknown methods */
1335     d3d11_shader_resource_view_QueryInterface,
1336     d3d11_shader_resource_view_AddRef,
1337     d3d11_shader_resource_view_Release,
1338     /* ID3D11DeviceChild methods */
1339     d3d11_shader_resource_view_GetDevice,
1340     d3d11_shader_resource_view_GetPrivateData,
1341     d3d11_shader_resource_view_SetPrivateData,
1342     d3d11_shader_resource_view_SetPrivateDataInterface,
1343     /* ID3D11View methods */
1344     d3d11_shader_resource_view_GetResource,
1345     /* ID3D11ShaderResourceView methods */
1346     d3d11_shader_resource_view_GetDesc,
1347 };
1348
1349 /* ID3D10ShaderResourceView methods */
1350
1351 static inline struct d3d_shader_resource_view *impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView1 *iface)
1352 {
1353     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
1354 }
1355
1356 /* IUnknown methods */
1357
1358 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_QueryInterface(ID3D10ShaderResourceView1 *iface,
1359         REFIID riid, void **object)
1360 {
1361     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1362
1363     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1364
1365     return d3d11_shader_resource_view_QueryInterface(&view->ID3D11ShaderResourceView_iface, riid, object);
1366 }
1367
1368 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_AddRef(ID3D10ShaderResourceView1 *iface)
1369 {
1370     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1371
1372     TRACE("iface %p.\n", iface);
1373
1374     return d3d11_shader_resource_view_AddRef(&view->ID3D11ShaderResourceView_iface);
1375 }
1376
1377 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_Release(ID3D10ShaderResourceView1 *iface)
1378 {
1379     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1380
1381     TRACE("iface %p.\n", iface);
1382
1383     return d3d11_shader_resource_view_Release(&view->ID3D11ShaderResourceView_iface);
1384 }
1385
1386 /* ID3D10DeviceChild methods */
1387
1388 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDevice(ID3D10ShaderResourceView1 *iface,
1389         ID3D10Device **device)
1390 {
1391     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1392
1393     TRACE("iface %p, device %p.\n", iface, device);
1394
1395     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1396 }
1397
1398 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_GetPrivateData(ID3D10ShaderResourceView1 *iface,
1399         REFGUID guid, UINT *data_size, void *data)
1400 {
1401     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1402
1403     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1404             iface, debugstr_guid(guid), data_size, data);
1405
1406     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1407 }
1408
1409 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateData(ID3D10ShaderResourceView1 *iface,
1410         REFGUID guid, UINT data_size, const void *data)
1411 {
1412     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1413
1414     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1415             iface, debugstr_guid(guid), data_size, data);
1416
1417     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1418 }
1419
1420 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateDataInterface(ID3D10ShaderResourceView1 *iface,
1421         REFGUID guid, const IUnknown *data)
1422 {
1423     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1424
1425     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1426
1427     return d3d_set_private_data_interface(&view->private_store, guid, data);
1428 }
1429
1430 /* ID3D10View methods */
1431
1432 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetResource(ID3D10ShaderResourceView1 *iface,
1433         ID3D10Resource **resource)
1434 {
1435     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1436
1437     TRACE("iface %p, resource %p.\n", iface, resource);
1438
1439     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1440 }
1441
1442 /* ID3D10ShaderResourceView methods */
1443
1444 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc(ID3D10ShaderResourceView1 *iface,
1445         D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
1446 {
1447     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1448
1449     TRACE("iface %p, desc %p.\n", iface, desc);
1450
1451     memcpy(desc, &view->desc, sizeof(*desc));
1452 }
1453
1454 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc1(ID3D10ShaderResourceView1 *iface,
1455         D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc)
1456 {
1457     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1458
1459     TRACE("iface %p, desc %p.\n", iface, desc);
1460
1461     memcpy(desc, &view->desc, sizeof(*desc));
1462 }
1463
1464 static const struct ID3D10ShaderResourceView1Vtbl d3d10_shader_resource_view_vtbl =
1465 {
1466     /* IUnknown methods */
1467     d3d10_shader_resource_view_QueryInterface,
1468     d3d10_shader_resource_view_AddRef,
1469     d3d10_shader_resource_view_Release,
1470     /* ID3D10DeviceChild methods */
1471     d3d10_shader_resource_view_GetDevice,
1472     d3d10_shader_resource_view_GetPrivateData,
1473     d3d10_shader_resource_view_SetPrivateData,
1474     d3d10_shader_resource_view_SetPrivateDataInterface,
1475     /* ID3D10View methods */
1476     d3d10_shader_resource_view_GetResource,
1477     /* ID3D10ShaderResourceView methods */
1478     d3d10_shader_resource_view_GetDesc,
1479     /* ID3D10ShaderResourceView1 methods */
1480     d3d10_shader_resource_view_GetDesc1,
1481 };
1482
1483 static HRESULT d3d_shader_resource_view_init(struct d3d_shader_resource_view *view, struct d3d_device *device,
1484         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
1485 {
1486     struct wined3d_resource *wined3d_resource;
1487     HRESULT hr;
1488
1489     view->ID3D11ShaderResourceView_iface.lpVtbl = &d3d11_shader_resource_view_vtbl;
1490     view->ID3D10ShaderResourceView1_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
1491     view->refcount = 1;
1492
1493     if (!desc)
1494     {
1495         if (FAILED(hr = set_srdesc_from_resource(&view->desc, resource)))
1496             return hr;
1497     }
1498     else
1499     {
1500         view->desc = *desc;
1501     }
1502
1503     wined3d_mutex_lock();
1504     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1505     {
1506         ERR("Failed to get wined3d resource for d3d10 resource %p.\n", resource);
1507         return E_FAIL;
1508     }
1509
1510     if (FAILED(hr = wined3d_shader_resource_view_create(wined3d_resource,
1511             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
1512     {
1513         WARN("Failed to create wined3d shader resource view, hr %#x.\n", hr);
1514         return hr;
1515     }
1516
1517     wined3d_private_store_init(&view->private_store);
1518     wined3d_mutex_unlock();
1519     view->resource = resource;
1520     ID3D11Resource_AddRef(resource);
1521     view->device = &device->ID3D11Device_iface;
1522     ID3D11Device_AddRef(view->device);
1523
1524     return S_OK;
1525 }
1526
1527 HRESULT d3d_shader_resource_view_create(struct d3d_device *device, ID3D11Resource *resource,
1528         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, struct d3d_shader_resource_view **view)
1529 {
1530     struct d3d_shader_resource_view *object;
1531     HRESULT hr;
1532
1533     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1534         return E_OUTOFMEMORY;
1535
1536     if (FAILED(hr = d3d_shader_resource_view_init(object, device, resource, desc)))
1537     {
1538         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
1539         HeapFree(GetProcessHeap(), 0, object);
1540         return hr;
1541     }
1542
1543     TRACE("Created shader resource view %p.\n", object);
1544     *view = object;
1545
1546     return S_OK;
1547 }
1548
1549 struct d3d_shader_resource_view *unsafe_impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
1550 {
1551     if (!iface)
1552         return NULL;
1553     assert(iface->lpVtbl == &d3d11_shader_resource_view_vtbl);
1554     return impl_from_ID3D11ShaderResourceView(iface);
1555 }
1556
1557 struct d3d_shader_resource_view *unsafe_impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
1558 {
1559     if (!iface)
1560         return NULL;
1561     assert(iface->lpVtbl == (ID3D10ShaderResourceViewVtbl *)&d3d10_shader_resource_view_vtbl);
1562     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
1563 }