dlls/d3d11/view.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #define NONAMELESSUNION
  24 #include "d3d11_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  27
  28 static HRESULT set_dsv_desc_from_resource(D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11Resource *resource)
  29 {
  30     D3D11_RESOURCE_DIMENSION dimension;
  31
  32     ID3D11Resource_GetType(resource, &dimension);
  33
  34     desc->Flags = 0;
  35
  36     switch (dimension)
  37     {
  38         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
  39         {
  40             D3D11_TEXTURE1D_DESC texture_desc;
  41             ID3D11Texture1D *texture;
  42
  43             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture)))
  44             {
  45                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D.\n");
  46                 return E_INVALIDARG;
  47             }
  48
  49             ID3D11Texture1D_GetDesc(texture, &texture_desc);
  50             ID3D11Texture1D_Release(texture);
  51
  52             desc->Format = texture_desc.Format;
  53             if (texture_desc.ArraySize == 1)
  54             {
  55                 desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1D;
  56                 desc->u.Texture1D.MipSlice = 0;
  57             }
  58             else
  59             {
  60                 desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1DARRAY;
  61                 desc->u.Texture1DArray.MipSlice = 0;
  62                 desc->u.Texture1DArray.FirstArraySlice = 0;
  63                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
  64             }
  65
  66             return S_OK;
  67         }
  68
  69         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
  70         {
  71             D3D11_TEXTURE2D_DESC texture_desc;
  72             ID3D11Texture2D *texture;
  73
  74             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
  75             {
  76                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
  77                 return E_INVALIDARG;
  78             }
  79
  80             ID3D11Texture2D_GetDesc(texture, &texture_desc);
  81             ID3D11Texture2D_Release(texture);
  82
  83             desc->Format = texture_desc.Format;
  84             if (texture_desc.ArraySize == 1)
  85             {
  86                 if (texture_desc.SampleDesc.Count == 1)
  87                 {
  88                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
  89                     desc->u.Texture2D.MipSlice = 0;
  90                 }
  91                 else
  92                 {
  93                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
  94                 }
  95             }
  96             else
  97             {
  98                 if (texture_desc.SampleDesc.Count == 1)
  99                 {
 100                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
 101                     desc->u.Texture2DArray.MipSlice = 0;
 102                     desc->u.Texture2DArray.FirstArraySlice = 0;
 103                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 104                 }
 105                 else
 106                 {
 107                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY;
 108                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 109                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 110                 }
 111             }
 112
 113             return S_OK;
 114         }
 115
 116         default:
 117             ERR("Unhandled resource dimension %#x.\n", dimension);
 118         case D3D11_RESOURCE_DIMENSION_BUFFER:
 119         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 120             return E_INVALIDARG;
 121     }
 122 }
 123
 124 static HRESULT normalize_dsv_desc(D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11Resource *resource)
 125 {
 126     D3D11_RESOURCE_DIMENSION dimension;
 127     unsigned int layer_count;
 128     DXGI_FORMAT format;
 129
 130     ID3D11Resource_GetType(resource, &dimension);
 131     switch (dimension)
 132     {
 133         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 134         {
 135             if (desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE1D
 136                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE1DARRAY)
 137             {
 138                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 139                 return E_INVALIDARG;
 140             }
 141
 142             FIXME("Unhandled 1D texture resource.\n");
 143             return S_OK;
 144         }
 145
 146         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 147         {
 148             const struct d3d_texture2d *texture;
 149
 150             if (desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2D
 151                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2DARRAY
 152                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2DMS
 153                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY)
 154             {
 155                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 156                 return E_INVALIDARG;
 157             }
 158
 159             if (!(texture = unsafe_impl_from_ID3D11Texture2D((ID3D11Texture2D *)resource)))
 160             {
 161                 ERR("Cannot get implementation from ID3D11Texture2D.\n");
 162                 return E_FAIL;
 163             }
 164
 165             format = texture->desc.Format;
 166             layer_count = texture->desc.ArraySize;
 167             break;
 168         }
 169
 170         case D3D11_RESOURCE_DIMENSION_BUFFER:
 171         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 172             WARN("Invalid resource dimension %#x.\n", dimension);
 173             return E_INVALIDARG;
 174
 175         default:
 176             ERR("Unhandled resource dimension %#x.\n", dimension);
 177             return E_FAIL;
 178     }
 179
 180     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 181         desc->Format = format;
 182
 183     switch (desc->ViewDimension)
 184     {
 185         case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
 186             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < layer_count)
 187                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 188             break;
 189
 190         case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
 191             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 192                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 193             break;
 194
 195         case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
 196             if (desc->u.Texture2DMSArray.ArraySize == ~0u && desc->u.Texture2DMSArray.FirstArraySlice < layer_count)
 197                 desc->u.Texture2DMSArray.ArraySize = layer_count - desc->u.Texture2DMSArray.FirstArraySlice;
 198             break;
 199
 200         default:
 201             break;
 202     }
 203
 204     return S_OK;
 205 }
 206
 207 static HRESULT set_rtv_desc_from_resource(D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11Resource *resource)
 208 {
 209     D3D11_RESOURCE_DIMENSION dimension;
 210     HRESULT hr;
 211
 212     ID3D11Resource_GetType(resource, &dimension);
 213
 214     switch (dimension)
 215     {
 216         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 217         {
 218             ID3D11Texture1D *texture;
 219             D3D11_TEXTURE1D_DESC texture_desc;
 220
 221             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture);
 222             if (FAILED(hr))
 223             {
 224                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D?\n");
 225                 return E_INVALIDARG;
 226             }
 227
 228             ID3D11Texture1D_GetDesc(texture, &texture_desc);
 229             ID3D11Texture1D_Release(texture);
 230
 231             desc->Format = texture_desc.Format;
 232             if (texture_desc.ArraySize == 1)
 233             {
 234                 desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1D;
 235                 desc->u.Texture1D.MipSlice = 0;
 236             }
 237             else
 238             {
 239                 desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1DARRAY;
 240                 desc->u.Texture1DArray.MipSlice = 0;
 241                 desc->u.Texture1DArray.FirstArraySlice = 0;
 242                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
 243             }
 244
 245             return S_OK;
 246         }
 247
 248         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 249         {
 250             ID3D11Texture2D *texture;
 251             D3D11_TEXTURE2D_DESC texture_desc;
 252
 253             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture);
 254             if (FAILED(hr))
 255             {
 256                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D?\n");
 257                 return E_INVALIDARG;
 258             }
 259
 260             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 261             ID3D11Texture2D_Release(texture);
 262
 263             desc->Format = texture_desc.Format;
 264             if (texture_desc.ArraySize == 1)
 265             {
 266                 if (texture_desc.SampleDesc.Count == 1)
 267                 {
 268                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
 269                     desc->u.Texture2D.MipSlice = 0;
 270                 }
 271                 else
 272                 {
 273                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
 274                 }
 275             }
 276             else
 277             {
 278                 if (texture_desc.SampleDesc.Count == 1)
 279                 {
 280                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
 281                     desc->u.Texture2DArray.MipSlice = 0;
 282                     desc->u.Texture2DArray.FirstArraySlice = 0;
 283                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 284                 }
 285                 else
 286                 {
 287                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY;
 288                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 289                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 290                 }
 291             }
 292
 293             return S_OK;
 294         }
 295
 296         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 297         {
 298             ID3D11Texture3D *texture;
 299             D3D11_TEXTURE3D_DESC texture_desc;
 300
 301             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture);
 302             if (FAILED(hr))
 303             {
 304                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D?\n");
 305                 return E_INVALIDARG;
 306             }
 307
 308             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 309             ID3D11Texture3D_Release(texture);
 310
 311             desc->Format = texture_desc.Format;
 312             desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;
 313             desc->u.Texture3D.MipSlice = 0;
 314             desc->u.Texture3D.FirstWSlice = 0;
 315             desc->u.Texture3D.WSize = texture_desc.Depth;
 316
 317             return S_OK;
 318         }
 319
 320         default:
 321             FIXME("Unhandled resource dimension %#x.\n", dimension);
 322             return E_INVALIDARG;
 323     }
 324 }
 325
 326 static HRESULT normalize_rtv_desc(D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11Resource *resource)
 327 {
 328     D3D11_RESOURCE_DIMENSION dimension;
 329     unsigned int layer_count;
 330     DXGI_FORMAT format;
 331
 332     ID3D11Resource_GetType(resource, &dimension);
 333     switch (dimension)
 334     {
 335         case D3D11_RESOURCE_DIMENSION_BUFFER:
 336         {
 337             if (desc->ViewDimension != D3D11_RTV_DIMENSION_BUFFER)
 338             {
 339                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 340                 return E_INVALIDARG;
 341             }
 342             return S_OK;
 343         }
 344
 345         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 346         {
 347             if (desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE1D
 348                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE1DARRAY)
 349             {
 350                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 351                 return E_INVALIDARG;
 352             }
 353
 354             FIXME("Unhandled 1D texture resource.\n");
 355             return S_OK;
 356         }
 357
 358         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 359         {
 360             const struct d3d_texture2d *texture;
 361
 362             if (desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2D
 363                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2DARRAY
 364                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2DMS
 365                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY)
 366             {
 367                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 368                 return E_INVALIDARG;
 369             }
 370
 371             if (!(texture = unsafe_impl_from_ID3D11Texture2D((ID3D11Texture2D *)resource)))
 372             {
 373                 ERR("Cannot get implementation from ID3D11Texture2D.\n");
 374                 return E_FAIL;
 375             }
 376
 377             format = texture->desc.Format;
 378             layer_count = texture->desc.ArraySize;
 379             break;
 380         }
 381
 382         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 383         {
 384             const struct d3d_texture3d *texture;
 385
 386             if (desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE3D)
 387             {
 388                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 389                 return E_INVALIDARG;
 390             }
 391
 392             if (!(texture = unsafe_impl_from_ID3D11Texture3D((ID3D11Texture3D *)resource)))
 393             {
 394                 ERR("Cannot get implementation from ID3D11Texture3D.\n");
 395                 return E_FAIL;
 396             }
 397
 398             format = texture->desc.Format;
 399             layer_count = texture->desc.Depth;
 400             break;
 401         }
 402
 403         default:
 404             ERR("Unhandled resource dimension %#x.\n", dimension);
 405             return E_FAIL;
 406     }
 407
 408     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 409         desc->Format = format;
 410
 411     switch (desc->ViewDimension)
 412     {
 413         case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
 414             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < layer_count)
 415                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 416             break;
 417
 418         case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
 419             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 420                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 421             break;
 422
 423         case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
 424             if (desc->u.Texture2DMSArray.ArraySize == ~0u && desc->u.Texture2DMSArray.FirstArraySlice < layer_count)
 425                 desc->u.Texture2DMSArray.ArraySize = layer_count - desc->u.Texture2DMSArray.FirstArraySlice;
 426             break;
 427
 428         case D3D11_RTV_DIMENSION_TEXTURE3D:
 429             layer_count = max(1, layer_count >> desc->u.Texture3D.MipSlice);
 430             if (desc->u.Texture3D.WSize == ~0u && desc->u.Texture3D.FirstWSlice < layer_count)
 431                 desc->u.Texture3D.WSize = layer_count - desc->u.Texture3D.FirstWSlice;
 432             break;
 433
 434         default:
 435             break;
 436     }
 437
 438     return S_OK;
 439 }
 440
 441 static HRESULT set_srv_desc_from_resource(D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11Resource *resource)
 442 {
 443     D3D11_RESOURCE_DIMENSION dimension;
 444
 445     ID3D11Resource_GetType(resource, &dimension);
 446
 447     switch (dimension)
 448     {
 449         case D3D11_RESOURCE_DIMENSION_BUFFER:
 450         {
 451             D3D11_BUFFER_DESC buffer_desc;
 452             ID3D11Buffer *buffer;
 453
 454             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Buffer, (void **)&buffer)))
 455             {
 456                 ERR("Resource of type BUFFER doesn't implement ID3D11Buffer.\n");
 457                 return E_INVALIDARG;
 458             }
 459
 460             ID3D11Buffer_GetDesc(buffer, &buffer_desc);
 461             ID3D11Buffer_Release(buffer);
 462
 463             if (buffer_desc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
 464             {
 465                 desc->Format = DXGI_FORMAT_UNKNOWN;
 466                 desc->ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
 467                 desc->u.Buffer.u1.FirstElement = 0;
 468                 desc->u.Buffer.u2.NumElements = buffer_desc.ByteWidth / buffer_desc.StructureByteStride;
 469                 return S_OK;
 470             }
 471
 472             return E_INVALIDARG;
 473         }
 474
 475         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 476         {
 477             D3D11_TEXTURE1D_DESC texture_desc;
 478             ID3D11Texture1D *texture;
 479
 480             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture)))
 481             {
 482                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D.\n");
 483                 return E_INVALIDARG;
 484             }
 485
 486             ID3D11Texture1D_GetDesc(texture, &texture_desc);
 487             ID3D11Texture1D_Release(texture);
 488
 489             desc->Format = texture_desc.Format;
 490             if (texture_desc.ArraySize == 1)
 491             {
 492                 desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
 493                 desc->u.Texture1D.MostDetailedMip = 0;
 494                 desc->u.Texture1D.MipLevels = texture_desc.MipLevels;
 495             }
 496             else
 497             {
 498                 desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY;
 499                 desc->u.Texture1DArray.MostDetailedMip = 0;
 500                 desc->u.Texture1DArray.MipLevels = texture_desc.MipLevels;
 501                 desc->u.Texture1DArray.FirstArraySlice = 0;
 502                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
 503             }
 504
 505             return S_OK;
 506         }
 507
 508         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 509         {
 510             D3D11_TEXTURE2D_DESC texture_desc;
 511             ID3D11Texture2D *texture;
 512
 513             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
 514             {
 515                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
 516                 return E_INVALIDARG;
 517             }
 518
 519             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 520             ID3D11Texture2D_Release(texture);
 521
 522             desc->Format = texture_desc.Format;
 523             if (texture_desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE)
 524             {
 525                 if (texture_desc.ArraySize >= 12)
 526                 {
 527                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
 528                     desc->u.TextureCubeArray.MostDetailedMip = 0;
 529                     desc->u.TextureCubeArray.MipLevels = texture_desc.MipLevels;
 530                     desc->u.TextureCubeArray.First2DArrayFace = 0;
 531                     desc->u.TextureCubeArray.NumCubes = texture_desc.ArraySize / 6;
 532                 }
 533                 else
 534                 {
 535                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
 536                     desc->u.TextureCube.MostDetailedMip = 0;
 537                     desc->u.TextureCube.MipLevels = texture_desc.MipLevels;
 538                 }
 539             }
 540             else if (texture_desc.ArraySize == 1)
 541             {
 542                 if (texture_desc.SampleDesc.Count == 1)
 543                 {
 544                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
 545                     desc->u.Texture2D.MostDetailedMip = 0;
 546                     desc->u.Texture2D.MipLevels = texture_desc.MipLevels;
 547                 }
 548                 else
 549                 {
 550                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
 551                 }
 552             }
 553             else
 554             {
 555                 if (texture_desc.SampleDesc.Count == 1)
 556                 {
 557                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
 558                     desc->u.Texture2DArray.MostDetailedMip = 0;
 559                     desc->u.Texture2DArray.MipLevels = texture_desc.MipLevels;
 560                     desc->u.Texture2DArray.FirstArraySlice = 0;
 561                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 562                 }
 563                 else
 564                 {
 565                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY;
 566                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 567                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 568                 }
 569             }
 570
 571             return S_OK;
 572         }
 573
 574         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 575         {
 576             D3D11_TEXTURE3D_DESC texture_desc;
 577             ID3D11Texture3D *texture;
 578
 579             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture)))
 580             {
 581                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D.\n");
 582                 return E_INVALIDARG;
 583             }
 584
 585             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 586             ID3D11Texture3D_Release(texture);
 587
 588             desc->Format = texture_desc.Format;
 589             desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
 590             desc->u.Texture3D.MostDetailedMip = 0;
 591             desc->u.Texture3D.MipLevels = texture_desc.MipLevels;
 592
 593             return S_OK;
 594         }
 595
 596         default:
 597             ERR("Unhandled resource dimension %#x.\n", dimension);
 598             return E_INVALIDARG;
 599     }
 600 }
 601
 602 static HRESULT normalize_srv_desc(D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11Resource *resource)
 603 {
 604     unsigned int miplevel_count, layer_count;
 605     D3D11_RESOURCE_DIMENSION dimension;
 606     DXGI_FORMAT format;
 607
 608     ID3D11Resource_GetType(resource, &dimension);
 609     switch (dimension)
 610     {
 611         case D3D11_RESOURCE_DIMENSION_BUFFER:
 612         {
 613             if (desc->ViewDimension != D3D11_SRV_DIMENSION_BUFFER
 614                     && desc->ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
 615             {
 616                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 617                 return E_INVALIDARG;
 618             }
 619             return S_OK;
 620         }
 621
 622         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 623         {
 624             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE1D
 625                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE1DARRAY)
 626             {
 627                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 628                 return E_INVALIDARG;
 629             }
 630
 631             FIXME("Unhandled 1D texture resource.\n");
 632             return S_OK;
 633         }
 634
 635         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 636         {
 637             const struct d3d_texture2d *texture;
 638
 639             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2D
 640                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DARRAY
 641                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DMS
 642                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY
 643                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURECUBE
 644                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURECUBEARRAY)
 645             {
 646                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 647                 return E_INVALIDARG;
 648             }
 649
 650             if (!(texture = unsafe_impl_from_ID3D11Texture2D((ID3D11Texture2D *)resource)))
 651             {
 652                 ERR("Cannot get implementation from ID3D11Texture2D.\n");
 653                 return E_FAIL;
 654             }
 655
 656             format = texture->desc.Format;
 657             miplevel_count = texture->desc.MipLevels;
 658             layer_count = texture->desc.ArraySize;
 659             break;
 660         }
 661
 662         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 663         {
 664             const struct d3d_texture3d *texture;
 665
 666             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE3D)
 667             {
 668                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 669                 return E_INVALIDARG;
 670             }
 671
 672             if (!(texture = unsafe_impl_from_ID3D11Texture3D((ID3D11Texture3D *)resource)))
 673             {
 674                 ERR("Cannot get implementation from ID3D11Texture3D.\n");
 675                 return E_FAIL;
 676             }
 677
 678             format = texture->desc.Format;
 679             miplevel_count = texture->desc.MipLevels;
 680             layer_count = 1;
 681             break;
 682         }
 683
 684         default:
 685             ERR("Unhandled resource dimension %#x.\n", dimension);
 686             return E_FAIL;
 687     }
 688
 689     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 690         desc->Format = format;
 691
 692     switch (desc->ViewDimension)
 693     {
 694         case D3D11_SRV_DIMENSION_TEXTURE1D:
 695             if (desc->u.Texture1D.MipLevels == ~0u && desc->u.Texture1D.MostDetailedMip < miplevel_count)
 696                 desc->u.Texture1D.MipLevels = miplevel_count - desc->u.Texture1D.MostDetailedMip;
 697             break;
 698
 699         case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
 700             if (desc->u.Texture1DArray.MipLevels == ~0u && desc->u.Texture1DArray.MostDetailedMip < miplevel_count)
 701                 desc->u.Texture1DArray.MipLevels = miplevel_count - desc->u.Texture1DArray.MostDetailedMip;
 702             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < miplevel_count)
 703                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 704             break;
 705
 706         case D3D11_SRV_DIMENSION_TEXTURE2D:
 707             if (desc->u.Texture2D.MipLevels == ~0u && desc->u.Texture2D.MostDetailedMip < miplevel_count)
 708                 desc->u.Texture2D.MipLevels = miplevel_count - desc->u.Texture2D.MostDetailedMip;
 709             break;
 710
 711         case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
 712             if (desc->u.Texture2DArray.MipLevels == ~0u && desc->u.Texture2DArray.MostDetailedMip < miplevel_count)
 713                 desc->u.Texture2DArray.MipLevels = miplevel_count - desc->u.Texture2DArray.MostDetailedMip;
 714             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 715                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 716             break;
 717
 718         case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
 719             if (desc->u.Texture2DMSArray.ArraySize == ~0u && desc->u.Texture2DMSArray.FirstArraySlice < layer_count)
 720                 desc->u.Texture2DMSArray.ArraySize = layer_count - desc->u.Texture2DMSArray.FirstArraySlice;
 721             break;
 722
 723         case D3D11_SRV_DIMENSION_TEXTURE3D:
 724             if (desc->u.Texture3D.MipLevels == ~0u && desc->u.Texture3D.MostDetailedMip < miplevel_count)
 725                 desc->u.Texture3D.MipLevels = miplevel_count - desc->u.Texture3D.MostDetailedMip;
 726             break;
 727
 728         case D3D11_SRV_DIMENSION_TEXTURECUBE:
 729             if (desc->u.TextureCube.MipLevels == ~0u && desc->u.TextureCube.MostDetailedMip < miplevel_count)
 730                 desc->u.TextureCube.MipLevels = miplevel_count - desc->u.TextureCube.MostDetailedMip;
 731             break;
 732
 733         case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
 734             if (desc->u.TextureCubeArray.MipLevels == ~0u && desc->u.TextureCubeArray.MostDetailedMip < miplevel_count)
 735                 desc->u.TextureCubeArray.MipLevels = miplevel_count - desc->u.TextureCubeArray.MostDetailedMip;
 736             if (desc->u.TextureCubeArray.NumCubes == ~0u && desc->u.TextureCubeArray.First2DArrayFace < layer_count)
 737                 desc->u.TextureCubeArray.NumCubes = (layer_count - desc->u.TextureCubeArray.First2DArrayFace) / 6;
 738             break;
 739
 740         default:
 741             break;
 742     }
 743
 744     return S_OK;
 745 }
 746
 747 static HRESULT set_uav_desc_from_resource(D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11Resource *resource)
 748 {
 749     D3D11_RESOURCE_DIMENSION dimension;
 750
 751     ID3D11Resource_GetType(resource, &dimension);
 752
 753     switch (dimension)
 754     {
 755         case D3D11_RESOURCE_DIMENSION_BUFFER:
 756         {
 757             D3D11_BUFFER_DESC buffer_desc;
 758             ID3D11Buffer *buffer;
 759
 760             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Buffer, (void **)&buffer)))
 761             {
 762                 ERR("Resource of type BUFFER doesn't implement ID3D11Buffer.\n");
 763                 return E_INVALIDARG;
 764             }
 765
 766             ID3D11Buffer_GetDesc(buffer, &buffer_desc);
 767             ID3D11Buffer_Release(buffer);
 768
 769             if (buffer_desc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
 770             {
 771                 desc->Format = DXGI_FORMAT_UNKNOWN;
 772                 desc->ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
 773                 desc->u.Buffer.FirstElement = 0;
 774                 desc->u.Buffer.NumElements = buffer_desc.ByteWidth / buffer_desc.StructureByteStride;
 775                 desc->u.Buffer.Flags = 0;
 776                 return S_OK;
 777             }
 778
 779             return E_INVALIDARG;
 780         }
 781
 782         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 783         {
 784             D3D11_TEXTURE2D_DESC texture_desc;
 785             ID3D11Texture2D *texture;
 786
 787             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
 788             {
 789                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
 790                 return E_INVALIDARG;
 791             }
 792
 793             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 794             ID3D11Texture2D_Release(texture);
 795
 796             if (texture_desc.SampleDesc.Count != 1)
 797             {
 798                 WARN("Trying to create view for multisample texture.\n");
 799                 return E_INVALIDARG;
 800             }
 801
 802             desc->Format = texture_desc.Format;
 803             if (texture_desc.ArraySize == 1)
 804             {
 805                 desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
 806                 desc->u.Texture2D.MipSlice = 0;
 807             }
 808             else
 809             {
 810                 desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY;
 811                 desc->u.Texture2DArray.MipSlice = 0;
 812                 desc->u.Texture2DArray.FirstArraySlice = 0;
 813                 desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 814             }
 815
 816             return S_OK;
 817         }
 818
 819         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 820         {
 821             D3D11_TEXTURE3D_DESC texture_desc;
 822             ID3D11Texture3D *texture;
 823
 824             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture)))
 825             {
 826                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D.\n");
 827                 return E_INVALIDARG;
 828             }
 829
 830             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 831             ID3D11Texture3D_Release(texture);
 832
 833             desc->Format = texture_desc.Format;
 834             desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D;
 835             desc->u.Texture3D.MipSlice = 0;
 836             desc->u.Texture3D.FirstWSlice = 0;
 837             desc->u.Texture3D.WSize = texture_desc.Depth;
 838
 839             return S_OK;
 840         }
 841
 842         default:
 843             FIXME("Unhandled resource dimension %#x.\n", dimension);
 844             return E_INVALIDARG;
 845     }
 846 }
 847
 848 static HRESULT normalize_uav_desc(D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11Resource *resource)
 849 {
 850     D3D11_RESOURCE_DIMENSION dimension;
 851     unsigned int layer_count;
 852     DXGI_FORMAT format;
 853
 854     ID3D11Resource_GetType(resource, &dimension);
 855     switch (dimension)
 856     {
 857         case D3D11_RESOURCE_DIMENSION_BUFFER:
 858         {
 859             if (desc->ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
 860             {
 861                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 862                 return E_INVALIDARG;
 863             }
 864             return S_OK;
 865         }
 866
 867         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 868         {
 869             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE1D
 870                     && desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE1DARRAY)
 871             {
 872                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 873                 return E_INVALIDARG;
 874             }
 875
 876             FIXME("Unhandled 1D texture resource.\n");
 877             return S_OK;
 878         }
 879
 880         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 881         {
 882             const struct d3d_texture2d *texture;
 883
 884             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE2D
 885                     && desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE2DARRAY)
 886             {
 887                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 888                 return E_INVALIDARG;
 889             }
 890
 891             if (!(texture = unsafe_impl_from_ID3D11Texture2D((ID3D11Texture2D *)resource)))
 892             {
 893                 ERR("Cannot get implementation from ID3D11Texture2D.\n");
 894                 return E_FAIL;
 895             }
 896
 897             format = texture->desc.Format;
 898             layer_count = texture->desc.ArraySize;
 899             break;
 900         }
 901
 902         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 903         {
 904             const struct d3d_texture3d *texture;
 905
 906             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE3D)
 907             {
 908                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 909                 return E_INVALIDARG;
 910             }
 911
 912             if (!(texture = unsafe_impl_from_ID3D11Texture3D((ID3D11Texture3D *)resource)))
 913             {
 914                 ERR("Cannot get implementation from ID3D11Texture3D.\n");
 915                 return E_FAIL;
 916             }
 917
 918             format = texture->desc.Format;
 919             layer_count = texture->desc.Depth;
 920             break;
 921         }
 922
 923         default:
 924             ERR("Unhandled resource dimension %#x.\n", dimension);
 925             return E_FAIL;
 926     }
 927
 928     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 929         desc->Format = format;
 930
 931     switch (desc->ViewDimension)
 932     {
 933         case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
 934             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < layer_count)
 935                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 936             break;
 937
 938         case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
 939             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 940                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 941             break;
 942
 943         case D3D11_UAV_DIMENSION_TEXTURE3D:
 944             layer_count = max(1, layer_count >> desc->u.Texture3D.MipSlice);
 945             if (desc->u.Texture3D.WSize == ~0u && desc->u.Texture3D.FirstWSlice < layer_count)
 946                 desc->u.Texture3D.WSize = layer_count - desc->u.Texture3D.FirstWSlice;
 947             break;
 948
 949         default:
 950             break;
 951     }
 952
 953     return S_OK;
 954 }
 955
 956 /* ID3D11DepthStencilView methods */
 957
 958 static inline struct d3d_depthstencil_view *impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
 959 {
 960     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D11DepthStencilView_iface);
 961 }
 962
 963 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_QueryInterface(ID3D11DepthStencilView *iface,
 964         REFIID riid, void **object)
 965 {
 966     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 967
 968     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 969
 970     if (IsEqualGUID(riid, &IID_ID3D11DepthStencilView)
 971             || IsEqualGUID(riid, &IID_ID3D11View)
 972             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 973             || IsEqualGUID(riid, &IID_IUnknown))
 974     {
 975         ID3D11DepthStencilView_AddRef(iface);
 976         *object = iface;
 977         return S_OK;
 978     }
 979
 980     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilView)
 981             || IsEqualGUID(riid, &IID_ID3D10View)
 982             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 983     {
 984         ID3D10DepthStencilView_AddRef(&view->ID3D10DepthStencilView_iface);
 985         *object = &view->ID3D10DepthStencilView_iface;
 986         return S_OK;
 987     }
 988
 989     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 990
 991     *object = NULL;
 992     return E_NOINTERFACE;
 993 }
 994
 995 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_AddRef(ID3D11DepthStencilView *iface)
 996 {
 997     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 998     ULONG refcount = InterlockedIncrement(&view->refcount);
 999
1000     TRACE("%p increasing refcount to %u.\n", view, refcount);
1001
1002     if (refcount == 1)
1003     {
1004         ID3D11Device_AddRef(view->device);
1005         wined3d_mutex_lock();
1006         wined3d_rendertarget_view_incref(view->wined3d_view);
1007         wined3d_mutex_unlock();
1008     }
1009
1010     return refcount;
1011 }
1012
1013 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_Release(ID3D11DepthStencilView *iface)
1014 {
1015     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1016     ULONG refcount = InterlockedDecrement(&view->refcount);
1017
1018     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1019
1020     if (!refcount)
1021     {
1022         ID3D11Device *device = view->device;
1023
1024         wined3d_mutex_lock();
1025         wined3d_rendertarget_view_decref(view->wined3d_view);
1026         wined3d_mutex_unlock();
1027
1028         ID3D11Device_Release(device);
1029     }
1030
1031     return refcount;
1032 }
1033
1034 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDevice(ID3D11DepthStencilView *iface,
1035         ID3D11Device **device)
1036 {
1037     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1038
1039     TRACE("iface %p, device %p.\n", iface, device);
1040
1041     *device = view->device;
1042     ID3D11Device_AddRef(*device);
1043 }
1044
1045 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_GetPrivateData(ID3D11DepthStencilView *iface,
1046         REFGUID guid, UINT *data_size, void *data)
1047 {
1048     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1049
1050     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1051
1052     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1053 }
1054
1055 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateData(ID3D11DepthStencilView *iface,
1056         REFGUID guid, UINT data_size, const void *data)
1057 {
1058     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1059
1060     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1061
1062     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1063 }
1064
1065 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateDataInterface(ID3D11DepthStencilView *iface,
1066         REFGUID guid, const IUnknown *data)
1067 {
1068     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1069
1070     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1071
1072     return d3d_set_private_data_interface(&view->private_store, guid, data);
1073 }
1074
1075 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetResource(ID3D11DepthStencilView *iface,
1076         ID3D11Resource **resource)
1077 {
1078     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1079
1080     TRACE("iface %p, resource %p.\n", iface, resource);
1081
1082     *resource = view->resource;
1083     ID3D11Resource_AddRef(*resource);
1084 }
1085
1086 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDesc(ID3D11DepthStencilView *iface,
1087         D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1088 {
1089     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1090
1091     TRACE("iface %p, desc %p.\n", iface, desc);
1092
1093     *desc = view->desc;
1094 }
1095
1096 static const struct ID3D11DepthStencilViewVtbl d3d11_depthstencil_view_vtbl =
1097 {
1098     /* IUnknown methods */
1099     d3d11_depthstencil_view_QueryInterface,
1100     d3d11_depthstencil_view_AddRef,
1101     d3d11_depthstencil_view_Release,
1102     /* ID3D11DeviceChild methods */
1103     d3d11_depthstencil_view_GetDevice,
1104     d3d11_depthstencil_view_GetPrivateData,
1105     d3d11_depthstencil_view_SetPrivateData,
1106     d3d11_depthstencil_view_SetPrivateDataInterface,
1107     /* ID3D11View methods */
1108     d3d11_depthstencil_view_GetResource,
1109     /* ID3D11DepthStencilView methods */
1110     d3d11_depthstencil_view_GetDesc,
1111 };
1112
1113 /* ID3D10DepthStencilView methods */
1114
1115 static inline struct d3d_depthstencil_view *impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
1116 {
1117     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D10DepthStencilView_iface);
1118 }
1119
1120 /* IUnknown methods */
1121
1122 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_QueryInterface(ID3D10DepthStencilView *iface,
1123         REFIID riid, void **object)
1124 {
1125     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1126
1127     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1128
1129     return d3d11_depthstencil_view_QueryInterface(&view->ID3D11DepthStencilView_iface, riid, object);
1130 }
1131
1132 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_AddRef(ID3D10DepthStencilView *iface)
1133 {
1134     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1135
1136     TRACE("iface %p.\n", iface);
1137
1138     return d3d11_depthstencil_view_AddRef(&view->ID3D11DepthStencilView_iface);
1139 }
1140
1141 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_Release(ID3D10DepthStencilView *iface)
1142 {
1143     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1144
1145     TRACE("iface %p.\n", iface);
1146
1147     return d3d11_depthstencil_view_Release(&view->ID3D11DepthStencilView_iface);
1148 }
1149
1150 /* ID3D10DeviceChild methods */
1151
1152 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDevice(ID3D10DepthStencilView *iface, ID3D10Device **device)
1153 {
1154     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1155
1156     TRACE("iface %p, device %p.\n", iface, device);
1157
1158     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1159 }
1160
1161 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_GetPrivateData(ID3D10DepthStencilView *iface,
1162         REFGUID guid, UINT *data_size, void *data)
1163 {
1164     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1165
1166     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1167             iface, debugstr_guid(guid), data_size, data);
1168
1169     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1170 }
1171
1172 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateData(ID3D10DepthStencilView *iface,
1173         REFGUID guid, UINT data_size, const void *data)
1174 {
1175     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1176
1177     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1178             iface, debugstr_guid(guid), data_size, data);
1179
1180     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1181 }
1182
1183 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateDataInterface(ID3D10DepthStencilView *iface,
1184         REFGUID guid, const IUnknown *data)
1185 {
1186     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1187
1188     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1189
1190     return d3d_set_private_data_interface(&view->private_store, guid, data);
1191 }
1192
1193 /* ID3D10View methods */
1194
1195 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetResource(ID3D10DepthStencilView *iface,
1196         ID3D10Resource **resource)
1197 {
1198     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1199
1200     TRACE("iface %p, resource %p.\n", iface, resource);
1201
1202     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1203 }
1204
1205 /* ID3D10DepthStencilView methods */
1206
1207 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDesc(ID3D10DepthStencilView *iface,
1208         D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
1209 {
1210     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1211     const D3D11_DEPTH_STENCIL_VIEW_DESC *d3d11_desc = &view->desc;
1212
1213     TRACE("iface %p, desc %p.\n", iface, desc);
1214
1215     desc->Format = d3d11_desc->Format;
1216     desc->ViewDimension = (D3D10_DSV_DIMENSION)d3d11_desc->ViewDimension;
1217     memcpy(&desc->u, &d3d11_desc->u, sizeof(desc->u));
1218 }
1219
1220 static const struct ID3D10DepthStencilViewVtbl d3d10_depthstencil_view_vtbl =
1221 {
1222     /* IUnknown methods */
1223     d3d10_depthstencil_view_QueryInterface,
1224     d3d10_depthstencil_view_AddRef,
1225     d3d10_depthstencil_view_Release,
1226     /* ID3D10DeviceChild methods */
1227     d3d10_depthstencil_view_GetDevice,
1228     d3d10_depthstencil_view_GetPrivateData,
1229     d3d10_depthstencil_view_SetPrivateData,
1230     d3d10_depthstencil_view_SetPrivateDataInterface,
1231     /* ID3D10View methods */
1232     d3d10_depthstencil_view_GetResource,
1233     /* ID3D10DepthStencilView methods */
1234     d3d10_depthstencil_view_GetDesc,
1235 };
1236
1237 static void STDMETHODCALLTYPE d3d_depth_stencil_view_wined3d_object_destroyed(void *parent)
1238 {
1239     struct d3d_depthstencil_view *view = parent;
1240
1241     wined3d_private_store_cleanup(&view->private_store);
1242     HeapFree(GetProcessHeap(), 0, parent);
1243 }
1244
1245 static const struct wined3d_parent_ops d3d_depth_stencil_view_wined3d_parent_ops =
1246 {
1247     d3d_depth_stencil_view_wined3d_object_destroyed,
1248 };
1249
1250 static void wined3d_depth_stencil_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
1251         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1252 {
1253     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1254
1255     if (desc->Flags)
1256         FIXME("Unhandled depth stencil view flags %#x.\n", desc->Flags);
1257
1258     wined3d_desc->flags = 0;
1259     wined3d_desc->u.texture.level_count = 1;
1260     switch (desc->ViewDimension)
1261     {
1262         case D3D11_DSV_DIMENSION_TEXTURE1D:
1263             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1264             wined3d_desc->u.texture.layer_idx = 0;
1265             wined3d_desc->u.texture.layer_count = 1;
1266             break;
1267
1268         case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
1269             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1270             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1271             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1272             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1273             break;
1274
1275         case D3D11_DSV_DIMENSION_TEXTURE2D:
1276             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1277             wined3d_desc->u.texture.layer_idx = 0;
1278             wined3d_desc->u.texture.layer_count = 1;
1279             break;
1280
1281         case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
1282             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1283             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1284             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1285             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1286             break;
1287
1288         case D3D11_DSV_DIMENSION_TEXTURE2DMS:
1289             wined3d_desc->u.texture.level_idx = 0;
1290             wined3d_desc->u.texture.layer_idx = 0;
1291             wined3d_desc->u.texture.layer_count = 1;
1292             break;
1293
1294         case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
1295             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1296             wined3d_desc->u.texture.level_idx = 0;
1297             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1298             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1299             break;
1300
1301         default:
1302             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1303             wined3d_desc->u.texture.level_idx = 0;
1304             wined3d_desc->u.texture.layer_idx = 0;
1305             wined3d_desc->u.texture.layer_count = 1;
1306             break;
1307     }
1308 }
1309
1310 static HRESULT d3d_depthstencil_view_init(struct d3d_depthstencil_view *view, struct d3d_device *device,
1311         ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1312 {
1313     struct wined3d_resource *wined3d_resource;
1314     struct wined3d_view_desc wined3d_desc;
1315     HRESULT hr;
1316
1317     view->ID3D11DepthStencilView_iface.lpVtbl = &d3d11_depthstencil_view_vtbl;
1318     view->ID3D10DepthStencilView_iface.lpVtbl = &d3d10_depthstencil_view_vtbl;
1319     view->refcount = 1;
1320
1321     if (!desc)
1322     {
1323         hr = set_dsv_desc_from_resource(&view->desc, resource);
1324     }
1325     else
1326     {
1327         view->desc = *desc;
1328         hr = normalize_dsv_desc(&view->desc, resource);
1329     }
1330     if (FAILED(hr))
1331         return hr;
1332
1333     wined3d_mutex_lock();
1334     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1335     {
1336         wined3d_mutex_unlock();
1337         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1338         return E_FAIL;
1339     }
1340
1341     wined3d_depth_stencil_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1342     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1343             view, &d3d_depth_stencil_view_wined3d_parent_ops, &view->wined3d_view)))
1344     {
1345         wined3d_mutex_unlock();
1346         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1347         return hr;
1348     }
1349
1350     wined3d_private_store_init(&view->private_store);
1351     wined3d_mutex_unlock();
1352     view->resource = resource;
1353     view->device = &device->ID3D11Device_iface;
1354     ID3D11Device_AddRef(view->device);
1355
1356     return S_OK;
1357 }
1358
1359 HRESULT d3d_depthstencil_view_create(struct d3d_device *device, ID3D11Resource *resource,
1360         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, struct d3d_depthstencil_view **view)
1361 {
1362     struct d3d_depthstencil_view *object;
1363     HRESULT hr;
1364
1365     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1366         return E_OUTOFMEMORY;
1367
1368     if (FAILED(hr = d3d_depthstencil_view_init(object, device, resource, desc)))
1369     {
1370         WARN("Failed to initialize depthstencil view, hr %#x.\n", hr);
1371         HeapFree(GetProcessHeap(), 0, object);
1372         return hr;
1373     }
1374
1375     TRACE("Created depthstencil view %p.\n", object);
1376     *view = object;
1377
1378     return S_OK;
1379 }
1380
1381 struct d3d_depthstencil_view *unsafe_impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
1382 {
1383     if (!iface)
1384         return NULL;
1385     assert(iface->lpVtbl == &d3d11_depthstencil_view_vtbl);
1386
1387     return impl_from_ID3D11DepthStencilView(iface);
1388 }
1389
1390 struct d3d_depthstencil_view *unsafe_impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
1391 {
1392     if (!iface)
1393         return NULL;
1394     assert(iface->lpVtbl == &d3d10_depthstencil_view_vtbl);
1395
1396     return impl_from_ID3D10DepthStencilView(iface);
1397 }
1398
1399 /* ID3D11RenderTargetView methods */
1400
1401 static inline struct d3d_rendertarget_view *impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
1402 {
1403     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D11RenderTargetView_iface);
1404 }
1405
1406 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_QueryInterface(ID3D11RenderTargetView *iface,
1407         REFIID riid, void **object)
1408 {
1409     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1410
1411     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1412
1413     if (IsEqualGUID(riid, &IID_ID3D11RenderTargetView)
1414             || IsEqualGUID(riid, &IID_ID3D11View)
1415             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1416             || IsEqualGUID(riid, &IID_IUnknown))
1417     {
1418         ID3D11RenderTargetView_AddRef(iface);
1419         *object = iface;
1420         return S_OK;
1421     }
1422
1423     if (IsEqualGUID(riid, &IID_ID3D10RenderTargetView)
1424             || IsEqualGUID(riid, &IID_ID3D10View)
1425             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1426     {
1427         ID3D10RenderTargetView_AddRef(&view->ID3D10RenderTargetView_iface);
1428         *object = &view->ID3D10RenderTargetView_iface;
1429         return S_OK;
1430     }
1431
1432     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1433
1434     *object = NULL;
1435     return E_NOINTERFACE;
1436 }
1437
1438 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_AddRef(ID3D11RenderTargetView *iface)
1439 {
1440     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1441     ULONG refcount = InterlockedIncrement(&view->refcount);
1442
1443     TRACE("%p increasing refcount to %u.\n", view, refcount);
1444
1445     if (refcount == 1)
1446     {
1447         ID3D11Device_AddRef(view->device);
1448         wined3d_mutex_lock();
1449         wined3d_rendertarget_view_incref(view->wined3d_view);
1450         wined3d_mutex_unlock();
1451     }
1452
1453     return refcount;
1454 }
1455
1456 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_Release(ID3D11RenderTargetView *iface)
1457 {
1458     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1459     ULONG refcount = InterlockedDecrement(&view->refcount);
1460
1461     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1462
1463     if (!refcount)
1464     {
1465         ID3D11Device *device = view->device;
1466
1467         wined3d_mutex_lock();
1468         wined3d_rendertarget_view_decref(view->wined3d_view);
1469         wined3d_mutex_unlock();
1470
1471         ID3D11Device_Release(device);
1472     }
1473
1474     return refcount;
1475 }
1476
1477 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDevice(ID3D11RenderTargetView *iface,
1478         ID3D11Device **device)
1479 {
1480     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1481
1482     TRACE("iface %p, device %p.\n", iface, device);
1483
1484     *device = view->device;
1485     ID3D11Device_AddRef(*device);
1486 }
1487
1488 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_GetPrivateData(ID3D11RenderTargetView *iface,
1489         REFGUID guid, UINT *data_size, void *data)
1490 {
1491     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1492
1493     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1494
1495     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1496 }
1497
1498 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateData(ID3D11RenderTargetView *iface,
1499         REFGUID guid, UINT data_size, const void *data)
1500 {
1501     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1502
1503     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1504
1505     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1506 }
1507
1508 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateDataInterface(ID3D11RenderTargetView *iface,
1509         REFGUID guid, const IUnknown *data)
1510 {
1511     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1512
1513     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1514
1515     return d3d_set_private_data_interface(&view->private_store, guid, data);
1516 }
1517
1518 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetResource(ID3D11RenderTargetView *iface,
1519         ID3D11Resource **resource)
1520 {
1521     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1522
1523     TRACE("iface %p, resource %p.\n", iface, resource);
1524
1525     *resource = view->resource;
1526     ID3D11Resource_AddRef(*resource);
1527 }
1528
1529 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDesc(ID3D11RenderTargetView *iface,
1530         D3D11_RENDER_TARGET_VIEW_DESC *desc)
1531 {
1532     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1533
1534     TRACE("iface %p, desc %p.\n", iface, desc);
1535
1536     *desc = view->desc;
1537 }
1538
1539 static const struct ID3D11RenderTargetViewVtbl d3d11_rendertarget_view_vtbl =
1540 {
1541     /* IUnknown methods */
1542     d3d11_rendertarget_view_QueryInterface,
1543     d3d11_rendertarget_view_AddRef,
1544     d3d11_rendertarget_view_Release,
1545     /* ID3D11DeviceChild methods */
1546     d3d11_rendertarget_view_GetDevice,
1547     d3d11_rendertarget_view_GetPrivateData,
1548     d3d11_rendertarget_view_SetPrivateData,
1549     d3d11_rendertarget_view_SetPrivateDataInterface,
1550     /* ID3D11View methods */
1551     d3d11_rendertarget_view_GetResource,
1552     /* ID3D11RenderTargetView methods */
1553     d3d11_rendertarget_view_GetDesc,
1554 };
1555
1556 /* ID3D10RenderTargetView methods */
1557
1558 static inline struct d3d_rendertarget_view *impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1559 {
1560     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D10RenderTargetView_iface);
1561 }
1562
1563 /* IUnknown methods */
1564
1565 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_QueryInterface(ID3D10RenderTargetView *iface,
1566         REFIID riid, void **object)
1567 {
1568     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1569
1570     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1571
1572     return d3d11_rendertarget_view_QueryInterface(&view->ID3D11RenderTargetView_iface, riid, object);
1573 }
1574
1575 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_AddRef(ID3D10RenderTargetView *iface)
1576 {
1577     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1578
1579     TRACE("iface %p.\n", iface);
1580
1581     return d3d11_rendertarget_view_AddRef(&view->ID3D11RenderTargetView_iface);
1582 }
1583
1584 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_Release(ID3D10RenderTargetView *iface)
1585 {
1586     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1587
1588     TRACE("iface %p.\n", iface);
1589
1590     return d3d11_rendertarget_view_Release(&view->ID3D11RenderTargetView_iface);
1591 }
1592
1593 /* ID3D10DeviceChild methods */
1594
1595 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDevice(ID3D10RenderTargetView *iface, ID3D10Device **device)
1596 {
1597     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1598
1599     TRACE("iface %p, device %p.\n", iface, device);
1600
1601     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1602 }
1603
1604 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_GetPrivateData(ID3D10RenderTargetView *iface,
1605         REFGUID guid, UINT *data_size, void *data)
1606 {
1607     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1608
1609     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1610             iface, debugstr_guid(guid), data_size, data);
1611
1612     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1613 }
1614
1615 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateData(ID3D10RenderTargetView *iface,
1616         REFGUID guid, UINT data_size, const void *data)
1617 {
1618     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1619
1620     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1621             iface, debugstr_guid(guid), data_size, data);
1622
1623     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1624 }
1625
1626 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateDataInterface(ID3D10RenderTargetView *iface,
1627         REFGUID guid, const IUnknown *data)
1628 {
1629     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1630
1631     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1632
1633     return d3d_set_private_data_interface(&view->private_store, guid, data);
1634 }
1635
1636 /* ID3D10View methods */
1637
1638 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTargetView *iface,
1639         ID3D10Resource **resource)
1640 {
1641     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1642
1643     TRACE("iface %p, resource %p\n", iface, resource);
1644
1645     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1646 }
1647
1648 /* ID3D10RenderTargetView methods */
1649
1650 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDesc(ID3D10RenderTargetView *iface,
1651         D3D10_RENDER_TARGET_VIEW_DESC *desc)
1652 {
1653     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1654
1655     TRACE("iface %p, desc %p\n", iface, desc);
1656
1657     memcpy(desc, &view->desc, sizeof(*desc));
1658 }
1659
1660 static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl =
1661 {
1662     /* IUnknown methods */
1663     d3d10_rendertarget_view_QueryInterface,
1664     d3d10_rendertarget_view_AddRef,
1665     d3d10_rendertarget_view_Release,
1666     /* ID3D10DeviceChild methods */
1667     d3d10_rendertarget_view_GetDevice,
1668     d3d10_rendertarget_view_GetPrivateData,
1669     d3d10_rendertarget_view_SetPrivateData,
1670     d3d10_rendertarget_view_SetPrivateDataInterface,
1671     /* ID3D10View methods */
1672     d3d10_rendertarget_view_GetResource,
1673     /* ID3D10RenderTargetView methods */
1674     d3d10_rendertarget_view_GetDesc,
1675 };
1676
1677 static void STDMETHODCALLTYPE d3d_render_target_view_wined3d_object_destroyed(void *parent)
1678 {
1679     struct d3d_rendertarget_view *view = parent;
1680
1681     wined3d_private_store_cleanup(&view->private_store);
1682     HeapFree(GetProcessHeap(), 0, parent);
1683 }
1684
1685 static const struct wined3d_parent_ops d3d_render_target_view_wined3d_parent_ops =
1686 {
1687     d3d_render_target_view_wined3d_object_destroyed,
1688 };
1689
1690 static void wined3d_rendertarget_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
1691         const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1692 {
1693     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1694
1695     wined3d_desc->flags = 0;
1696     wined3d_desc->u.texture.level_count = 1;
1697     switch (desc->ViewDimension)
1698     {
1699         case D3D11_RTV_DIMENSION_BUFFER:
1700             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
1701             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
1702             break;
1703
1704         case D3D11_RTV_DIMENSION_TEXTURE1D:
1705             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1706             wined3d_desc->u.texture.layer_idx = 0;
1707             wined3d_desc->u.texture.layer_count = 1;
1708             break;
1709
1710         case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
1711             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1712             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1713             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1714             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1715             break;
1716
1717         case D3D11_RTV_DIMENSION_TEXTURE2D:
1718             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1719             wined3d_desc->u.texture.layer_idx = 0;
1720             wined3d_desc->u.texture.layer_count = 1;
1721             break;
1722
1723         case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
1724             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1725             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1726             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1727             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1728             break;
1729
1730         case D3D11_RTV_DIMENSION_TEXTURE2DMS:
1731             wined3d_desc->u.texture.level_idx = 0;
1732             wined3d_desc->u.texture.layer_idx = 0;
1733             wined3d_desc->u.texture.layer_count = 1;
1734             break;
1735
1736         case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
1737             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1738             wined3d_desc->u.texture.level_idx = 0;
1739             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1740             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1741             break;
1742
1743         case D3D11_RTV_DIMENSION_TEXTURE3D:
1744             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
1745             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
1746             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
1747             break;
1748
1749         default:
1750             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1751             wined3d_desc->u.texture.level_idx = 0;
1752             wined3d_desc->u.texture.layer_idx = 0;
1753             wined3d_desc->u.texture.layer_count = 1;
1754             break;
1755     }
1756 }
1757
1758 static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, struct d3d_device *device,
1759         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1760 {
1761     struct wined3d_resource *wined3d_resource;
1762     struct wined3d_view_desc wined3d_desc;
1763     HRESULT hr;
1764
1765     view->ID3D11RenderTargetView_iface.lpVtbl = &d3d11_rendertarget_view_vtbl;
1766     view->ID3D10RenderTargetView_iface.lpVtbl = &d3d10_rendertarget_view_vtbl;
1767     view->refcount = 1;
1768
1769     if (!desc)
1770     {
1771         hr = set_rtv_desc_from_resource(&view->desc, resource);
1772     }
1773     else
1774     {
1775         view->desc = *desc;
1776         hr = normalize_rtv_desc(&view->desc, resource);
1777     }
1778     if (FAILED(hr))
1779         return hr;
1780
1781     wined3d_mutex_lock();
1782     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1783     {
1784         wined3d_mutex_unlock();
1785         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1786         return E_FAIL;
1787     }
1788
1789     wined3d_rendertarget_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1790     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1791             view, &d3d_render_target_view_wined3d_parent_ops, &view->wined3d_view)))
1792     {
1793         wined3d_mutex_unlock();
1794         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1795         return hr;
1796     }
1797
1798     wined3d_private_store_init(&view->private_store);
1799     wined3d_mutex_unlock();
1800     view->resource = resource;
1801     view->device = &device->ID3D11Device_iface;
1802     ID3D11Device_AddRef(view->device);
1803
1804     return S_OK;
1805 }
1806
1807 HRESULT d3d_rendertarget_view_create(struct d3d_device *device, ID3D11Resource *resource,
1808         const D3D11_RENDER_TARGET_VIEW_DESC *desc, struct d3d_rendertarget_view **view)
1809 {
1810     struct d3d_rendertarget_view *object;
1811     HRESULT hr;
1812
1813     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1814         return E_OUTOFMEMORY;
1815
1816     if (FAILED(hr = d3d_rendertarget_view_init(object, device, resource, desc)))
1817     {
1818         WARN("Failed to initialize rendertarget view, hr %#x.\n", hr);
1819         HeapFree(GetProcessHeap(), 0, object);
1820         return hr;
1821     }
1822
1823     TRACE("Created rendertarget view %p.\n", object);
1824     *view = object;
1825
1826     return S_OK;
1827 }
1828
1829 struct d3d_rendertarget_view *unsafe_impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
1830 {
1831     if (!iface)
1832         return NULL;
1833     assert(iface->lpVtbl == &d3d11_rendertarget_view_vtbl);
1834
1835     return impl_from_ID3D11RenderTargetView(iface);
1836 }
1837
1838 struct d3d_rendertarget_view *unsafe_impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1839 {
1840     if (!iface)
1841         return NULL;
1842     assert(iface->lpVtbl == &d3d10_rendertarget_view_vtbl);
1843
1844     return impl_from_ID3D10RenderTargetView(iface);
1845 }
1846
1847 /* ID3D11ShaderResourceView methods */
1848
1849 static inline struct d3d_shader_resource_view *impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
1850 {
1851     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D11ShaderResourceView_iface);
1852 }
1853
1854 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_QueryInterface(ID3D11ShaderResourceView *iface,
1855         REFIID riid, void **object)
1856 {
1857     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1858
1859     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1860
1861     if (IsEqualGUID(riid, &IID_ID3D11ShaderResourceView)
1862             || IsEqualGUID(riid, &IID_ID3D11View)
1863             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1864             || IsEqualGUID(riid, &IID_IUnknown))
1865     {
1866         ID3D11ShaderResourceView_AddRef(iface);
1867         *object = iface;
1868         return S_OK;
1869     }
1870
1871     if (IsEqualGUID(riid, &IID_ID3D10ShaderResourceView1)
1872             || IsEqualGUID(riid, &IID_ID3D10ShaderResourceView)
1873             || IsEqualGUID(riid, &IID_ID3D10View)
1874             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1875     {
1876         ID3D10ShaderResourceView1_AddRef(&view->ID3D10ShaderResourceView1_iface);
1877         *object = &view->ID3D10ShaderResourceView1_iface;
1878         return S_OK;
1879     }
1880
1881     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1882
1883     *object = NULL;
1884     return E_NOINTERFACE;
1885 }
1886
1887 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_AddRef(ID3D11ShaderResourceView *iface)
1888 {
1889     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1890     ULONG refcount = InterlockedIncrement(&view->refcount);
1891
1892     TRACE("%p increasing refcount to %u.\n", view, refcount);
1893
1894     if (refcount == 1)
1895     {
1896         ID3D11Device_AddRef(view->device);
1897         wined3d_mutex_lock();
1898         wined3d_shader_resource_view_incref(view->wined3d_view);
1899         wined3d_mutex_unlock();
1900     }
1901
1902     return refcount;
1903 }
1904
1905 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_Release(ID3D11ShaderResourceView *iface)
1906 {
1907     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1908     ULONG refcount = InterlockedDecrement(&view->refcount);
1909
1910     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1911
1912     if (!refcount)
1913     {
1914         ID3D11Device *device = view->device;
1915
1916         wined3d_mutex_lock();
1917         wined3d_shader_resource_view_decref(view->wined3d_view);
1918         wined3d_mutex_unlock();
1919
1920         ID3D11Device_Release(device);
1921     }
1922
1923     return refcount;
1924 }
1925
1926 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDevice(ID3D11ShaderResourceView *iface,
1927         ID3D11Device **device)
1928 {
1929     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1930
1931     TRACE("iface %p, device %p.\n", iface, device);
1932
1933     *device = view->device;
1934     ID3D11Device_AddRef(*device);
1935 }
1936
1937 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_GetPrivateData(ID3D11ShaderResourceView *iface,
1938         REFGUID guid, UINT *data_size, void *data)
1939 {
1940     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1941
1942     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1943
1944     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1945 }
1946
1947 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateData(ID3D11ShaderResourceView *iface,
1948         REFGUID guid, UINT data_size, const void *data)
1949 {
1950     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1951
1952     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1953
1954     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1955 }
1956
1957 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateDataInterface(ID3D11ShaderResourceView *iface,
1958         REFGUID guid, const IUnknown *data)
1959 {
1960     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1961
1962     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1963
1964     return d3d_set_private_data_interface(&view->private_store, guid, data);
1965 }
1966
1967 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetResource(ID3D11ShaderResourceView *iface,
1968         ID3D11Resource **resource)
1969 {
1970     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1971
1972     TRACE("iface %p, resource %p.\n", iface, resource);
1973
1974     *resource = view->resource;
1975     ID3D11Resource_AddRef(*resource);
1976 }
1977
1978 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDesc(ID3D11ShaderResourceView *iface,
1979         D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
1980 {
1981     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1982
1983     TRACE("iface %p, desc %p.\n", iface, desc);
1984
1985     *desc = view->desc;
1986 }
1987
1988 static const struct ID3D11ShaderResourceViewVtbl d3d11_shader_resource_view_vtbl =
1989 {
1990     /* IUnknown methods */
1991     d3d11_shader_resource_view_QueryInterface,
1992     d3d11_shader_resource_view_AddRef,
1993     d3d11_shader_resource_view_Release,
1994     /* ID3D11DeviceChild methods */
1995     d3d11_shader_resource_view_GetDevice,
1996     d3d11_shader_resource_view_GetPrivateData,
1997     d3d11_shader_resource_view_SetPrivateData,
1998     d3d11_shader_resource_view_SetPrivateDataInterface,
1999     /* ID3D11View methods */
2000     d3d11_shader_resource_view_GetResource,
2001     /* ID3D11ShaderResourceView methods */
2002     d3d11_shader_resource_view_GetDesc,
2003 };
2004
2005 /* ID3D10ShaderResourceView methods */
2006
2007 static inline struct d3d_shader_resource_view *impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView1 *iface)
2008 {
2009     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
2010 }
2011
2012 /* IUnknown methods */
2013
2014 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_QueryInterface(ID3D10ShaderResourceView1 *iface,
2015         REFIID riid, void **object)
2016 {
2017     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2018
2019     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
2020
2021     return d3d11_shader_resource_view_QueryInterface(&view->ID3D11ShaderResourceView_iface, riid, object);
2022 }
2023
2024 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_AddRef(ID3D10ShaderResourceView1 *iface)
2025 {
2026     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2027
2028     TRACE("iface %p.\n", iface);
2029
2030     return d3d11_shader_resource_view_AddRef(&view->ID3D11ShaderResourceView_iface);
2031 }
2032
2033 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_Release(ID3D10ShaderResourceView1 *iface)
2034 {
2035     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2036
2037     TRACE("iface %p.\n", iface);
2038
2039     return d3d11_shader_resource_view_Release(&view->ID3D11ShaderResourceView_iface);
2040 }
2041
2042 /* ID3D10DeviceChild methods */
2043
2044 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDevice(ID3D10ShaderResourceView1 *iface,
2045         ID3D10Device **device)
2046 {
2047     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2048
2049     TRACE("iface %p, device %p.\n", iface, device);
2050
2051     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
2052 }
2053
2054 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_GetPrivateData(ID3D10ShaderResourceView1 *iface,
2055         REFGUID guid, UINT *data_size, void *data)
2056 {
2057     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2058
2059     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
2060             iface, debugstr_guid(guid), data_size, data);
2061
2062     return d3d_get_private_data(&view->private_store, guid, data_size, data);
2063 }
2064
2065 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateData(ID3D10ShaderResourceView1 *iface,
2066         REFGUID guid, UINT data_size, const void *data)
2067 {
2068     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2069
2070     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
2071             iface, debugstr_guid(guid), data_size, data);
2072
2073     return d3d_set_private_data(&view->private_store, guid, data_size, data);
2074 }
2075
2076 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateDataInterface(ID3D10ShaderResourceView1 *iface,
2077         REFGUID guid, const IUnknown *data)
2078 {
2079     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2080
2081     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2082
2083     return d3d_set_private_data_interface(&view->private_store, guid, data);
2084 }
2085
2086 /* ID3D10View methods */
2087
2088 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetResource(ID3D10ShaderResourceView1 *iface,
2089         ID3D10Resource **resource)
2090 {
2091     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2092
2093     TRACE("iface %p, resource %p.\n", iface, resource);
2094
2095     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
2096 }
2097
2098 /* ID3D10ShaderResourceView methods */
2099
2100 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc(ID3D10ShaderResourceView1 *iface,
2101         D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
2102 {
2103     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2104
2105     TRACE("iface %p, desc %p.\n", iface, desc);
2106
2107     memcpy(desc, &view->desc, sizeof(*desc));
2108 }
2109
2110 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc1(ID3D10ShaderResourceView1 *iface,
2111         D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc)
2112 {
2113     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2114
2115     TRACE("iface %p, desc %p.\n", iface, desc);
2116
2117     memcpy(desc, &view->desc, sizeof(*desc));
2118 }
2119
2120 static const struct ID3D10ShaderResourceView1Vtbl d3d10_shader_resource_view_vtbl =
2121 {
2122     /* IUnknown methods */
2123     d3d10_shader_resource_view_QueryInterface,
2124     d3d10_shader_resource_view_AddRef,
2125     d3d10_shader_resource_view_Release,
2126     /* ID3D10DeviceChild methods */
2127     d3d10_shader_resource_view_GetDevice,
2128     d3d10_shader_resource_view_GetPrivateData,
2129     d3d10_shader_resource_view_SetPrivateData,
2130     d3d10_shader_resource_view_SetPrivateDataInterface,
2131     /* ID3D10View methods */
2132     d3d10_shader_resource_view_GetResource,
2133     /* ID3D10ShaderResourceView methods */
2134     d3d10_shader_resource_view_GetDesc,
2135     /* ID3D10ShaderResourceView1 methods */
2136     d3d10_shader_resource_view_GetDesc1,
2137 };
2138
2139 static void STDMETHODCALLTYPE d3d_shader_resource_view_wined3d_object_destroyed(void *parent)
2140 {
2141     struct d3d_shader_resource_view *view = parent;
2142
2143     wined3d_private_store_cleanup(&view->private_store);
2144     HeapFree(GetProcessHeap(), 0, parent);
2145 }
2146
2147 static const struct wined3d_parent_ops d3d_shader_resource_view_wined3d_parent_ops =
2148 {
2149     d3d_shader_resource_view_wined3d_object_destroyed,
2150 };
2151
2152 static unsigned int wined3d_view_flags_from_d3d11_bufferex_flags(unsigned int d3d11_flags)
2153 {
2154     unsigned int wined3d_flags = d3d11_flags & WINED3D_VIEW_BUFFER_RAW;
2155
2156     if (d3d11_flags != wined3d_flags)
2157         FIXME("Unhandled flags %#x.\n", d3d11_flags & ~wined3d_flags);
2158
2159     return wined3d_flags;
2160 }
2161
2162 static HRESULT wined3d_shader_resource_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
2163         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2164 {
2165     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2166     wined3d_desc->flags = 0;
2167
2168     switch (desc->ViewDimension)
2169     {
2170         case D3D11_SRV_DIMENSION_BUFFER:
2171             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
2172             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
2173             break;
2174
2175         case D3D11_SRV_DIMENSION_TEXTURE1D:
2176             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MostDetailedMip;
2177             wined3d_desc->u.texture.level_count = desc->u.Texture1D.MipLevels;
2178             wined3d_desc->u.texture.layer_idx = 0;
2179             wined3d_desc->u.texture.layer_count = 1;
2180             break;
2181
2182         case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
2183             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2184             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MostDetailedMip;
2185             wined3d_desc->u.texture.level_count = desc->u.Texture1DArray.MipLevels;
2186             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2187             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2188             break;
2189
2190         case D3D11_SRV_DIMENSION_TEXTURE2D:
2191             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MostDetailedMip;
2192             wined3d_desc->u.texture.level_count = desc->u.Texture2D.MipLevels;
2193             wined3d_desc->u.texture.layer_idx = 0;
2194             wined3d_desc->u.texture.layer_count = 1;
2195             break;
2196
2197         case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
2198             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2199             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MostDetailedMip;
2200             wined3d_desc->u.texture.level_count = desc->u.Texture2DArray.MipLevels;
2201             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2202             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2203             break;
2204
2205         case D3D11_SRV_DIMENSION_TEXTURE2DMS:
2206             wined3d_desc->u.texture.level_idx = 0;
2207             wined3d_desc->u.texture.level_count = 1;
2208             wined3d_desc->u.texture.layer_idx = 0;
2209             wined3d_desc->u.texture.layer_count = 1;
2210             break;
2211
2212         case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
2213             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2214             wined3d_desc->u.texture.level_idx = 0;
2215             wined3d_desc->u.texture.level_count = 1;
2216             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
2217             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
2218             break;
2219
2220         case D3D11_SRV_DIMENSION_TEXTURE3D:
2221             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MostDetailedMip;
2222             wined3d_desc->u.texture.level_count = desc->u.Texture3D.MipLevels;
2223             wined3d_desc->u.texture.layer_idx = 0;
2224             wined3d_desc->u.texture.layer_count = 1;
2225             break;
2226
2227         case D3D11_SRV_DIMENSION_TEXTURECUBE:
2228             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE;
2229             wined3d_desc->u.texture.level_idx = desc->u.TextureCube.MostDetailedMip;
2230             wined3d_desc->u.texture.level_count = desc->u.TextureCube.MipLevels;
2231             wined3d_desc->u.texture.layer_idx = 0;
2232             wined3d_desc->u.texture.layer_count = 6;
2233             break;
2234
2235         case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
2236             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE | WINED3D_VIEW_TEXTURE_ARRAY;
2237             wined3d_desc->u.texture.level_idx = desc->u.TextureCubeArray.MostDetailedMip;
2238             wined3d_desc->u.texture.level_count = desc->u.TextureCubeArray.MipLevels;
2239             wined3d_desc->u.texture.layer_idx = desc->u.TextureCubeArray.First2DArrayFace;
2240             wined3d_desc->u.texture.layer_count = 6 * desc->u.TextureCubeArray.NumCubes;
2241             break;
2242
2243         case D3D11_SRV_DIMENSION_BUFFEREX:
2244             wined3d_desc->flags = wined3d_view_flags_from_d3d11_bufferex_flags(desc->u.BufferEx.Flags);
2245             wined3d_desc->u.buffer.start_idx = desc->u.BufferEx.FirstElement;
2246             wined3d_desc->u.buffer.count = desc->u.BufferEx.NumElements;
2247             break;
2248
2249         default:
2250             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2251             return E_FAIL;
2252     }
2253
2254     return S_OK;
2255 }
2256
2257 static HRESULT d3d_shader_resource_view_init(struct d3d_shader_resource_view *view, struct d3d_device *device,
2258         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2259 {
2260     struct wined3d_resource *wined3d_resource;
2261     struct wined3d_view_desc wined3d_desc;
2262     HRESULT hr;
2263
2264     view->ID3D11ShaderResourceView_iface.lpVtbl = &d3d11_shader_resource_view_vtbl;
2265     view->ID3D10ShaderResourceView1_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
2266     view->refcount = 1;
2267
2268     if (!desc)
2269     {
2270         hr = set_srv_desc_from_resource(&view->desc, resource);
2271     }
2272     else
2273     {
2274         view->desc = *desc;
2275         hr = normalize_srv_desc(&view->desc, resource);
2276     }
2277     if (FAILED(hr))
2278         return hr;
2279
2280     if (FAILED(hr = wined3d_shader_resource_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2281         return hr;
2282
2283     wined3d_mutex_lock();
2284     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2285     {
2286         wined3d_mutex_unlock();
2287         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2288         return E_FAIL;
2289     }
2290
2291     if (FAILED(hr = wined3d_shader_resource_view_create(&wined3d_desc, wined3d_resource,
2292             view, &d3d_shader_resource_view_wined3d_parent_ops, &view->wined3d_view)))
2293     {
2294         wined3d_mutex_unlock();
2295         WARN("Failed to create wined3d shader resource view, hr %#x.\n", hr);
2296         return hr;
2297     }
2298
2299     wined3d_private_store_init(&view->private_store);
2300     wined3d_mutex_unlock();
2301     view->resource = resource;
2302     view->device = &device->ID3D11Device_iface;
2303     ID3D11Device_AddRef(view->device);
2304
2305     return S_OK;
2306 }
2307
2308 HRESULT d3d_shader_resource_view_create(struct d3d_device *device, ID3D11Resource *resource,
2309         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, struct d3d_shader_resource_view **view)
2310 {
2311     struct d3d_shader_resource_view *object;
2312     HRESULT hr;
2313
2314     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2315         return E_OUTOFMEMORY;
2316
2317     if (FAILED(hr = d3d_shader_resource_view_init(object, device, resource, desc)))
2318     {
2319         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
2320         HeapFree(GetProcessHeap(), 0, object);
2321         return hr;
2322     }
2323
2324     TRACE("Created shader resource view %p.\n", object);
2325     *view = object;
2326
2327     return S_OK;
2328 }
2329
2330 struct d3d_shader_resource_view *unsafe_impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
2331 {
2332     if (!iface)
2333         return NULL;
2334     assert(iface->lpVtbl == &d3d11_shader_resource_view_vtbl);
2335     return impl_from_ID3D11ShaderResourceView(iface);
2336 }
2337
2338 struct d3d_shader_resource_view *unsafe_impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
2339 {
2340     if (!iface)
2341         return NULL;
2342     assert(iface->lpVtbl == (ID3D10ShaderResourceViewVtbl *)&d3d10_shader_resource_view_vtbl);
2343     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
2344 }
2345
2346 /* ID3D11UnorderedAccessView methods */
2347
2348 static inline struct d3d11_unordered_access_view *impl_from_ID3D11UnorderedAccessView(ID3D11UnorderedAccessView *iface)
2349 {
2350     return CONTAINING_RECORD(iface, struct d3d11_unordered_access_view, ID3D11UnorderedAccessView_iface);
2351 }
2352
2353 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_QueryInterface(ID3D11UnorderedAccessView *iface,
2354         REFIID riid, void **object)
2355 {
2356     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
2357
2358     if (IsEqualGUID(riid, &IID_ID3D11UnorderedAccessView)
2359             || IsEqualGUID(riid, &IID_ID3D11View)
2360             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
2361             || IsEqualGUID(riid, &IID_IUnknown))
2362     {
2363         ID3D11UnorderedAccessView_AddRef(*object = iface);
2364         return S_OK;
2365     }
2366
2367     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2368
2369     *object = NULL;
2370     return E_NOINTERFACE;
2371 }
2372
2373 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_AddRef(ID3D11UnorderedAccessView *iface)
2374 {
2375     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2376     ULONG refcount = InterlockedIncrement(&view->refcount);
2377
2378     TRACE("%p increasing refcount to %u.\n", view, refcount);
2379
2380     if (refcount == 1)
2381     {
2382         ID3D11Device_AddRef(view->device);
2383         wined3d_mutex_lock();
2384         wined3d_unordered_access_view_incref(view->wined3d_view);
2385         wined3d_mutex_unlock();
2386     }
2387
2388     return refcount;
2389 }
2390
2391 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_Release(ID3D11UnorderedAccessView *iface)
2392 {
2393     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2394     ULONG refcount = InterlockedDecrement(&view->refcount);
2395
2396     TRACE("%p decreasing refcount to %u.\n", view, refcount);
2397
2398     if (!refcount)
2399     {
2400         ID3D11Device *device = view->device;
2401
2402         wined3d_mutex_lock();
2403         wined3d_unordered_access_view_decref(view->wined3d_view);
2404         wined3d_mutex_unlock();
2405
2406         ID3D11Device_Release(device);
2407     }
2408
2409     return refcount;
2410 }
2411
2412 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDevice(ID3D11UnorderedAccessView *iface,
2413         ID3D11Device **device)
2414 {
2415     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2416
2417     TRACE("iface %p, device %p.\n", iface, device);
2418
2419     ID3D11Device_AddRef(*device = view->device);
2420 }
2421
2422 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_GetPrivateData(ID3D11UnorderedAccessView *iface,
2423         REFGUID guid, UINT *data_size, void *data)
2424 {
2425     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2426
2427     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2428
2429     return d3d_get_private_data(&view->private_store, guid, data_size, data);
2430 }
2431
2432 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateData(ID3D11UnorderedAccessView *iface,
2433         REFGUID guid, UINT data_size, const void *data)
2434 {
2435     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2436
2437     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2438
2439     return d3d_set_private_data(&view->private_store, guid, data_size, data);
2440 }
2441
2442 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateDataInterface(ID3D11UnorderedAccessView *iface,
2443         REFGUID guid, const IUnknown *data)
2444 {
2445     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2446
2447     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2448
2449     return d3d_set_private_data_interface(&view->private_store, guid, data);
2450 }
2451
2452 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetResource(ID3D11UnorderedAccessView *iface,
2453         ID3D11Resource **resource)
2454 {
2455     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2456
2457     TRACE("iface %p, resource %p.\n", iface, resource);
2458
2459     ID3D11Resource_AddRef(*resource = view->resource);
2460 }
2461
2462 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDesc(ID3D11UnorderedAccessView *iface,
2463         D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2464 {
2465     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2466
2467     TRACE("iface %p, desc %p.\n", iface, desc);
2468
2469     *desc = view->desc;
2470 }
2471
2472 static const struct ID3D11UnorderedAccessViewVtbl d3d11_unordered_access_view_vtbl =
2473 {
2474     /* IUnknown methods */
2475     d3d11_unordered_access_view_QueryInterface,
2476     d3d11_unordered_access_view_AddRef,
2477     d3d11_unordered_access_view_Release,
2478     /* ID3D11DeviceChild methods */
2479     d3d11_unordered_access_view_GetDevice,
2480     d3d11_unordered_access_view_GetPrivateData,
2481     d3d11_unordered_access_view_SetPrivateData,
2482     d3d11_unordered_access_view_SetPrivateDataInterface,
2483     /* ID3D11View methods */
2484     d3d11_unordered_access_view_GetResource,
2485     /* ID3D11UnorderedAccessView methods */
2486     d3d11_unordered_access_view_GetDesc,
2487 };
2488
2489 static void STDMETHODCALLTYPE d3d11_unordered_access_view_wined3d_object_destroyed(void *parent)
2490 {
2491     struct d3d11_unordered_access_view *view = parent;
2492
2493     wined3d_private_store_cleanup(&view->private_store);
2494     HeapFree(GetProcessHeap(), 0, parent);
2495 }
2496
2497 static const struct wined3d_parent_ops d3d11_unordered_access_view_wined3d_parent_ops =
2498 {
2499     d3d11_unordered_access_view_wined3d_object_destroyed,
2500 };
2501
2502 static unsigned int wined3d_view_flags_from_d3d11_buffer_uav_flags(unsigned int d3d11_flags)
2503 {
2504     unsigned int wined3d_flags = d3d11_flags & (WINED3D_VIEW_BUFFER_RAW
2505             | WINED3D_VIEW_BUFFER_APPEND | WINED3D_VIEW_BUFFER_COUNTER);
2506
2507     if (d3d11_flags != wined3d_flags)
2508         FIXME("Unhandled flags %#x.\n", d3d11_flags & ~wined3d_flags);
2509
2510     return wined3d_flags;
2511 }
2512
2513 static HRESULT wined3d_unordered_access_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
2514         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2515 {
2516     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2517
2518     wined3d_desc->flags = 0;
2519     wined3d_desc->u.texture.level_count = 1;
2520     switch (desc->ViewDimension)
2521     {
2522         case D3D11_UAV_DIMENSION_BUFFER:
2523             wined3d_desc->flags = wined3d_view_flags_from_d3d11_buffer_uav_flags(desc->u.Buffer.Flags);
2524             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.FirstElement;
2525             wined3d_desc->u.buffer.count = desc->u.Buffer.NumElements;
2526             break;
2527
2528         case D3D11_UAV_DIMENSION_TEXTURE1D:
2529             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
2530             wined3d_desc->u.texture.layer_idx = 0;
2531             wined3d_desc->u.texture.layer_count = 1;
2532             break;
2533
2534         case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
2535             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2536             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
2537             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2538             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2539             break;
2540
2541         case D3D11_UAV_DIMENSION_TEXTURE2D:
2542             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
2543             wined3d_desc->u.texture.layer_idx = 0;
2544             wined3d_desc->u.texture.layer_count = 1;
2545             break;
2546
2547         case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
2548             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2549             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
2550             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2551             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2552             break;
2553
2554         case D3D11_UAV_DIMENSION_TEXTURE3D:
2555             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
2556             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
2557             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
2558             break;
2559
2560         default:
2561             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2562             return E_FAIL;
2563     }
2564
2565     return S_OK;
2566 }
2567
2568 static HRESULT d3d11_unordered_access_view_init(struct d3d11_unordered_access_view *view,
2569         struct d3d_device *device, ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2570 {
2571     struct wined3d_resource *wined3d_resource;
2572     struct wined3d_view_desc wined3d_desc;
2573     HRESULT hr;
2574
2575     view->ID3D11UnorderedAccessView_iface.lpVtbl = &d3d11_unordered_access_view_vtbl;
2576     view->refcount = 1;
2577
2578     if (!desc)
2579     {
2580         hr = set_uav_desc_from_resource(&view->desc, resource);
2581     }
2582     else
2583     {
2584         view->desc = *desc;
2585         hr = normalize_uav_desc(&view->desc, resource);
2586     }
2587     if (FAILED(hr))
2588         return hr;
2589
2590     if (FAILED(hr = wined3d_unordered_access_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2591         return hr;
2592
2593     wined3d_mutex_lock();
2594     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2595     {
2596         wined3d_mutex_unlock();
2597         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2598         return E_FAIL;
2599     }
2600
2601     if (FAILED(hr = wined3d_unordered_access_view_create(&wined3d_desc, wined3d_resource,
2602             view, &d3d11_unordered_access_view_wined3d_parent_ops, &view->wined3d_view)))
2603     {
2604         wined3d_mutex_unlock();
2605         WARN("Failed to create wined3d unordered access view, hr %#x.\n", hr);
2606         return hr;
2607     }
2608
2609     wined3d_private_store_init(&view->private_store);
2610     wined3d_mutex_unlock();
2611     view->resource = resource;
2612     ID3D11Device_AddRef(view->device = &device->ID3D11Device_iface);
2613
2614     return S_OK;
2615 }
2616
2617 HRESULT d3d11_unordered_access_view_create(struct d3d_device *device, ID3D11Resource *resource,
2618         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, struct d3d11_unordered_access_view **view)
2619 {
2620     struct d3d11_unordered_access_view *object;
2621     HRESULT hr;
2622
2623     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2624         return E_OUTOFMEMORY;
2625
2626     if (FAILED(hr = d3d11_unordered_access_view_init(object, device, resource, desc)))
2627     {
2628         WARN("Failed to initialize unordered access view, hr %#x.\n", hr);
2629         HeapFree(GetProcessHeap(), 0, object);
2630         return hr;
2631     }
2632
2633     TRACE("Created unordered access view %p.\n", object);
2634     *view = object;
2635
2636     return S_OK;
2637 }
2638
2639 struct d3d11_unordered_access_view *unsafe_impl_from_ID3D11UnorderedAccessView(ID3D11UnorderedAccessView *iface)
2640 {
2641     if (!iface)
2642         return NULL;
2643     assert(iface->lpVtbl == &d3d11_unordered_access_view_vtbl);
2644
2645     return impl_from_ID3D11UnorderedAccessView(iface);
2646 }