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