dlls/d3d10core/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 "d3d10core_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3d10core);
  27
  28 static struct wined3d_resource *wined3d_resource_from_resource(ID3D10Resource *resource)
  29 {
  30     D3D10_RESOURCE_DIMENSION dimension;
  31
  32     ID3D10Resource_GetType(resource, &dimension);
  33
  34     switch(dimension)
  35     {
  36         case D3D10_RESOURCE_DIMENSION_BUFFER:
  37             return wined3d_buffer_get_resource(((struct d3d10_buffer *)resource)->wined3d_buffer);
  38
  39         case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
  40             return wined3d_texture_get_resource(((struct d3d10_texture2d *)resource)->wined3d_texture);
  41
  42         default:
  43             FIXME("Unhandled resource dimension %#x.\n", dimension);
  44             return NULL;
  45     }
  46 }
  47
  48 static HRESULT set_dsdesc_from_resource(D3D10_DEPTH_STENCIL_VIEW_DESC *desc, ID3D10Resource *resource)
  49 {
  50     D3D10_RESOURCE_DIMENSION dimension;
  51
  52     ID3D10Resource_GetType(resource, &dimension);
  53
  54     switch (dimension)
  55     {
  56         case D3D10_RESOURCE_DIMENSION_TEXTURE1D:
  57         {
  58             D3D10_TEXTURE1D_DESC texture_desc;
  59             ID3D10Texture1D *texture;
  60
  61             if (FAILED(ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture1D, (void **)&texture)))
  62             {
  63                 ERR("Resource of type TEXTURE1D doesn't implement ID3D10Texture1D.\n");
  64                 return E_INVALIDARG;
  65             }
  66
  67             ID3D10Texture1D_GetDesc(texture, &texture_desc);
  68             ID3D10Texture1D_Release(texture);
  69
  70             desc->Format = texture_desc.Format;
  71             if (texture_desc.ArraySize == 1)
  72             {
  73                 desc->ViewDimension = D3D10_DSV_DIMENSION_TEXTURE1D;
  74                 desc->u.Texture1D.MipSlice = 0;
  75             }
  76             else
  77             {
  78                 desc->ViewDimension = D3D10_DSV_DIMENSION_TEXTURE1DARRAY;
  79                 desc->u.Texture1DArray.MipSlice = 0;
  80                 desc->u.Texture1DArray.FirstArraySlice = 0;
  81                 desc->u.Texture1DArray.ArraySize = 1;
  82             }
  83
  84             return S_OK;
  85         }
  86
  87         case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
  88         {
  89             D3D10_TEXTURE2D_DESC texture_desc;
  90             ID3D10Texture2D *texture;
  91
  92             if (FAILED(ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture2D, (void **)&texture)))
  93             {
  94                 ERR("Resource of type TEXTURE2D doesn't implement ID3D10Texture2D.\n");
  95                 return E_INVALIDARG;
  96             }
  97
  98             ID3D10Texture2D_GetDesc(texture, &texture_desc);
  99             ID3D10Texture2D_Release(texture);
 100
 101             desc->Format = texture_desc.Format;
 102             if (texture_desc.ArraySize == 1)
 103             {
 104                 if (texture_desc.SampleDesc.Count == 1)
 105                 {
 106                     desc->ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
 107                     desc->u.Texture2D.MipSlice = 0;
 108                 }
 109                 else
 110                 {
 111                     desc->ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2DMS;
 112                 }
 113             }
 114             else
 115             {
 116                 if (texture_desc.SampleDesc.Count == 1)
 117                 {
 118                     desc->ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2DARRAY;
 119                     desc->u.Texture2DArray.MipSlice = 0;
 120                     desc->u.Texture2DArray.FirstArraySlice = 0;
 121                     desc->u.Texture2DArray.ArraySize = 1;
 122                 }
 123                 else
 124                 {
 125                     desc->ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY;
 126                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 127                     desc->u.Texture2DMSArray.ArraySize = 1;
 128                 }
 129             }
 130
 131             return S_OK;
 132         }
 133
 134         default:
 135             FIXME("Unhandled resource dimension %#x.\n", dimension);
 136         case D3D10_RESOURCE_DIMENSION_BUFFER:
 137         case D3D10_RESOURCE_DIMENSION_TEXTURE3D:
 138             return E_INVALIDARG;
 139     }
 140 }
 141
 142 static HRESULT set_rtdesc_from_resource(D3D10_RENDER_TARGET_VIEW_DESC *desc, ID3D10Resource *resource)
 143 {
 144     D3D10_RESOURCE_DIMENSION dimension;
 145     HRESULT hr;
 146
 147     ID3D10Resource_GetType(resource, &dimension);
 148
 149     switch(dimension)
 150     {
 151         case D3D10_RESOURCE_DIMENSION_TEXTURE1D:
 152         {
 153             ID3D10Texture1D *texture;
 154             D3D10_TEXTURE1D_DESC texture_desc;
 155
 156             hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture1D, (void **)&texture);
 157             if (FAILED(hr))
 158             {
 159                 ERR("Resource of type TEXTURE1D doesn't implement ID3D10Texture1D?\n");
 160                 return E_INVALIDARG;
 161             }
 162
 163             ID3D10Texture1D_GetDesc(texture, &texture_desc);
 164             ID3D10Texture1D_Release(texture);
 165
 166             desc->Format = texture_desc.Format;
 167             if (texture_desc.ArraySize == 1)
 168             {
 169                 desc->ViewDimension = D3D10_RTV_DIMENSION_TEXTURE1D;
 170                 desc->u.Texture1D.MipSlice = 0;
 171             }
 172             else
 173             {
 174                 desc->ViewDimension = D3D10_RTV_DIMENSION_TEXTURE1DARRAY;
 175                 desc->u.Texture1DArray.MipSlice = 0;
 176                 desc->u.Texture1DArray.FirstArraySlice = 0;
 177                 desc->u.Texture1DArray.ArraySize = 1;
 178             }
 179
 180             return S_OK;
 181         }
 182
 183         case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
 184         {
 185             ID3D10Texture2D *texture;
 186             D3D10_TEXTURE2D_DESC texture_desc;
 187
 188             hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture2D, (void **)&texture);
 189             if (FAILED(hr))
 190             {
 191                 ERR("Resource of type TEXTURE2D doesn't implement ID3D10Texture2D?\n");
 192                 return E_INVALIDARG;
 193             }
 194
 195             ID3D10Texture2D_GetDesc(texture, &texture_desc);
 196             ID3D10Texture2D_Release(texture);
 197
 198             desc->Format = texture_desc.Format;
 199             if (texture_desc.ArraySize == 1)
 200             {
 201                 if (texture_desc.SampleDesc.Count == 1)
 202                 {
 203                     desc->ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D;
 204                     desc->u.Texture2D.MipSlice = 0;
 205                 }
 206                 else
 207                 {
 208                     desc->ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2DMS;
 209                 }
 210             }
 211             else
 212             {
 213                 if (texture_desc.SampleDesc.Count == 1)
 214                 {
 215                     desc->ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2DARRAY;
 216                     desc->u.Texture2DArray.MipSlice = 0;
 217                     desc->u.Texture2DArray.FirstArraySlice = 0;
 218                     desc->u.Texture2DArray.ArraySize = 1;
 219                 }
 220                 else
 221                 {
 222                     desc->ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY;
 223                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 224                     desc->u.Texture2DMSArray.ArraySize = 1;
 225                 }
 226             }
 227
 228             return S_OK;
 229         }
 230
 231         case D3D10_RESOURCE_DIMENSION_TEXTURE3D:
 232         {
 233             ID3D10Texture3D *texture;
 234             D3D10_TEXTURE3D_DESC texture_desc;
 235
 236             hr = ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture3D, (void **)&texture);
 237             if (FAILED(hr))
 238             {
 239                 ERR("Resource of type TEXTURE3D doesn't implement ID3D10Texture3D?\n");
 240                 return E_INVALIDARG;
 241             }
 242
 243             ID3D10Texture3D_GetDesc(texture, &texture_desc);
 244             ID3D10Texture3D_Release(texture);
 245
 246             desc->Format = texture_desc.Format;
 247             desc->ViewDimension = D3D10_RTV_DIMENSION_TEXTURE3D;
 248             desc->u.Texture3D.MipSlice = 0;
 249             desc->u.Texture3D.FirstWSlice = 0;
 250             desc->u.Texture3D.WSize = 1;
 251
 252             return S_OK;
 253         }
 254
 255         default:
 256             FIXME("Unhandled resource dimension %#x.\n", dimension);
 257             return E_INVALIDARG;
 258     }
 259 }
 260
 261 static HRESULT set_srdesc_from_resource(D3D10_SHADER_RESOURCE_VIEW_DESC *desc, ID3D10Resource *resource)
 262 {
 263     D3D10_RESOURCE_DIMENSION dimension;
 264
 265     ID3D10Resource_GetType(resource, &dimension);
 266
 267     switch (dimension)
 268     {
 269         case D3D10_RESOURCE_DIMENSION_TEXTURE1D:
 270         {
 271             D3D10_TEXTURE1D_DESC texture_desc;
 272             ID3D10Texture1D *texture;
 273
 274             if (FAILED(ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture1D, (void **)&texture)))
 275             {
 276                 ERR("Resource of type TEXTURE1D doesn't implement ID3D10Texture1D.\n");
 277                 return E_INVALIDARG;
 278             }
 279
 280             ID3D10Texture1D_GetDesc(texture, &texture_desc);
 281             ID3D10Texture1D_Release(texture);
 282
 283             desc->Format = texture_desc.Format;
 284             if (texture_desc.ArraySize == 1)
 285             {
 286                 desc->ViewDimension = D3D10_SRV_DIMENSION_TEXTURE1D;
 287                 desc->u.Texture1D.MostDetailedMip = 0;
 288                 desc->u.Texture1D.MipLevels = texture_desc.MipLevels;
 289             }
 290             else
 291             {
 292                 desc->ViewDimension = D3D10_SRV_DIMENSION_TEXTURE1DARRAY;
 293                 desc->u.Texture1DArray.MostDetailedMip = 0;
 294                 desc->u.Texture1DArray.MipLevels = texture_desc.MipLevels;
 295                 desc->u.Texture1DArray.FirstArraySlice = 0;
 296                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
 297             }
 298
 299             return S_OK;
 300         }
 301
 302         case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
 303         {
 304             D3D10_TEXTURE2D_DESC texture_desc;
 305             ID3D10Texture2D *texture;
 306
 307             if (FAILED(ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture2D, (void **)&texture)))
 308             {
 309                 ERR("Resource of type TEXTURE2D doesn't implement ID3D10Texture2D.\n");
 310                 return E_INVALIDARG;
 311             }
 312
 313             ID3D10Texture2D_GetDesc(texture, &texture_desc);
 314             ID3D10Texture2D_Release(texture);
 315
 316             desc->Format = texture_desc.Format;
 317             if (texture_desc.ArraySize == 1)
 318             {
 319                 if (texture_desc.SampleDesc.Count == 1)
 320                 {
 321                     desc->ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
 322                     desc->u.Texture2D.MostDetailedMip = 0;
 323                     desc->u.Texture2D.MipLevels = texture_desc.MipLevels;
 324                 }
 325                 else
 326                 {
 327                     desc->ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DMS;
 328                 }
 329             }
 330             else
 331             {
 332                 if (texture_desc.SampleDesc.Count == 1)
 333                 {
 334                     desc->ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
 335                     desc->u.Texture2DArray.MostDetailedMip = 0;
 336                     desc->u.Texture2DArray.MipLevels = texture_desc.MipLevels;
 337                     desc->u.Texture2DArray.FirstArraySlice = 0;
 338                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 339                 }
 340                 else
 341                 {
 342                     desc->ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY;
 343                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 344                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 345                 }
 346             }
 347
 348             return S_OK;
 349         }
 350
 351         case D3D10_RESOURCE_DIMENSION_TEXTURE3D:
 352         {
 353             D3D10_TEXTURE3D_DESC texture_desc;
 354             ID3D10Texture3D *texture;
 355
 356             if (FAILED(ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture3D, (void **)&texture)))
 357             {
 358                 ERR("Resource of type TEXTURE3D doesn't implement ID3D10Texture3D.\n");
 359                 return E_INVALIDARG;
 360             }
 361
 362             ID3D10Texture3D_GetDesc(texture, &texture_desc);
 363             ID3D10Texture3D_Release(texture);
 364
 365             desc->Format = texture_desc.Format;
 366             desc->ViewDimension = D3D10_SRV_DIMENSION_TEXTURE3D;
 367             desc->u.Texture3D.MostDetailedMip = 0;
 368             desc->u.Texture3D.MipLevels = texture_desc.MipLevels;
 369
 370             return S_OK;
 371         }
 372
 373         default:
 374             FIXME("Unhandled resource dimension %#x.\n", dimension);
 375         case D3D10_RESOURCE_DIMENSION_BUFFER:
 376             return E_INVALIDARG;
 377     }
 378 }
 379
 380 static inline struct d3d10_depthstencil_view *impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
 381 {
 382     return CONTAINING_RECORD(iface, struct d3d10_depthstencil_view, ID3D10DepthStencilView_iface);
 383 }
 384
 385 /* IUnknown methods */
 386
 387 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_QueryInterface(ID3D10DepthStencilView *iface,
 388         REFIID riid, void **object)
 389 {
 390     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 391
 392     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilView)
 393             || IsEqualGUID(riid, &IID_ID3D10View)
 394             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 395             || IsEqualGUID(riid, &IID_IUnknown))
 396     {
 397         IUnknown_AddRef(iface);
 398         *object = iface;
 399         return S_OK;
 400     }
 401
 402     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 403
 404     *object = NULL;
 405     return E_NOINTERFACE;
 406 }
 407
 408 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_AddRef(ID3D10DepthStencilView *iface)
 409 {
 410     struct d3d10_depthstencil_view *This = impl_from_ID3D10DepthStencilView(iface);
 411     ULONG refcount = InterlockedIncrement(&This->refcount);
 412
 413     TRACE("%p increasing refcount to %u.\n", This, refcount);
 414
 415     return refcount;
 416 }
 417
 418 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_Release(ID3D10DepthStencilView *iface)
 419 {
 420     struct d3d10_depthstencil_view *This = impl_from_ID3D10DepthStencilView(iface);
 421     ULONG refcount = InterlockedDecrement(&This->refcount);
 422
 423     TRACE("%p decreasing refcount to %u.\n", This, refcount);
 424
 425     if (!refcount)
 426     {
 427         ID3D10Resource_Release(This->resource);
 428         ID3D10Device1_Release(This->device);
 429         HeapFree(GetProcessHeap(), 0, This);
 430     }
 431
 432     return refcount;
 433 }
 434
 435 /* ID3D10DeviceChild methods */
 436
 437 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDevice(ID3D10DepthStencilView *iface, ID3D10Device **device)
 438 {
 439     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 440
 441     TRACE("iface %p, device %p.\n", iface, device);
 442
 443     *device = (ID3D10Device *)view->device;
 444     ID3D10Device_AddRef(*device);
 445 }
 446
 447 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_GetPrivateData(ID3D10DepthStencilView *iface,
 448         REFGUID guid, UINT *data_size, void *data)
 449 {
 450     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 451             iface, debugstr_guid(guid), data_size, data);
 452
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateData(ID3D10DepthStencilView *iface,
 457         REFGUID guid, UINT data_size, const void *data)
 458 {
 459     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 460             iface, debugstr_guid(guid), data_size, data);
 461
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateDataInterface(ID3D10DepthStencilView *iface,
 466         REFGUID guid, const IUnknown *data)
 467 {
 468     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 469
 470     return E_NOTIMPL;
 471 }
 472
 473 /* ID3D10View methods */
 474
 475 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetResource(ID3D10DepthStencilView *iface,
 476         ID3D10Resource **resource)
 477 {
 478     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 479
 480     TRACE("iface %p, resource %p.\n", iface, resource);
 481
 482     *resource = view->resource;
 483     ID3D10Resource_AddRef(*resource);
 484 }
 485
 486 /* ID3D10DepthStencilView methods */
 487
 488 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDesc(ID3D10DepthStencilView *iface,
 489         D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
 490 {
 491     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 492
 493     TRACE("iface %p, desc %p.\n", iface, desc);
 494
 495     *desc = view->desc;
 496 }
 497
 498 static const struct ID3D10DepthStencilViewVtbl d3d10_depthstencil_view_vtbl =
 499 {
 500     /* IUnknown methods */
 501     d3d10_depthstencil_view_QueryInterface,
 502     d3d10_depthstencil_view_AddRef,
 503     d3d10_depthstencil_view_Release,
 504     /* ID3D10DeviceChild methods */
 505     d3d10_depthstencil_view_GetDevice,
 506     d3d10_depthstencil_view_GetPrivateData,
 507     d3d10_depthstencil_view_SetPrivateData,
 508     d3d10_depthstencil_view_SetPrivateDataInterface,
 509     /* ID3D10View methods */
 510     d3d10_depthstencil_view_GetResource,
 511     /* ID3D10DepthStencilView methods */
 512     d3d10_depthstencil_view_GetDesc,
 513 };
 514
 515 HRESULT d3d10_depthstencil_view_init(struct d3d10_depthstencil_view *view, struct d3d10_device *device,
 516         ID3D10Resource *resource, const D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
 517 {
 518     HRESULT hr;
 519
 520     view->ID3D10DepthStencilView_iface.lpVtbl = &d3d10_depthstencil_view_vtbl;
 521     view->refcount = 1;
 522
 523     if (!desc)
 524     {
 525         if (FAILED(hr = set_dsdesc_from_resource(&view->desc, resource)))
 526             return hr;
 527     }
 528     else
 529     {
 530         view->desc = *desc;
 531     }
 532
 533     view->resource = resource;
 534     ID3D10Resource_AddRef(resource);
 535     view->device = &device->ID3D10Device1_iface;
 536     ID3D10Device1_AddRef(view->device);
 537
 538     return S_OK;
 539 }
 540
 541 static inline struct d3d10_rendertarget_view *impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
 542 {
 543     return CONTAINING_RECORD(iface, struct d3d10_rendertarget_view, ID3D10RenderTargetView_iface);
 544 }
 545
 546 /* IUnknown methods */
 547
 548 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_QueryInterface(ID3D10RenderTargetView *iface,
 549         REFIID riid, void **object)
 550 {
 551     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 552
 553     if (IsEqualGUID(riid, &IID_ID3D10RenderTargetView)
 554             || IsEqualGUID(riid, &IID_ID3D10View)
 555             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 556             || IsEqualGUID(riid, &IID_IUnknown))
 557     {
 558         IUnknown_AddRef(iface);
 559         *object = iface;
 560         return S_OK;
 561     }
 562
 563     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 564
 565     *object = NULL;
 566     return E_NOINTERFACE;
 567 }
 568
 569 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_AddRef(ID3D10RenderTargetView *iface)
 570 {
 571     struct d3d10_rendertarget_view *This = impl_from_ID3D10RenderTargetView(iface);
 572     ULONG refcount = InterlockedIncrement(&This->refcount);
 573
 574     TRACE("%p increasing refcount to %u\n", This, refcount);
 575
 576     return refcount;
 577 }
 578
 579 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_Release(ID3D10RenderTargetView *iface)
 580 {
 581     struct d3d10_rendertarget_view *This = impl_from_ID3D10RenderTargetView(iface);
 582     ULONG refcount = InterlockedDecrement(&This->refcount);
 583
 584     TRACE("%p decreasing refcount to %u\n", This, refcount);
 585
 586     if (!refcount)
 587     {
 588         wined3d_rendertarget_view_decref(This->wined3d_view);
 589         ID3D10Resource_Release(This->resource);
 590         ID3D10Device1_Release(This->device);
 591         HeapFree(GetProcessHeap(), 0, This);
 592     }
 593
 594     return refcount;
 595 }
 596
 597 /* ID3D10DeviceChild methods */
 598
 599 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDevice(ID3D10RenderTargetView *iface, ID3D10Device **device)
 600 {
 601     struct d3d10_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 602
 603     TRACE("iface %p, device %p.\n", iface, device);
 604
 605     *device = (ID3D10Device *)view->device;
 606     ID3D10Device_AddRef(*device);
 607 }
 608
 609 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_GetPrivateData(ID3D10RenderTargetView *iface,
 610         REFGUID guid, UINT *data_size, void *data)
 611 {
 612     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 613             iface, debugstr_guid(guid), data_size, data);
 614
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateData(ID3D10RenderTargetView *iface,
 619         REFGUID guid, UINT data_size, const void *data)
 620 {
 621     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 622             iface, debugstr_guid(guid), data_size, data);
 623
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateDataInterface(ID3D10RenderTargetView *iface,
 628         REFGUID guid, const IUnknown *data)
 629 {
 630     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 631
 632     return E_NOTIMPL;
 633 }
 634
 635 /* ID3D10View methods */
 636
 637 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTargetView *iface,
 638         ID3D10Resource **resource)
 639 {
 640     struct d3d10_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 641
 642     TRACE("iface %p, resource %p\n", iface, resource);
 643
 644     *resource = view->resource;
 645     ID3D10Resource_AddRef(*resource);
 646 }
 647
 648 /* ID3D10RenderTargetView methods */
 649
 650 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDesc(ID3D10RenderTargetView *iface,
 651         D3D10_RENDER_TARGET_VIEW_DESC *desc)
 652 {
 653     struct d3d10_rendertarget_view *This = impl_from_ID3D10RenderTargetView(iface);
 654
 655     TRACE("iface %p, desc %p\n", iface, desc);
 656
 657     *desc = This->desc;
 658 }
 659
 660 static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl =
 661 {
 662     /* IUnknown methods */
 663     d3d10_rendertarget_view_QueryInterface,
 664     d3d10_rendertarget_view_AddRef,
 665     d3d10_rendertarget_view_Release,
 666     /* ID3D10DeviceChild methods */
 667     d3d10_rendertarget_view_GetDevice,
 668     d3d10_rendertarget_view_GetPrivateData,
 669     d3d10_rendertarget_view_SetPrivateData,
 670     d3d10_rendertarget_view_SetPrivateDataInterface,
 671     /* ID3D10View methods */
 672     d3d10_rendertarget_view_GetResource,
 673     /* ID3D10RenderTargetView methods */
 674     d3d10_rendertarget_view_GetDesc,
 675 };
 676
 677 HRESULT d3d10_rendertarget_view_init(struct d3d10_rendertarget_view *view, struct d3d10_device *device,
 678         ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc)
 679 {
 680     struct wined3d_resource *wined3d_resource;
 681     HRESULT hr;
 682
 683     view->ID3D10RenderTargetView_iface.lpVtbl = &d3d10_rendertarget_view_vtbl;
 684     view->refcount = 1;
 685
 686     if (!desc)
 687     {
 688         HRESULT hr = set_rtdesc_from_resource(&view->desc, resource);
 689         if (FAILED(hr)) return hr;
 690     }
 691     else
 692     {
 693         view->desc = *desc;
 694     }
 695
 696     wined3d_resource = wined3d_resource_from_resource(resource);
 697     if (!wined3d_resource)
 698     {
 699         ERR("Failed to get wined3d resource for d3d10 resource %p.\n", resource);
 700         return E_FAIL;
 701     }
 702
 703     hr = wined3d_rendertarget_view_create(wined3d_resource, view, &view->wined3d_view);
 704     if (FAILED(hr))
 705     {
 706         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
 707         return hr;
 708     }
 709
 710     view->resource = resource;
 711     ID3D10Resource_AddRef(resource);
 712     view->device = &device->ID3D10Device1_iface;
 713     ID3D10Device1_AddRef(view->device);
 714
 715     return S_OK;
 716 }
 717
 718 struct d3d10_rendertarget_view *unsafe_impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
 719 {
 720     if (!iface)
 721         return NULL;
 722     assert(iface->lpVtbl == &d3d10_rendertarget_view_vtbl);
 723
 724     return impl_from_ID3D10RenderTargetView(iface);
 725 }
 726
 727 static inline struct d3d10_shader_resource_view *impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
 728 {
 729     return CONTAINING_RECORD(iface, struct d3d10_shader_resource_view, ID3D10ShaderResourceView_iface);
 730 }
 731
 732 /* IUnknown methods */
 733
 734 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_QueryInterface(ID3D10ShaderResourceView *iface,
 735         REFIID riid, void **object)
 736 {
 737     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 738
 739     if (IsEqualGUID(riid, &IID_ID3D10ShaderResourceView)
 740             || IsEqualGUID(riid, &IID_ID3D10View)
 741             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 742             || IsEqualGUID(riid, &IID_IUnknown))
 743     {
 744         IUnknown_AddRef(iface);
 745         *object = iface;
 746         return S_OK;
 747     }
 748
 749     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 750
 751     *object = NULL;
 752     return E_NOINTERFACE;
 753 }
 754
 755 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_AddRef(ID3D10ShaderResourceView *iface)
 756 {
 757     struct d3d10_shader_resource_view *This = impl_from_ID3D10ShaderResourceView(iface);
 758     ULONG refcount = InterlockedIncrement(&This->refcount);
 759
 760     TRACE("%p increasing refcount to %u.\n", This, refcount);
 761
 762     return refcount;
 763 }
 764
 765 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_Release(ID3D10ShaderResourceView *iface)
 766 {
 767     struct d3d10_shader_resource_view *This = impl_from_ID3D10ShaderResourceView(iface);
 768     ULONG refcount = InterlockedDecrement(&This->refcount);
 769
 770     TRACE("%p decreasing refcount to %u.\n", This, refcount);
 771
 772     if (!refcount)
 773     {
 774         ID3D10Resource_Release(This->resource);
 775         ID3D10Device1_Release(This->device);
 776         HeapFree(GetProcessHeap(), 0, This);
 777     }
 778
 779     return refcount;
 780 }
 781
 782 /* ID3D10DeviceChild methods */
 783
 784 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDevice(ID3D10ShaderResourceView *iface,
 785         ID3D10Device **device)
 786 {
 787     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 788
 789     TRACE("iface %p, device %p.\n", iface, device);
 790
 791     *device = (ID3D10Device *)view->device;
 792     ID3D10Device_AddRef(*device);
 793 }
 794
 795 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_GetPrivateData(ID3D10ShaderResourceView *iface,
 796         REFGUID guid, UINT *data_size, void *data)
 797 {
 798     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 799             iface, debugstr_guid(guid), data_size, data);
 800
 801     return E_NOTIMPL;
 802 }
 803
 804 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateData(ID3D10ShaderResourceView *iface,
 805         REFGUID guid, UINT data_size, const void *data)
 806 {
 807     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 808             iface, debugstr_guid(guid), data_size, data);
 809
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateDataInterface(ID3D10ShaderResourceView *iface,
 814         REFGUID guid, const IUnknown *data)
 815 {
 816     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 817
 818     return E_NOTIMPL;
 819 }
 820
 821 /* ID3D10View methods */
 822
 823 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetResource(ID3D10ShaderResourceView *iface,
 824         ID3D10Resource **resource)
 825 {
 826     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 827
 828     TRACE("iface %p, resource %p.\n", iface, resource);
 829
 830     *resource = view->resource;
 831     ID3D10Resource_AddRef(*resource);
 832 }
 833
 834 /* ID3D10ShaderResourceView methods */
 835
 836 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc(ID3D10ShaderResourceView *iface,
 837         D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
 838 {
 839     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 840
 841     TRACE("iface %p, desc %p.\n", iface, desc);
 842
 843     *desc = view->desc;
 844 }
 845
 846 static const struct ID3D10ShaderResourceViewVtbl d3d10_shader_resource_view_vtbl =
 847 {
 848     /* IUnknown methods */
 849     d3d10_shader_resource_view_QueryInterface,
 850     d3d10_shader_resource_view_AddRef,
 851     d3d10_shader_resource_view_Release,
 852     /* ID3D10DeviceChild methods */
 853     d3d10_shader_resource_view_GetDevice,
 854     d3d10_shader_resource_view_GetPrivateData,
 855     d3d10_shader_resource_view_SetPrivateData,
 856     d3d10_shader_resource_view_SetPrivateDataInterface,
 857     /* ID3D10View methods */
 858     d3d10_shader_resource_view_GetResource,
 859     /* ID3D10ShaderResourceView methods */
 860     d3d10_shader_resource_view_GetDesc,
 861 };
 862
 863 HRESULT d3d10_shader_resource_view_init(struct d3d10_shader_resource_view *view, struct d3d10_device *device,
 864         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
 865 {
 866     HRESULT hr;
 867
 868     view->ID3D10ShaderResourceView_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
 869     view->refcount = 1;
 870
 871     if (!desc)
 872     {
 873         if (FAILED(hr = set_srdesc_from_resource(&view->desc, resource)))
 874             return hr;
 875     }
 876     else
 877     {
 878         view->desc = *desc;
 879     }
 880
 881     view->resource = resource;
 882     ID3D10Resource_AddRef(resource);
 883     view->device = &device->ID3D10Device1_iface;
 884     ID3D10Device1_AddRef(view->device);
 885
 886     return S_OK;
 887 }