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, &d3d10_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_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
 761 {
 762     if (!iface)
 763         return NULL;
 764     assert(iface->lpVtbl == &d3d10_depthstencil_view_vtbl);
 765
 766     return impl_from_ID3D10DepthStencilView(iface);
 767 }
 768
 769 /* ID3D11RenderTargetView methods */
 770
 771 static inline struct d3d_rendertarget_view *impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
 772 {
 773     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D11RenderTargetView_iface);
 774 }
 775
 776 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_QueryInterface(ID3D11RenderTargetView *iface,
 777         REFIID riid, void **object)
 778 {
 779     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 780
 781     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 782
 783     if (IsEqualGUID(riid, &IID_ID3D11RenderTargetView)
 784             || IsEqualGUID(riid, &IID_ID3D11View)
 785             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 786             || IsEqualGUID(riid, &IID_IUnknown))
 787     {
 788         ID3D11RenderTargetView_AddRef(iface);
 789         *object = iface;
 790         return S_OK;
 791     }
 792
 793     if (IsEqualGUID(riid, &IID_ID3D10RenderTargetView)
 794             || IsEqualGUID(riid, &IID_ID3D10View)
 795             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 796     {
 797         ID3D10RenderTargetView_AddRef(&view->ID3D10RenderTargetView_iface);
 798         *object = &view->ID3D10RenderTargetView_iface;
 799         return S_OK;
 800     }
 801
 802     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 803
 804     *object = NULL;
 805     return E_NOINTERFACE;
 806 }
 807
 808 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_AddRef(ID3D11RenderTargetView *iface)
 809 {
 810     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 811     ULONG refcount = InterlockedIncrement(&view->refcount);
 812
 813     TRACE("%p increasing refcount to %u.\n", view, refcount);
 814
 815     return refcount;
 816 }
 817
 818 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_Release(ID3D11RenderTargetView *iface)
 819 {
 820     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 821     ULONG refcount = InterlockedDecrement(&view->refcount);
 822
 823     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 824
 825     if (!refcount)
 826     {
 827         wined3d_mutex_lock();
 828         wined3d_rendertarget_view_decref(view->wined3d_view);
 829         ID3D11Resource_Release(view->resource);
 830         ID3D11Device_Release(view->device);
 831         wined3d_private_store_cleanup(&view->private_store);
 832         wined3d_mutex_unlock();
 833         HeapFree(GetProcessHeap(), 0, view);
 834     }
 835
 836     return refcount;
 837 }
 838
 839 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDevice(ID3D11RenderTargetView *iface,
 840         ID3D11Device **device)
 841 {
 842     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 843
 844     TRACE("iface %p, device %p.\n", iface, device);
 845
 846     *device = view->device;
 847     ID3D11Device_AddRef(*device);
 848 }
 849
 850 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_GetPrivateData(ID3D11RenderTargetView *iface,
 851         REFGUID guid, UINT *data_size, void *data)
 852 {
 853     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 854
 855     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 856
 857     return d3d_get_private_data(&view->private_store, guid, data_size, data);
 858 }
 859
 860 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateData(ID3D11RenderTargetView *iface,
 861         REFGUID guid, UINT data_size, const void *data)
 862 {
 863     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 864
 865     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 866
 867     return d3d_set_private_data(&view->private_store, guid, data_size, data);
 868 }
 869
 870 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateDataInterface(ID3D11RenderTargetView *iface,
 871         REFGUID guid, const IUnknown *data)
 872 {
 873     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 874
 875     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 876
 877     return d3d_set_private_data_interface(&view->private_store, guid, data);
 878 }
 879
 880 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetResource(ID3D11RenderTargetView *iface,
 881         ID3D11Resource **resource)
 882 {
 883     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 884
 885     TRACE("iface %p, resource %p.\n", iface, resource);
 886
 887     *resource = view->resource;
 888     ID3D11Resource_AddRef(*resource);
 889 }
 890
 891 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDesc(ID3D11RenderTargetView *iface,
 892         D3D11_RENDER_TARGET_VIEW_DESC *desc)
 893 {
 894     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
 895
 896     TRACE("iface %p, desc %p.\n", iface, desc);
 897
 898     *desc = view->desc;
 899 }
 900
 901 static const struct ID3D11RenderTargetViewVtbl d3d11_rendertarget_view_vtbl =
 902 {
 903     /* IUnknown methods */
 904     d3d11_rendertarget_view_QueryInterface,
 905     d3d11_rendertarget_view_AddRef,
 906     d3d11_rendertarget_view_Release,
 907     /* ID3D11DeviceChild methods */
 908     d3d11_rendertarget_view_GetDevice,
 909     d3d11_rendertarget_view_GetPrivateData,
 910     d3d11_rendertarget_view_SetPrivateData,
 911     d3d11_rendertarget_view_SetPrivateDataInterface,
 912     /* ID3D11View methods */
 913     d3d11_rendertarget_view_GetResource,
 914     /* ID3D11RenderTargetView methods */
 915     d3d11_rendertarget_view_GetDesc,
 916 };
 917
 918 /* ID3D10RenderTargetView methods */
 919
 920 static inline struct d3d_rendertarget_view *impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
 921 {
 922     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D10RenderTargetView_iface);
 923 }
 924
 925 /* IUnknown methods */
 926
 927 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_QueryInterface(ID3D10RenderTargetView *iface,
 928         REFIID riid, void **object)
 929 {
 930     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 931
 932     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 933
 934     return d3d11_rendertarget_view_QueryInterface(&view->ID3D11RenderTargetView_iface, riid, object);
 935 }
 936
 937 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_AddRef(ID3D10RenderTargetView *iface)
 938 {
 939     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 940
 941     TRACE("iface %p.\n", iface);
 942
 943     return d3d11_rendertarget_view_AddRef(&view->ID3D11RenderTargetView_iface);
 944 }
 945
 946 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_Release(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_Release(&view->ID3D11RenderTargetView_iface);
 953 }
 954
 955 /* ID3D10DeviceChild methods */
 956
 957 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDevice(ID3D10RenderTargetView *iface, ID3D10Device **device)
 958 {
 959     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 960
 961     TRACE("iface %p, device %p.\n", iface, device);
 962
 963     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
 964 }
 965
 966 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_GetPrivateData(ID3D10RenderTargetView *iface,
 967         REFGUID guid, UINT *data_size, void *data)
 968 {
 969     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 970
 971     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 972             iface, debugstr_guid(guid), data_size, data);
 973
 974     return d3d_get_private_data(&view->private_store, guid, data_size, data);
 975 }
 976
 977 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateData(ID3D10RenderTargetView *iface,
 978         REFGUID guid, UINT data_size, const void *data)
 979 {
 980     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 981
 982     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 983             iface, debugstr_guid(guid), data_size, data);
 984
 985     return d3d_set_private_data(&view->private_store, guid, data_size, data);
 986 }
 987
 988 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateDataInterface(ID3D10RenderTargetView *iface,
 989         REFGUID guid, const IUnknown *data)
 990 {
 991     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 992
 993     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 994
 995     return d3d_set_private_data_interface(&view->private_store, guid, data);
 996 }
 997
 998 /* ID3D10View methods */
 999
