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