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         wined3d_private_store_cleanup(&This->private_store);
 411         HeapFree(GetProcessHeap(), 0, This);
 412     }
 413
 414     return refcount;
 415 }
 416
 417 /* ID3D10DeviceChild methods */
 418
 419 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDevice(ID3D10DepthStencilView *iface, ID3D10Device **device)
 420 {
 421     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 422
 423     TRACE("iface %p, device %p.\n", iface, device);
 424
 425     *device = (ID3D10Device *)view->device;
 426     ID3D10Device_AddRef(*device);
 427 }
 428
 429 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_GetPrivateData(ID3D10DepthStencilView *iface,
 430         REFGUID guid, UINT *data_size, void *data)
 431 {
 432     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 433
 434     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 435             iface, debugstr_guid(guid), data_size, data);
 436
 437     return d3d10_get_private_data(&view->private_store, guid, data_size, data);
 438 }
 439
 440 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateData(ID3D10DepthStencilView *iface,
 441         REFGUID guid, UINT data_size, const void *data)
 442 {
 443     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 444
 445     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 446             iface, debugstr_guid(guid), data_size, data);
 447
 448     return d3d10_set_private_data(&view->private_store, guid, data_size, data);
 449 }
 450
 451 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateDataInterface(ID3D10DepthStencilView *iface,
 452         REFGUID guid, const IUnknown *data)
 453 {
 454     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 455
 456     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 457
 458     return d3d10_set_private_data_interface(&view->private_store, guid, data);
 459 }
 460
 461 /* ID3D10View methods */
 462
 463 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetResource(ID3D10DepthStencilView *iface,
 464         ID3D10Resource **resource)
 465 {
 466     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 467
 468     TRACE("iface %p, resource %p.\n", iface, resource);
 469
 470     *resource = view->resource;
 471     ID3D10Resource_AddRef(*resource);
 472 }
 473
 474 /* ID3D10DepthStencilView methods */
 475
 476 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDesc(ID3D10DepthStencilView *iface,
 477         D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
 478 {
 479     struct d3d10_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
 480
 481     TRACE("iface %p, desc %p.\n", iface, desc);
 482
 483     *desc = view->desc;
 484 }
 485
 486 static const struct ID3D10DepthStencilViewVtbl d3d10_depthstencil_view_vtbl =
 487 {
 488     /* IUnknown methods */
 489     d3d10_depthstencil_view_QueryInterface,
 490     d3d10_depthstencil_view_AddRef,
 491     d3d10_depthstencil_view_Release,
 492     /* ID3D10DeviceChild methods */
 493     d3d10_depthstencil_view_GetDevice,
 494     d3d10_depthstencil_view_GetPrivateData,
 495     d3d10_depthstencil_view_SetPrivateData,
 496     d3d10_depthstencil_view_SetPrivateDataInterface,
 497     /* ID3D10View methods */
 498     d3d10_depthstencil_view_GetResource,
 499     /* ID3D10DepthStencilView methods */
 500     d3d10_depthstencil_view_GetDesc,
 501 };
 502
 503 static void wined3d_depth_stencil_view_desc_from_d3d10core(struct wined3d_rendertarget_view_desc *wined3d_desc,
 504         const D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
 505 {
 506     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
 507
 508     switch (desc->ViewDimension)
 509     {
 510         case D3D10_DSV_DIMENSION_TEXTURE1D:
 511             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
 512             wined3d_desc->u.texture.layer_idx = 0;
 513             wined3d_desc->u.texture.layer_count = 1;
 514             break;
 515
 516         case D3D10_DSV_DIMENSION_TEXTURE1DARRAY:
 517             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
 518             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
 519             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
 520             break;
 521
 522         case D3D10_DSV_DIMENSION_TEXTURE2D:
 523             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
 524             wined3d_desc->u.texture.layer_idx = 0;
 525             wined3d_desc->u.texture.layer_count = 1;
 526             break;
 527
 528         case D3D10_DSV_DIMENSION_TEXTURE2DARRAY:
 529             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
 530             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
 531             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
 532             break;
 533
 534         case D3D10_DSV_DIMENSION_TEXTURE2DMS:
 535             wined3d_desc->u.texture.level_idx = 0;
 536             wined3d_desc->u.texture.layer_idx = 0;
 537             wined3d_desc->u.texture.layer_count = 1;
 538             break;
 539
 540         case D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY:
 541             wined3d_desc->u.texture.level_idx = 0;
 542             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
 543             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
 544             break;
 545
 546         default:
 547             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
 548             wined3d_desc->u.texture.level_idx = 0;
 549             wined3d_desc->u.texture.layer_idx = 0;
 550             wined3d_desc->u.texture.layer_count = 1;
 551             break;
 552     }
 553 }
 554
 555 HRESULT d3d10_depthstencil_view_init(struct d3d10_depthstencil_view *view, struct d3d10_device *device,
 556         ID3D10Resource *resource, const D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
 557 {
 558     struct wined3d_rendertarget_view_desc wined3d_desc;
 559     struct wined3d_resource *wined3d_resource;
 560     HRESULT hr;
 561
 562     view->ID3D10DepthStencilView_iface.lpVtbl = &d3d10_depthstencil_view_vtbl;
 563     view->refcount = 1;
 564
 565     if (!desc)
 566     {
 567         if (FAILED(hr = set_dsdesc_from_resource(&view->desc, resource)))
 568             return hr;
 569     }
 570     else
 571     {
 572         view->desc = *desc;
 573     }
 574
 575     if (!(wined3d_resource = wined3d_resource_from_resource(resource)))
 576     {
 577         ERR("Failed to get wined3d resource for d3d10 resource %p.\n", resource);
 578         return E_FAIL;
 579     }
 580
 581     wined3d_depth_stencil_view_desc_from_d3d10core(&wined3d_desc, &view->desc);
 582     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
 583             view, &d3d10_null_wined3d_parent_ops, &view->wined3d_view)))
 584     {
 585         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
 586         return hr;
 587     }
 588
 589     wined3d_private_store_init(&view->private_store);
 590     view->resource = resource;
 591     ID3D10Resource_AddRef(resource);
 592     view->device = &device->ID3D10Device1_iface;
 593     ID3D10Device1_AddRef(view->device);
 594
 595     return S_OK;
 596 }
 597
 598 struct d3d10_depthstencil_view *unsafe_impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
 599 {
 600     if (!iface)
 601         return NULL;
 602     assert(iface->lpVtbl == &d3d10_depthstencil_view_vtbl);
 603
 604     return impl_from_ID3D10DepthStencilView(iface);
 605 }
 606
 607 static inline struct d3d10_rendertarget_view *impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
 608 {
 609     return CONTAINING_RECORD(iface, struct d3d10_rendertarget_view, ID3D10RenderTargetView_iface);
 610 }
 611
 612 /* IUnknown methods */
 613
 614 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_QueryInterface(ID3D10RenderTargetView *iface,
 615         REFIID riid, void **object)
 616 {
 617     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 618
 619     if (IsEqualGUID(riid, &IID_ID3D10RenderTargetView)
 620             || IsEqualGUID(riid, &IID_ID3D10View)
 621             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 622             || IsEqualGUID(riid, &IID_IUnknown))
 623     {
 624         IUnknown_AddRef(iface);
 625         *object = iface;
 626         return S_OK;
 627     }
 628
 629     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 630
 631     *object = NULL;
 632     return E_NOINTERFACE;
 633 }
 634
 635 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_AddRef(ID3D10RenderTargetView *iface)
 636 {
 637     struct d3d10_rendertarget_view *This = impl_from_ID3D10RenderTargetView(iface);
 638     ULONG refcount = InterlockedIncrement(&This->refcount);
 639
 640     TRACE("%p increasing refcount to %u\n", This, refcount);
 641
 642     return refcount;
 643 }
 644
 645 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_Release(ID3D10RenderTargetView *iface)
 646 {
 647     struct d3d10_rendertarget_view *This = impl_from_ID3D10RenderTargetView(iface);
 648     ULONG refcount = InterlockedDecrement(&This->refcount);
 649
 650     TRACE("%p decreasing refcount to %u\n", This, refcount);
 651
 652     if (!refcount)
 653     {
 654         wined3d_rendertarget_view_decref(This->wined3d_view);
 655         ID3D10Resource_Release(This->resource);
 656         ID3D10Device1_Release(This->device);
 657         wined3d_private_store_cleanup(&This->private_store);
 658         HeapFree(GetProcessHeap(), 0, This);
 659     }
 660
 661     return refcount;
 662 }
 663
 664 /* ID3D10DeviceChild methods */
 665
 666 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDevice(ID3D10RenderTargetView *iface, ID3D10Device **device)
 667 {
 668     struct d3d10_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 669
 670     TRACE("iface %p, device %p.\n", iface, device);
 671
 672     *device = (ID3D10Device *)view->device;
 673     ID3D10Device_AddRef(*device);
 674 }
 675
 676 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_GetPrivateData(ID3D10RenderTargetView *iface,
 677         REFGUID guid, UINT *data_size, void *data)
 678 {
 679     struct d3d10_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 680
 681     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 682             iface, debugstr_guid(guid), data_size, data);
 683
 684     return d3d10_get_private_data(&view->private_store, guid, data_size, data);
 685 }
 686
 687 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateData(ID3D10RenderTargetView *iface,
 688         REFGUID guid, UINT data_size, const void *data)
 689 {
 690     struct d3d10_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 691
 692     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 693             iface, debugstr_guid(guid), data_size, data);
 694
 695     return d3d10_set_private_data(&view->private_store, guid, data_size, data);
 696 }
 697
 698 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateDataInterface(ID3D10RenderTargetView *iface,
 699         REFGUID guid, const IUnknown *data)
 700 {
 701     struct d3d10_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 702
 703     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 704
 705     return d3d10_set_private_data_interface(&view->private_store, guid, data);
 706 }
 707
 708 /* ID3D10View methods */
 709
 710 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTargetView *iface,
 711         ID3D10Resource **resource)
 712 {
 713     struct d3d10_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
 714
 715     TRACE("iface %p, resource %p\n", iface, resource);
 716
 717     *resource = view->resource;
 718     ID3D10Resource_AddRef(*resource);
 719 }
 720
 721 /* ID3D10RenderTargetView methods */
 722
 723 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDesc(ID3D10RenderTargetView *iface,
 724         D3D10_RENDER_TARGET_VIEW_DESC *desc)
 725 {
 726     struct d3d10_rendertarget_view *This = impl_from_ID3D10RenderTargetView(iface);
 727
 728     TRACE("iface %p, desc %p\n", iface, desc);
 729
 730     *desc = This->desc;
 731 }
 732
 733 static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl =
 734 {
 735     /* IUnknown methods */
 736     d3d10_rendertarget_view_QueryInterface,
 737     d3d10_rendertarget_view_AddRef,
 738     d3d10_rendertarget_view_Release,
 739     /* ID3D10DeviceChild methods */
 740     d3d10_rendertarget_view_GetDevice,
 741     d3d10_rendertarget_view_GetPrivateData,
 742     d3d10_rendertarget_view_SetPrivateData,
 743     d3d10_rendertarget_view_SetPrivateDataInterface,
 744     /* ID3D10View methods */
 745     d3d10_rendertarget_view_GetResource,
 746     /* ID3D10RenderTargetView methods */
 747     d3d10_rendertarget_view_GetDesc,
 748 };
 749
 750 static void wined3d_rendertarget_view_desc_from_d3d10core(struct wined3d_rendertarget_view_desc *wined3d_desc,
 751         const D3D10_RENDER_TARGET_VIEW_DESC *desc)
 752 {
 753     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
 754
 755     switch (desc->ViewDimension)
 756     {
 757         case D3D10_RTV_DIMENSION_BUFFER:
 758             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.ElementOffset;
 759             wined3d_desc->u.buffer.count = desc->u.Buffer.ElementWidth;
 760             break;
 761
 762         case D3D10_RTV_DIMENSION_TEXTURE1D:
 763             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
 764             wined3d_desc->u.texture.layer_idx = 0;
 765             wined3d_desc->u.texture.layer_count = 1;
 766             break;
 767
 768         case D3D10_RTV_DIMENSION_TEXTURE1DARRAY:
 769             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
 770             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
 771             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
 772             break;
 773
 774         case D3D10_RTV_DIMENSION_TEXTURE2D:
 775             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
 776             wined3d_desc->u.texture.layer_idx = 0;
 777             wined3d_desc->u.texture.layer_count = 1;
 778             break;
 779
 780         case D3D10_RTV_DIMENSION_TEXTURE2DARRAY:
 781             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
 782             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
 783             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
 784             break;
 785
 786         case D3D10_RTV_DIMENSION_TEXTURE2DMS:
 787             wined3d_desc->u.texture.level_idx = 0;
 788             wined3d_desc->u.texture.layer_idx = 0;
 789             wined3d_desc->u.texture.layer_count = 1;
 790             break;
 791
 792         case D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY:
 793             wined3d_desc->u.texture.level_idx = 0;
 794             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
 795             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
 796             break;
 797
 798         case D3D10_RTV_DIMENSION_TEXTURE3D:
 799             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
 800             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
 801             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
 802             break;
 803
 804         default:
 805             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
 806             wined3d_desc->u.texture.level_idx = 0;
 807             wined3d_desc->u.texture.layer_idx = 0;
 808             wined3d_desc->u.texture.layer_count = 1;
 809             break;
 810     }
 811 }
 812
 813 HRESULT d3d10_rendertarget_view_init(struct d3d10_rendertarget_view *view, struct d3d10_device *device,
 814         ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc)
 815 {
 816     struct wined3d_rendertarget_view_desc wined3d_desc;
 817     struct wined3d_resource *wined3d_resource;
 818     HRESULT hr;
 819
 820     view->ID3D10RenderTargetView_iface.lpVtbl = &d3d10_rendertarget_view_vtbl;
 821     view->refcount = 1;
 822
 823     if (!desc)
 824     {
 825         HRESULT hr = set_rtdesc_from_resource(&view->desc, resource);
 826         if (FAILED(hr)) return hr;
 827     }
 828     else
 829     {
 830         view->desc = *desc;
 831     }
 832
 833     wined3d_resource = wined3d_resource_from_resource(resource);
 834     if (!wined3d_resource)
 835     {
 836         ERR("Failed to get wined3d resource for d3d10 resource %p.\n", resource);
 837         return E_FAIL;
 838     }
 839
 840     wined3d_rendertarget_view_desc_from_d3d10core(&wined3d_desc, &view->desc);
 841     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
 842             view, &d3d10_null_wined3d_parent_ops, &view->wined3d_view)))
 843     {
 844         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
 845         return hr;
 846     }
 847
 848     wined3d_private_store_init(&view->private_store);
 849     view->resource = resource;
 850     ID3D10Resource_AddRef(resource);
 851     view->device = &device->ID3D10Device1_iface;
 852     ID3D10Device1_AddRef(view->device);
 853
 854     return S_OK;
 855 }
 856
 857 struct d3d10_rendertarget_view *unsafe_impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
 858 {
 859     if (!iface)
 860         return NULL;
 861     assert(iface->lpVtbl == &d3d10_rendertarget_view_vtbl);
 862
 863     return impl_from_ID3D10RenderTargetView(iface);
 864 }
 865
 866 static inline struct d3d10_shader_resource_view *impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
 867 {
 868     return CONTAINING_RECORD(iface, struct d3d10_shader_resource_view, ID3D10ShaderResourceView_iface);
 869 }
 870
 871 /* IUnknown methods */
 872
 873 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_QueryInterface(ID3D10ShaderResourceView *iface,
 874         REFIID riid, void **object)
 875 {
 876     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 877
 878     if (IsEqualGUID(riid, &IID_ID3D10ShaderResourceView)
 879             || IsEqualGUID(riid, &IID_ID3D10View)
 880             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 881             || IsEqualGUID(riid, &IID_IUnknown))
 882     {
 883         IUnknown_AddRef(iface);
 884         *object = iface;
 885         return S_OK;
 886     }
 887
 888     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 889
 890     *object = NULL;
 891     return E_NOINTERFACE;
 892 }
 893
 894 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_AddRef(ID3D10ShaderResourceView *iface)
 895 {
 896     struct d3d10_shader_resource_view *This = impl_from_ID3D10ShaderResourceView(iface);
 897     ULONG refcount = InterlockedIncrement(&This->refcount);
 898
 899     TRACE("%p increasing refcount to %u.\n", This, refcount);
 900
 901     return refcount;
 902 }
 903
 904 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_Release(ID3D10ShaderResourceView *iface)
 905 {
 906     struct d3d10_shader_resource_view *This = impl_from_ID3D10ShaderResourceView(iface);
 907     ULONG refcount = InterlockedDecrement(&This->refcount);
 908
 909     TRACE("%p decreasing refcount to %u.\n", This, refcount);
 910
 911     if (!refcount)
 912     {
 913         wined3d_shader_resource_view_decref(This->wined3d_view);
 914         ID3D10Resource_Release(This->resource);
 915         ID3D10Device1_Release(This->device);
 916         wined3d_private_store_cleanup(&This->private_store);
 917         HeapFree(GetProcessHeap(), 0, This);
 918     }
 919
 920     return refcount;
 921 }
 922
 923 /* ID3D10DeviceChild methods */
 924
 925 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDevice(ID3D10ShaderResourceView *iface,
 926         ID3D10Device **device)
 927 {
 928     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 929
 930     TRACE("iface %p, device %p.\n", iface, device);
 931
 932     *device = (ID3D10Device *)view->device;
 933     ID3D10Device_AddRef(*device);
 934 }
 935
 936 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_GetPrivateData(ID3D10ShaderResourceView *iface,
 937         REFGUID guid, UINT *data_size, void *data)
 938 {
 939     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 940
 941     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 942             iface, debugstr_guid(guid), data_size, data);
 943
 944     return d3d10_get_private_data(&view->private_store, guid, data_size, data);
 945 }
 946
 947 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateData(ID3D10ShaderResourceView *iface,
 948         REFGUID guid, UINT data_size, const void *data)
 949 {
 950     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 951
 952     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 953             iface, debugstr_guid(guid), data_size, data);
 954
 955     return d3d10_set_private_data(&view->private_store, guid, data_size, data);
 956 }
 957
 958 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateDataInterface(ID3D10ShaderResourceView *iface,
 959         REFGUID guid, const IUnknown *data)
 960 {
 961     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 962
 963     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 964
 965     return d3d10_set_private_data_interface(&view->private_store, guid, data);
 966 }
 967
 968 /* ID3D10View methods */
 969
 970 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetResource(ID3D10ShaderResourceView *iface,
 971         ID3D10Resource **resource)
 972 {
 973     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 974
 975     TRACE("iface %p, resource %p.\n", iface, resource);
 976
 977     *resource = view->resource;
 978     ID3D10Resource_AddRef(*resource);
 979 }
 980
 981 /* ID3D10ShaderResourceView methods */
 982
 983 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc(ID3D10ShaderResourceView *iface,
 984         D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
 985 {
 986     struct d3d10_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
 987
 988     TRACE("iface %p, desc %p.\n", iface, desc);
 989
 990     *desc = view->desc;
 991 }
 992
 993 static const struct ID3D10ShaderResourceViewVtbl d3d10_shader_resource_view_vtbl =
 994 {
 995     /* IUnknown methods */
 996     d3d10_shader_resource_view_QueryInterface,
 997     d3d10_shader_resource_view_AddRef,
 998     d3d10_shader_resource_view_Release,
 999     /* ID3D10DeviceChild methods */
1000     d3d10_shader_resource_view_GetDevice,
1001     d3d10_shader_resource_view_GetPrivateData,
1002     d3d10_shader_resource_view_SetPrivateData,
1003     d3d10_shader_resource_view_SetPrivateDataInterface,
1004     /* ID3D10View methods */
1005     d3d10_shader_resource_view_GetResource,
1006     /* ID3D10ShaderResourceView methods */
1007     d3d10_shader_resource_view_GetDesc,
1008 };
1009
1010 HRESULT d3d10_shader_resource_view_init(struct d3d10_shader_resource_view *view, struct d3d10_device *device,
1011         ID3D10Resource *resource, const D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
1012 {
1013     struct wined3d_resource *wined3d_resource;
1014     HRESULT hr;
1015
1016     view->ID3D10ShaderResourceView_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
1017     view->refcount = 1;
1018
1019     if (!desc)
1020     {
1021         if (FAILED(hr = set_srdesc_from_resource(&view->desc, resource)))
1022             return hr;
1023     }
1024     else
1025     {
1026         view->desc = *desc;
1027     }
1028
1029     if (!(wined3d_resource = wined3d_resource_from_resource(resource)))
1030     {
1031         ERR("Failed to get wined3d resource for d3d10 resource %p.\n", resource);
1032         return E_FAIL;
1033     }
1034
1035     if (FAILED(hr = wined3d_shader_resource_view_create(wined3d_resource,
1036             view, &d3d10_null_wined3d_parent_ops, &view->wined3d_view)))
1037     {
1038         WARN("Failed to create wined3d shader resource view, hr %#x.\n", hr);
1039         return hr;
1040     }
1041
1042     wined3d_private_store_init(&view->private_store);
1043     view->resource = resource;
1044     ID3D10Resource_AddRef(resource);
1045     view->device = &device->ID3D10Device1_iface;
1046     ID3D10Device1_AddRef(view->device);
1047
1048     return S_OK;
1049 }
1050
1051 struct d3d10_shader_resource_view *unsafe_impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
1052 {
1053     if (!iface)
1054         return NULL;
1055     assert(iface->lpVtbl == &d3d10_shader_resource_view_vtbl);
1056     return CONTAINING_RECORD(iface, struct d3d10_shader_resource_view, ID3D10ShaderResourceView_iface);
1057 }