1000 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTargetView *iface,
1001         ID3D10Resource **resource)
1002 {
1003     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1004
1005     TRACE("iface %p, resource %p\n", iface, resource);
1006
1007     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1008 }
1009
1010 /* ID3D10RenderTargetView methods */
1011
1012 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDesc(ID3D10RenderTargetView *iface,
1013         D3D10_RENDER_TARGET_VIEW_DESC *desc)
1014 {
1015     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1016
1017     TRACE("iface %p, desc %p\n", iface, desc);
1018
1019     memcpy(desc, &view->desc, sizeof(*desc));
1020 }
1021
1022 static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl =
1023 {
1024     /* IUnknown methods */
1025     d3d10_rendertarget_view_QueryInterface,
1026     d3d10_rendertarget_view_AddRef,
1027     d3d10_rendertarget_view_Release,
1028     /* ID3D10DeviceChild methods */
1029     d3d10_rendertarget_view_GetDevice,
1030     d3d10_rendertarget_view_GetPrivateData,
1031     d3d10_rendertarget_view_SetPrivateData,
1032     d3d10_rendertarget_view_SetPrivateDataInterface,
1033     /* ID3D10View methods */
1034     d3d10_rendertarget_view_GetResource,
1035     /* ID3D10RenderTargetView methods */
1036     d3d10_rendertarget_view_GetDesc,
1037 };
1038
1039 static void wined3d_rendertarget_view_desc_from_d3d11(struct wined3d_rendertarget_view_desc *wined3d_desc,
1040         const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1041 {
1042     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1043
1044     switch (desc->ViewDimension)
1045     {
1046         case D3D11_RTV_DIMENSION_BUFFER:
1047             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
1048             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
1049             break;
1050
1051         case D3D11_RTV_DIMENSION_TEXTURE1D:
1052             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1053             wined3d_desc->u.texture.layer_idx = 0;
1054             wined3d_desc->u.texture.layer_count = 1;
1055             break;
1056
1057         case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
1058             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1059             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1060             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1061             break;
1062
1063         case D3D11_RTV_DIMENSION_TEXTURE2D:
1064             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1065             wined3d_desc->u.texture.layer_idx = 0;
1066             wined3d_desc->u.texture.layer_count = 1;
1067             break;
1068
1069         case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
1070             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1071             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1072             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1073             break;
1074
1075         case D3D11_RTV_DIMENSION_TEXTURE2DMS:
1076             wined3d_desc->u.texture.level_idx = 0;
1077             wined3d_desc->u.texture.layer_idx = 0;
1078             wined3d_desc->u.texture.layer_count = 1;
1079             break;
1080
1081         case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
1082             wined3d_desc->u.texture.level_idx = 0;
1083             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1084             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1085             break;
1086
1087         case D3D11_RTV_DIMENSION_TEXTURE3D:
1088             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
1089             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
1090             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
1091             break;
1092
1093         default:
1094             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1095             wined3d_desc->u.texture.level_idx = 0;
1096             wined3d_desc->u.texture.layer_idx = 0;
1097             wined3d_desc->u.texture.layer_count = 1;
1098             break;
1099     }
1100 }
1101
1102 static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, struct d3d_device *device,
1103         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1104 {
1105     struct wined3d_rendertarget_view_desc wined3d_desc;
1106     struct wined3d_resource *wined3d_resource;
1107     HRESULT hr;
1108
1109     view->ID3D11RenderTargetView_iface.lpVtbl = &d3d11_rendertarget_view_vtbl;
1110     view->ID3D10RenderTargetView_iface.lpVtbl = &d3d10_rendertarget_view_vtbl;
1111     view->refcount = 1;
1112
1113     if (!desc)
1114     {
1115         HRESULT hr = set_rtdesc_from_resource(&view->desc, resource);
1116         if (FAILED(hr)) return hr;
1117     }
1118     else
1119     {
1120         view->desc = *desc;
1121     }
1122
1123     wined3d_mutex_lock();
1124     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1125     {
1126         wined3d_mutex_unlock();
1127         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1128         return E_FAIL;
1129     }
1130
1131     wined3d_rendertarget_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1132     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1133             view, &d3d10_null_wined3d_parent_ops, &view->wined3d_view)))
1134     {
1135         wined3d_mutex_unlock();
1136         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1137         return hr;
1138     }
1139
1140     wined3d_private_store_init(&view->private_store);
1141     wined3d_mutex_unlock();
1142     view->resource = resource;
1143     ID3D11Resource_AddRef(resource);
1144     view->device = &device->ID3D11Device_iface;
1145     ID3D11Device_AddRef(view->device);
1146
1147     return S_OK;
1148 }
1149
1150 HRESULT d3d_rendertarget_view_create(struct d3d_device *device, ID3D11Resource *resource,
1151         const D3D11_RENDER_TARGET_VIEW_DESC *desc, struct d3d_rendertarget_view **view)
1152 {
1153     struct d3d_rendertarget_view *object;
1154     HRESULT hr;
1155
1156     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1157         return E_OUTOFMEMORY;
1158
1159     if (FAILED(hr = d3d_rendertarget_view_init(object, device, resource, desc)))
1160     {
1161         WARN("Failed to initialize rendertarget view, hr %#x.\n", hr);
1162         HeapFree(GetProcessHeap(), 0, object);
1163         return hr;
1164     }
1165
1166     TRACE("Created rendertarget view %p.\n", object);
1167     *view = object;
1168
1169     return S_OK;
1170 }
1171
1172 struct d3d_rendertarget_view *unsafe_impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1173 {
1174     if (!iface)
1175         return NULL;
1176     assert(iface->lpVtbl == &d3d10_rendertarget_view_vtbl);
1177
1178     return impl_from_ID3D10RenderTargetView(iface);
1179 }
1180
1181 /* ID3D11ShaderResourceView methods */
1182
1183 struct d3d_shader_resource_view *impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
1184 {
1185     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D11ShaderResourceView_iface);
1186 }
1187
1188 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_QueryInterface(ID3D11ShaderResourceView *iface,
1189         REFIID riid, void **object)
1190 {
1191     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1192
1193     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1194
1195     if (IsEqualGUID(riid, &IID_ID3D11ShaderResourceView)
1196             || IsEqualGUID(riid, &IID_ID3D11View)
1197             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1198             || IsEqualGUID(riid, &IID_IUnknown))
1199     {
1200         ID3D11ShaderResourceView_AddRef(iface);
1201         *object = iface;
1202         return S_OK;
1203     }
1204
1205     if (IsEqualGUID(riid, &IID_ID3D10ShaderResourceView)
1206             || IsEqualGUID(riid, &IID_ID3D10View)
1207             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1208     {
1209         ID3D10ShaderResourceView_AddRef(&view->ID3D10ShaderResourceView_iface);
1210         *object = &view->ID3D10ShaderResourceView_iface;
1211         return S_OK;
1212     }
1213
1214     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1215
1216     *object = NULL;
1217     return E_NOINTERFACE;
1218 }
1219
1220 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_AddRef(ID3D11ShaderResourceView *iface)
1221 {
1222     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1223     ULONG refcount = InterlockedIncrement(&view->refcount);
1224
1225     TRACE("%p increasing refcount to %u.\n", view, refcount);
1226
1227     return refcount;
1228 }
1229
1230 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_Release(ID3D11ShaderResourceView *iface)
1231 {
1232     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1233     ULONG refcount = InterlockedDecrement(&view->refcount);
1234
1235     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1236
1237     if (!refcount)
1238     {
1239         wined3d_mutex_lock();
1240         wined3d_shader_resource_view_decref(view->wined3d_view);
1241         ID3D11Resource_Release(view->resource);
1242         ID3D11Device_Release(view->device);
1243         wined3d_private_store_cleanup(&view->private_store);
1244         wined3d_mutex_unlock();
1245         HeapFree(GetProcessHeap(), 0, view);
1246     }
1247
1248     return refcount;
1249 }
1250
1251 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDevice(ID3D11ShaderResourceView *iface,
1252         ID3D11Device **device)
1253 {
1254     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1255
1256     TRACE("iface %p, device %p.\n", iface, device);
1257
1258     *device = view->device;
1259     ID3D11Device_AddRef(*device);
1260 }
1261
1262 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_GetPrivateData(ID3D11ShaderResourceView *iface,
1263         REFGUID guid, UINT *data_size, void *data)
1264 {
1265     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1266
1267     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1268
1269     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1270 }
1271
1272 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateData(ID3D11ShaderResourceView *iface,
1273         REFGUID guid, UINT data_size, const void *data)
1274 {
1275     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1276
1277     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1278
1279     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1280 }
1281
1282 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateDataInterface(ID3D11ShaderResourceView *iface,
1283         REFGUID guid, const IUnknown *data)
1284 {
1285     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1286
1287     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1288
1289     return d3d_set_private_data_interface(&view->private_store, guid, data);
1290 }
1291
1292 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetResource(ID3D11ShaderResourceView *iface,
1293         ID3D11Resource **resource)
1294 {
1295     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1296
1297     TRACE("iface %p, resource %p.\n", iface, resource);
1298
1299     *resource = view->resource;
1300     ID3D11Resource_AddRef(*resource);
1301 }
1302
1303 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDesc(ID3D11ShaderResourceView *iface,
1304         D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
1305 {
1306     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1307
1308     TRACE("iface %p, desc %p.\n", iface, desc);
1309
1310     *desc = view->desc;
1311 }
1312
1313 static const struct ID3D11ShaderResourceViewVtbl d3d11_shader_resource_view_vtbl =
1314 {
1315     /* IUnknown methods */
1316     d3d11_shader_resource_view_QueryInterface,
1317     d3d11_shader_resource_view_AddRef,
1318     d3d11_shader_resource_view_Release,
1319     /* ID3D11DeviceChild methods */
1320     d3d11_shader_resource_view_GetDevice,
1321     d3d11_shader_resource_view_GetPrivateData,
1322     d3d11_shader_resource_view_SetPrivateData,
1323     d3d11_shader_resource_view_SetPrivateDataInterface,
1324     /* ID3D11View methods */
1325     d3d11_shader_resource_view_GetResource,
1326     /* ID3D11ShaderResourceView methods */
1327     d3d11_shader_resource_view_GetDesc,
1328 };
1329
1330 /* ID3D10ShaderResourceView methods */
1331
1332 static inline struct d3d_shader_resource_view *impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
1333 {
1334     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView_iface);
1335 }
1336
1337 /* IUnknown methods */
1338
1339 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_QueryInterface(ID3D10ShaderResourceView *iface,
1340         REFIID riid, void **object)
1341 {
1342     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1343
1344     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1345
1346     return d3d11_shader_resource_view_QueryInterface(&view->ID3D11ShaderResourceView_iface, riid, object);
1347 }
1348
1349 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_AddRef(ID3D10ShaderResourceView *iface)
1350 {
1351     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1352
1353     TRACE("iface %p.\n", iface);
1354
1355     return d3d11_shader_resource_view_AddRef(&view->ID3D11ShaderResourceView_iface);
1356 }
1357
1358 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_Release(ID3D10ShaderResourceView *iface)
1359 {
1360     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1361
1362     TRACE("iface %p.\n", iface);
1363
1364     return d3d11_shader_resource_view_Release(&view->ID3D11ShaderResourceView_iface);
1365 }
1366
1367 /* ID3D10DeviceChild methods */
1368
1369 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDevice(ID3D10ShaderResourceView *iface,
1370         ID3D10Device **device)
1371 {
1372     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1373
1374     TRACE("iface %p, device %p.\n", iface, device);
1375
1376     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1377 }
1378
1379 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_GetPrivateData(ID3D10ShaderResourceView *iface,
1380         REFGUID guid, UINT *data_size, void *data)
1381 {
1382     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1383
1384     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1385             iface, debugstr_guid(guid), data_size, data);
1386
1387     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1388 }
1389
1390 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateData(ID3D10ShaderResourceView *iface,
1391         REFGUID guid, UINT data_size, const void *data)
1392 {
1393     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1394
1395     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1396             iface, debugstr_guid(guid), data_size, data);
1397
1398     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1399 }
1400
1401 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateDataInterface(ID3D10ShaderResourceView *iface,
1402         REFGUID guid, const IUnknown *data)
1403 {
1404     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1405
1406     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1407
1408     return d3d_set_private_data_interface(&view->private_store, guid, data);
1409 }
1410
1411 /* ID3D10View methods */
1412
1413 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetResource(ID3D10ShaderResourceView *iface,
1414         ID3D10Resource **resource)
1415 {
1416     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1417
1418     TRACE("iface %p, resource %p.\n", iface, resource);
1419
1420     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1421 }
1422
1423 /* ID3D10ShaderResourceView methods */
1424
1425 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc(ID3D10ShaderResourceView *iface,
1426         D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
1427 {
1428     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1429
1430     TRACE("iface %p, desc %p.\n", iface, desc);
1431
1432     memcpy(desc, &view->desc, sizeof(*desc));
1433 }
1434
1435 static const struct ID3D10ShaderResourceViewVtbl d3d10_shader_resource_view_vtbl =
1436 {
1437     /* IUnknown methods */
1438     d3d10_shader_resource_view_QueryInterface,
1439     d3d10_shader_resource_view_AddRef,
1440     d3d10_shader_resource_view_Release,
1441     /* ID3D10DeviceChild methods */
1442     d3d10_shader_resource_view_GetDevice,
1443     d3d10_shader_resource_view_GetPrivateData,
1444     d3d10_shader_resource_view_SetPrivateData,
1445     d3d10_shader_resource_view_SetPrivateDataInterface,
1446     /* ID3D10View methods */
1447     d3d10_shader_resource_view_GetResource,
1448     /* ID3D10ShaderResourceView methods */
1449     d3d10_shader_resource_view_GetDesc,
1450 };
1451
1452 static HRESULT d3d_shader_resource_view_init(struct d3d_shader_resource_view *view, struct d3d_device *device,
1453         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
1454 {
1455     struct wined3d_resource *wined3d_resource;
1456     HRESULT hr;
1457
1458     view->ID3D11ShaderResourceView_iface.lpVtbl = &d3d11_shader_resource_view_vtbl;
1459     view->ID3D10ShaderResourceView_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
1460     view->refcount = 1;
1461
1462     if (!desc)
1463     {
1464         if (FAILED(hr = set_srdesc_from_resource(&view->desc, resource)))
1465             return hr;
1466     }
1467     else
1468     {
1469         view->desc = *desc;
1470     }
1471
1472     wined3d_mutex_lock();
1473     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1474     {
1475         ERR("Failed to get wined3d resource for d3d10 resource %p.\n", resource);
1476         return E_FAIL;
1477     }
1478
1479     if (FAILED(hr = wined3d_shader_resource_view_create(wined3d_resource,
1480             view, &d3d10_null_wined3d_parent_ops, &view->wined3d_view)))
1481     {
1482         WARN("Failed to create wined3d shader resource view, hr %#x.\n", hr);
1483         return hr;
1484     }
1485
1486     wined3d_private_store_init(&view->private_store);
1487     wined3d_mutex_unlock();
1488     view->resource = resource;
1489     ID3D11Resource_AddRef(resource);
1490     view->device = &device->ID3D11Device_iface;
1491     ID3D11Device_AddRef(view->device);
1492
1493     return S_OK;
1494 }
1495
1496 HRESULT d3d_shader_resource_view_create(struct d3d_device *device, ID3D11Resource *resource,
1497         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, struct d3d_shader_resource_view **view)
1498 {
1499     struct d3d_shader_resource_view *object;
1500     HRESULT hr;
1501
1502     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1503         return E_OUTOFMEMORY;
1504
1505     if (FAILED(hr = d3d_shader_resource_view_init(object, device, resource, desc)))
1506     {
1507         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
1508         HeapFree(GetProcessHeap(), 0, object);
1509         return hr;
1510     }
1511
1512     TRACE("Created shader resource view %p.\n", object);
1513     *view = object;
1514
1515     return S_OK;
1516 }
1517
1518 struct d3d_shader_resource_view *unsafe_impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
1519 {
1520     if (!iface)
1521         return NULL;
1522     assert(iface->lpVtbl == &d3d10_shader_resource_view_vtbl);
1523     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView_iface);
1524 }