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.ArraySize == 1)
 524             {
 525                 if (texture_desc.SampleDesc.Count == 1)
 526                 {
 527                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
 528                     desc->u.Texture2D.MostDetailedMip = 0;
 529                     desc->u.Texture2D.MipLevels = texture_desc.MipLevels;
 530                 }
 531                 else
 532                 {
 533                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
 534                 }
 535             }
 536             else
 537             {
 538                 if (texture_desc.SampleDesc.Count == 1)
 539                 {
 540                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
 541                     desc->u.Texture2DArray.MostDetailedMip = 0;
 542                     desc->u.Texture2DArray.MipLevels = texture_desc.MipLevels;
 543                     desc->u.Texture2DArray.FirstArraySlice = 0;
 544                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 545                 }
 546                 else
 547                 {
 548                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY;
 549                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 550                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 551                 }
 552             }
 553
 554             return S_OK;
 555         }
 556
 557         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 558         {
 559             D3D11_TEXTURE3D_DESC texture_desc;
 560             ID3D11Texture3D *texture;
 561
 562             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture)))
 563             {
 564                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D.\n");
 565                 return E_INVALIDARG;
 566             }
 567
 568             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 569             ID3D11Texture3D_Release(texture);
 570
 571             desc->Format = texture_desc.Format;
 572             desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
 573             desc->u.Texture3D.MostDetailedMip = 0;
 574             desc->u.Texture3D.MipLevels = texture_desc.MipLevels;
 575
 576             return S_OK;
 577         }
 578
 579         default:
 580             ERR("Unhandled resource dimension %#x.\n", dimension);
 581             return E_INVALIDARG;
 582     }
 583 }
 584
 585 static HRESULT normalize_srv_desc(D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11Resource *resource)
 586 {
 587     unsigned int miplevel_count, layer_count;
 588     D3D11_RESOURCE_DIMENSION dimension;
 589     DXGI_FORMAT format;
 590
 591     ID3D11Resource_GetType(resource, &dimension);
 592     switch (dimension)
 593     {
 594         case D3D11_RESOURCE_DIMENSION_BUFFER:
 595         {
 596             if (desc->ViewDimension != D3D11_SRV_DIMENSION_BUFFER
 597                     && desc->ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
 598             {
 599                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 600                 return E_INVALIDARG;
 601             }
 602             return S_OK;
 603         }
 604
 605         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 606         {
 607             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE1D
 608                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE1DARRAY)
 609             {
 610                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 611                 return E_INVALIDARG;
 612             }
 613
 614             FIXME("Unhandled 1D texture resource.\n");
 615             return S_OK;
 616         }
 617
 618         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 619         {
 620             const struct d3d_texture2d *texture;
 621
 622             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2D
 623                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DARRAY
 624                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DMS
 625                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY
 626                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURECUBE
 627                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURECUBEARRAY)
 628             {
 629                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 630                 return E_INVALIDARG;
 631             }
 632
 633             if (!(texture = unsafe_impl_from_ID3D11Texture2D((ID3D11Texture2D *)resource)))
 634             {
 635                 ERR("Cannot get implementation from ID3D11Texture2D.\n");
 636                 return E_FAIL;
 637             }
 638
 639             format = texture->desc.Format;
 640             miplevel_count = texture->desc.MipLevels;
 641             layer_count = texture->desc.ArraySize;
 642             break;
 643         }
 644
 645         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 646         {
 647             const struct d3d_texture3d *texture;
 648
 649             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE3D)
 650             {
 651                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 652                 return E_INVALIDARG;
 653             }
 654
 655             if (!(texture = unsafe_impl_from_ID3D11Texture3D((ID3D11Texture3D *)resource)))
 656             {
 657                 ERR("Cannot get implementation from ID3D11Texture3D.\n");
 658                 return E_FAIL;
 659             }
 660
 661             format = texture->desc.Format;
 662             miplevel_count = texture->desc.MipLevels;
 663             layer_count = 1;
 664             break;
 665         }
 666
 667         default:
 668             ERR("Unhandled resource dimension %#x.\n", dimension);
 669             return E_FAIL;
 670     }
 671
 672     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 673         desc->Format = format;
 674
 675     switch (desc->ViewDimension)
 676     {
 677         case D3D11_SRV_DIMENSION_TEXTURE1D:
 678             if (desc->u.Texture1D.MipLevels == ~0u && desc->u.Texture1D.MostDetailedMip < miplevel_count)
 679                 desc->u.Texture1D.MipLevels = miplevel_count - desc->u.Texture1D.MostDetailedMip;
 680             break;
 681
 682         case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
 683             if (desc->u.Texture1DArray.MipLevels == ~0u && desc->u.Texture1DArray.MostDetailedMip < miplevel_count)
 684                 desc->u.Texture1DArray.MipLevels = miplevel_count - desc->u.Texture1DArray.MostDetailedMip;
 685             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < miplevel_count)
 686                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 687             break;
 688
 689         case D3D11_SRV_DIMENSION_TEXTURE2D:
 690             if (desc->u.Texture2D.MipLevels == ~0u && desc->u.Texture2D.MostDetailedMip < miplevel_count)
 691                 desc->u.Texture2D.MipLevels = miplevel_count - desc->u.Texture2D.MostDetailedMip;
 692             break;
 693
 694         case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
 695             if (desc->u.Texture2DArray.MipLevels == ~0u && desc->u.Texture2DArray.MostDetailedMip < miplevel_count)
 696                 desc->u.Texture2DArray.MipLevels = miplevel_count - desc->u.Texture2DArray.MostDetailedMip;
 697             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 698                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 699             break;
 700
 701         case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
 702             if (desc->u.Texture2DMSArray.ArraySize == ~0u && desc->u.Texture2DMSArray.FirstArraySlice < layer_count)
 703                 desc->u.Texture2DMSArray.ArraySize = layer_count - desc->u.Texture2DMSArray.FirstArraySlice;
 704             break;
 705
 706         case D3D11_SRV_DIMENSION_TEXTURE3D:
 707             if (desc->u.Texture3D.MipLevels == ~0u && desc->u.Texture3D.MostDetailedMip < miplevel_count)
 708                 desc->u.Texture3D.MipLevels = miplevel_count - desc->u.Texture3D.MostDetailedMip;
 709             break;
 710
 711         case D3D11_SRV_DIMENSION_TEXTURECUBE:
 712             if (desc->u.TextureCube.MipLevels == ~0u && desc->u.TextureCube.MostDetailedMip < miplevel_count)
 713                 desc->u.TextureCube.MipLevels = miplevel_count - desc->u.TextureCube.MostDetailedMip;
 714             break;
 715
 716         case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
 717             if (desc->u.TextureCubeArray.MipLevels == ~0u && desc->u.TextureCubeArray.MostDetailedMip < miplevel_count)
 718                 desc->u.TextureCubeArray.MipLevels = miplevel_count - desc->u.TextureCubeArray.MostDetailedMip;
 719             if (desc->u.TextureCubeArray.NumCubes == ~0u && desc->u.TextureCubeArray.First2DArrayFace < layer_count)
 720                 desc->u.TextureCubeArray.NumCubes = (layer_count - desc->u.TextureCubeArray.First2DArrayFace) / 6;
 721             break;
 722
 723         default:
 724             break;
 725     }
 726
 727     return S_OK;
 728 }
 729
 730 static HRESULT set_uav_desc_from_resource(D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11Resource *resource)
 731 {
 732     D3D11_RESOURCE_DIMENSION dimension;
 733
 734     ID3D11Resource_GetType(resource, &dimension);
 735
 736     switch (dimension)
 737     {
 738         case D3D11_RESOURCE_DIMENSION_BUFFER:
 739         {
 740             D3D11_BUFFER_DESC buffer_desc;
 741             ID3D11Buffer *buffer;
 742
 743             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Buffer, (void **)&buffer)))
 744             {
 745                 ERR("Resource of type BUFFER doesn't implement ID3D11Buffer.\n");
 746                 return E_INVALIDARG;
 747             }
 748
 749             ID3D11Buffer_GetDesc(buffer, &buffer_desc);
 750             ID3D11Buffer_Release(buffer);
 751
 752             if (buffer_desc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
 753             {
 754                 desc->Format = DXGI_FORMAT_UNKNOWN;
 755                 desc->ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
 756                 desc->u.Buffer.FirstElement = 0;
 757                 desc->u.Buffer.NumElements = buffer_desc.ByteWidth / buffer_desc.StructureByteStride;
 758                 desc->u.Buffer.Flags = 0;
 759                 return S_OK;
 760             }
 761
 762             return E_INVALIDARG;
 763         }
 764
 765         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 766         {
 767             D3D11_TEXTURE2D_DESC texture_desc;
 768             ID3D11Texture2D *texture;
 769
 770             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
 771             {
 772                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
 773                 return E_INVALIDARG;
 774             }
 775
 776             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 777             ID3D11Texture2D_Release(texture);
 778
 779             if (texture_desc.SampleDesc.Count != 1)
 780             {
 781                 WARN("Trying to create view for multisample texture.\n");
 782                 return E_INVALIDARG;
 783             }
 784
 785             desc->Format = texture_desc.Format;
 786             if (texture_desc.ArraySize == 1)
 787             {
 788                 desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
 789                 desc->u.Texture2D.MipSlice = 0;
 790             }
 791             else
 792             {
 793                 desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY;
 794                 desc->u.Texture2DArray.MipSlice = 0;
 795                 desc->u.Texture2DArray.FirstArraySlice = 0;
 796                 desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 797             }
 798
 799             return S_OK;
 800         }
 801
 802         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 803         {
 804             D3D11_TEXTURE3D_DESC texture_desc;
 805             ID3D11Texture3D *texture;
 806
 807             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture)))
 808             {
 809                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D.\n");
 810                 return E_INVALIDARG;
 811             }
 812
 813             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 814             ID3D11Texture3D_Release(texture);
 815
 816             desc->Format = texture_desc.Format;
 817             desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D;
 818             desc->u.Texture3D.MipSlice = 0;
 819             desc->u.Texture3D.FirstWSlice = 0;
 820             desc->u.Texture3D.WSize = texture_desc.Depth;
 821
 822             return S_OK;
 823         }
 824
 825         default:
 826             FIXME("Unhandled resource dimension %#x.\n", dimension);
 827             return E_INVALIDARG;
 828     }
 829 }
 830
 831 static HRESULT normalize_uav_desc(D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11Resource *resource)
 832 {
 833     D3D11_RESOURCE_DIMENSION dimension;
 834     unsigned int layer_count;
 835     DXGI_FORMAT format;
 836
 837     ID3D11Resource_GetType(resource, &dimension);
 838     switch (dimension)
 839     {
 840         case D3D11_RESOURCE_DIMENSION_BUFFER:
 841         {
 842             if (desc->ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
 843             {
 844                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 845                 return E_INVALIDARG;
 846             }
 847             return S_OK;
 848         }
 849
 850         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 851         {
 852             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE1D
 853                     && desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE1DARRAY)
 854             {
 855                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 856                 return E_INVALIDARG;
 857             }
 858
 859             FIXME("Unhandled 1D texture resource.\n");
 860             return S_OK;
 861         }
 862
 863         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 864         {
 865             const struct d3d_texture2d *texture;
 866
 867             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE2D
 868                     && desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE2DARRAY)
 869             {
 870                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 871                 return E_INVALIDARG;
 872             }
 873
 874             if (!(texture = unsafe_impl_from_ID3D11Texture2D((ID3D11Texture2D *)resource)))
 875             {
 876                 ERR("Cannot get implementation from ID3D11Texture2D.\n");
 877                 return E_FAIL;
 878             }
 879
 880             format = texture->desc.Format;
 881             layer_count = texture->desc.ArraySize;
 882             break;
 883         }
 884
 885         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 886         {
 887             const struct d3d_texture3d *texture;
 888
 889             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE3D)
 890             {
 891                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 892                 return E_INVALIDARG;
 893             }
 894
 895             if (!(texture = unsafe_impl_from_ID3D11Texture3D((ID3D11Texture3D *)resource)))
 896             {
 897                 ERR("Cannot get implementation from ID3D11Texture3D.\n");
 898                 return E_FAIL;
 899             }
 900
 901             format = texture->desc.Format;
 902             layer_count = texture->desc.Depth;
 903             break;
 904         }
 905
 906         default:
 907             ERR("Unhandled resource dimension %#x.\n", dimension);
 908             return E_FAIL;
 909     }
 910
 911     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 912         desc->Format = format;
 913
 914     switch (desc->ViewDimension)
 915     {
 916         case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
 917             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < layer_count)
 918                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 919             break;
 920
 921         case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
 922             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 923                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 924             break;
 925
 926         case D3D11_UAV_DIMENSION_TEXTURE3D:
 927             layer_count = max(1, layer_count >> desc->u.Texture3D.MipSlice);
 928             if (desc->u.Texture3D.WSize == ~0u && desc->u.Texture3D.FirstWSlice < layer_count)
 929                 desc->u.Texture3D.WSize = layer_count - desc->u.Texture3D.FirstWSlice;
 930             break;
 931
 932         default:
 933             break;
 934     }
 935
 936     return S_OK;
 937 }
 938
 939 /* ID3D11DepthStencilView methods */
 940
 941 static inline struct d3d_depthstencil_view *impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
 942 {
 943     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D11DepthStencilView_iface);
 944 }
 945
 946 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_QueryInterface(ID3D11DepthStencilView *iface,
 947         REFIID riid, void **object)
 948 {
 949     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 950
 951     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 952
 953     if (IsEqualGUID(riid, &IID_ID3D11DepthStencilView)
 954             || IsEqualGUID(riid, &IID_ID3D11View)
 955             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 956             || IsEqualGUID(riid, &IID_IUnknown))
 957     {
 958         ID3D11DepthStencilView_AddRef(iface);
 959         *object = iface;
 960         return S_OK;
 961     }
 962
 963     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilView)
 964             || IsEqualGUID(riid, &IID_ID3D10View)
 965             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 966     {
 967         ID3D10DepthStencilView_AddRef(&view->ID3D10DepthStencilView_iface);
 968         *object = &view->ID3D10DepthStencilView_iface;
 969         return S_OK;
 970     }
 971
 972     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 973
 974     *object = NULL;
 975     return E_NOINTERFACE;
 976 }
 977
 978 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_AddRef(ID3D11DepthStencilView *iface)
 979 {
 980     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 981     ULONG refcount = InterlockedIncrement(&view->refcount);
 982
 983     TRACE("%p increasing refcount to %u.\n", view, refcount);
 984
 985     return refcount;
 986 }
 987
 988 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_Release(ID3D11DepthStencilView *iface)
 989 {
 990     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 991     ULONG refcount = InterlockedDecrement(&view->refcount);
 992
 993     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 994
 995     if (!refcount)
 996     {
 997         wined3d_mutex_lock();
 998         wined3d_rendertarget_view_decref(view->wined3d_view);
 999         ID3D11Resource_Release(view->resource);
1000         ID3D11Device_Release(view->device);
1001         wined3d_private_store_cleanup(&view->private_store);
1002         wined3d_mutex_unlock();
1003         HeapFree(GetProcessHeap(), 0, view);
1004     }
1005
1006     return refcount;
1007 }
1008
1009 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDevice(ID3D11DepthStencilView *iface,
1010         ID3D11Device **device)
1011 {
1012     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1013
1014     TRACE("iface %p, device %p.\n", iface, device);
1015
1016     *device = view->device;
1017     ID3D11Device_AddRef(*device);
1018 }
1019
1020 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_GetPrivateData(ID3D11DepthStencilView *iface,
1021         REFGUID guid, UINT *data_size, void *data)
1022 {
1023     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1024
1025     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1026
1027     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1028 }
1029
1030 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateData(ID3D11DepthStencilView *iface,
1031         REFGUID guid, UINT data_size, const void *data)
1032 {
1033     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1034
1035     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1036
1037     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1038 }
1039
1040 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateDataInterface(ID3D11DepthStencilView *iface,
1041         REFGUID guid, const IUnknown *data)
1042 {
1043     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1044
1045     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1046
1047     return d3d_set_private_data_interface(&view->private_store, guid, data);
1048 }
1049
1050 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetResource(ID3D11DepthStencilView *iface,
1051         ID3D11Resource **resource)
1052 {
1053     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1054
1055     TRACE("iface %p, resource %p.\n", iface, resource);
1056
1057     *resource = view->resource;
1058     ID3D11Resource_AddRef(*resource);
1059 }
1060
1061 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDesc(ID3D11DepthStencilView *iface,
1062         D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1063 {
1064     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1065
1066     TRACE("iface %p, desc %p.\n", iface, desc);
1067
1068     *desc = view->desc;
1069 }
1070
1071 static const struct ID3D11DepthStencilViewVtbl d3d11_depthstencil_view_vtbl =
1072 {
1073     /* IUnknown methods */
1074     d3d11_depthstencil_view_QueryInterface,
1075     d3d11_depthstencil_view_AddRef,
1076     d3d11_depthstencil_view_Release,
1077     /* ID3D11DeviceChild methods */
1078     d3d11_depthstencil_view_GetDevice,
1079     d3d11_depthstencil_view_GetPrivateData,
1080     d3d11_depthstencil_view_SetPrivateData,
1081     d3d11_depthstencil_view_SetPrivateDataInterface,
1082     /* ID3D11View methods */
1083     d3d11_depthstencil_view_GetResource,
1084     /* ID3D11DepthStencilView methods */
1085     d3d11_depthstencil_view_GetDesc,
1086 };
1087
1088 /* ID3D10DepthStencilView methods */
1089
1090 static inline struct d3d_depthstencil_view *impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
1091 {
1092     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D10DepthStencilView_iface);
1093 }
1094
1095 /* IUnknown methods */
1096
1097 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_QueryInterface(ID3D10DepthStencilView *iface,
1098         REFIID riid, void **object)
1099 {
1100     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1101
1102     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1103
1104     return d3d11_depthstencil_view_QueryInterface(&view->ID3D11DepthStencilView_iface, riid, object);
1105 }
1106
1107 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_AddRef(ID3D10DepthStencilView *iface)
1108 {
1109     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1110
1111     TRACE("iface %p.\n", iface);
1112
1113     return d3d11_depthstencil_view_AddRef(&view->ID3D11DepthStencilView_iface);
1114 }
1115
1116 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_Release(ID3D10DepthStencilView *iface)
1117 {
1118     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1119
1120     TRACE("iface %p.\n", iface);
1121
1122     return d3d11_depthstencil_view_Release(&view->ID3D11DepthStencilView_iface);
1123 }
1124
1125 /* ID3D10DeviceChild methods */
1126
1127 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDevice(ID3D10DepthStencilView *iface, ID3D10Device **device)
1128 {
1129     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1130
1131     TRACE("iface %p, device %p.\n", iface, device);
1132
1133     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1134 }
1135
1136 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_GetPrivateData(ID3D10DepthStencilView *iface,
1137         REFGUID guid, UINT *data_size, void *data)
1138 {
1139     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1140
1141     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1142             iface, debugstr_guid(guid), data_size, data);
1143
1144     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1145 }
1146
1147 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateData(ID3D10DepthStencilView *iface,
1148         REFGUID guid, UINT data_size, const void *data)
1149 {
1150     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1151
1152     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1153             iface, debugstr_guid(guid), data_size, data);
1154
1155     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1156 }
1157
1158 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateDataInterface(ID3D10DepthStencilView *iface,
1159         REFGUID guid, const IUnknown *data)
1160 {
1161     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1162
1163     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1164
1165     return d3d_set_private_data_interface(&view->private_store, guid, data);
1166 }
1167
1168 /* ID3D10View methods */
1169
1170 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetResource(ID3D10DepthStencilView *iface,
1171         ID3D10Resource **resource)
1172 {
1173     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1174
1175     TRACE("iface %p, resource %p.\n", iface, resource);
1176
1177     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1178 }
1179
1180 /* ID3D10DepthStencilView methods */
1181
1182 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDesc(ID3D10DepthStencilView *iface,
1183         D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
1184 {
1185     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1186     const D3D11_DEPTH_STENCIL_VIEW_DESC *d3d11_desc = &view->desc;
1187
1188     TRACE("iface %p, desc %p.\n", iface, desc);
1189
1190     desc->Format = d3d11_desc->Format;
1191     desc->ViewDimension = (D3D10_DSV_DIMENSION)d3d11_desc->ViewDimension;
1192     memcpy(&desc->u, &d3d11_desc->u, sizeof(desc->u));
1193 }
1194
1195 static const struct ID3D10DepthStencilViewVtbl d3d10_depthstencil_view_vtbl =
1196 {
1197     /* IUnknown methods */
1198     d3d10_depthstencil_view_QueryInterface,
1199     d3d10_depthstencil_view_AddRef,
1200     d3d10_depthstencil_view_Release,
1201     /* ID3D10DeviceChild methods */
1202     d3d10_depthstencil_view_GetDevice,
1203     d3d10_depthstencil_view_GetPrivateData,
1204     d3d10_depthstencil_view_SetPrivateData,
1205     d3d10_depthstencil_view_SetPrivateDataInterface,
1206     /* ID3D10View methods */
1207     d3d10_depthstencil_view_GetResource,
1208     /* ID3D10DepthStencilView methods */
1209     d3d10_depthstencil_view_GetDesc,
1210 };
1211
1212 static void wined3d_depth_stencil_view_desc_from_d3d11(struct wined3d_rendertarget_view_desc *wined3d_desc,
1213         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1214 {
1215     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1216
1217     if (desc->Flags)
1218         FIXME("Unhandled depth stencil view flags %#x.\n", desc->Flags);
1219
1220     switch (desc->ViewDimension)
1221     {
1222         case D3D11_DSV_DIMENSION_TEXTURE1D:
1223             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1224             wined3d_desc->u.texture.layer_idx = 0;
1225             wined3d_desc->u.texture.layer_count = 1;
1226             break;
1227
1228         case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
1229             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1230             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1231             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1232             break;
1233
1234         case D3D11_DSV_DIMENSION_TEXTURE2D:
1235             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1236             wined3d_desc->u.texture.layer_idx = 0;
1237             wined3d_desc->u.texture.layer_count = 1;
1238             break;
1239
1240         case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
1241             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1242             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1243             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1244             break;
1245
1246         case D3D11_DSV_DIMENSION_TEXTURE2DMS:
1247             wined3d_desc->u.texture.level_idx = 0;
1248             wined3d_desc->u.texture.layer_idx = 0;
1249             wined3d_desc->u.texture.layer_count = 1;
1250             break;
1251
1252         case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
1253             wined3d_desc->u.texture.level_idx = 0;
1254             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1255             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1256             break;
1257
1258         default:
1259             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1260             wined3d_desc->u.texture.level_idx = 0;
1261             wined3d_desc->u.texture.layer_idx = 0;
1262             wined3d_desc->u.texture.layer_count = 1;
1263             break;
1264     }
1265 }
1266
1267 static HRESULT d3d_depthstencil_view_init(struct d3d_depthstencil_view *view, struct d3d_device *device,
1268         ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1269 {
1270     struct wined3d_rendertarget_view_desc wined3d_desc;
1271     struct wined3d_resource *wined3d_resource;
1272     HRESULT hr;
1273
1274     view->ID3D11DepthStencilView_iface.lpVtbl = &d3d11_depthstencil_view_vtbl;
1275     view->ID3D10DepthStencilView_iface.lpVtbl = &d3d10_depthstencil_view_vtbl;
1276     view->refcount = 1;
1277
1278     if (!desc)
1279     {
1280         hr = set_dsv_desc_from_resource(&view->desc, resource);
1281     }
1282     else
1283     {
1284         view->desc = *desc;
1285         hr = normalize_dsv_desc(&view->desc, resource);
1286     }
1287     if (FAILED(hr))
1288         return hr;
1289
1290     wined3d_mutex_lock();
1291     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1292     {
1293         wined3d_mutex_unlock();
1294         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1295         return E_FAIL;
1296     }
1297
1298     wined3d_depth_stencil_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1299     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1300             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
1301     {
1302         wined3d_mutex_unlock();
1303         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1304         return hr;
1305     }
1306
1307     wined3d_private_store_init(&view->private_store);
1308     wined3d_mutex_unlock();
1309     view->resource = resource;
1310     ID3D11Resource_AddRef(resource);
1311     view->device = &device->ID3D11Device_iface;
1312     ID3D11Device_AddRef(view->device);
1313
1314     return S_OK;
1315 }
1316
1317 HRESULT d3d_depthstencil_view_create(struct d3d_device *device, ID3D11Resource *resource,
1318         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, struct d3d_depthstencil_view **view)
1319 {
1320     struct d3d_depthstencil_view *object;
1321     HRESULT hr;
1322
1323     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1324         return E_OUTOFMEMORY;
1325
1326     if (FAILED(hr = d3d_depthstencil_view_init(object, device, resource, desc)))
1327     {
1328         WARN("Failed to initialize depthstencil view, hr %#x.\n", hr);
1329         HeapFree(GetProcessHeap(), 0, object);
1330         return hr;
1331     }
1332
1333     TRACE("Created depthstencil view %p.\n", object);
1334     *view = object;
1335
1336     return S_OK;
1337 }
1338
1339 struct d3d_depthstencil_view *unsafe_impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
1340 {
1341     if (!iface)
1342         return NULL;
1343     assert(iface->lpVtbl == &d3d11_depthstencil_view_vtbl);
1344
1345     return impl_from_ID3D11DepthStencilView(iface);
1346 }
1347
1348 struct d3d_depthstencil_view *unsafe_impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
1349 {
1350     if (!iface)
1351         return NULL;
1352     assert(iface->lpVtbl == &d3d10_depthstencil_view_vtbl);
1353
1354     return impl_from_ID3D10DepthStencilView(iface);
1355 }
1356
1357 /* ID3D11RenderTargetView methods */
1358
1359 static inline struct d3d_rendertarget_view *impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
1360 {
1361     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D11RenderTargetView_iface);
1362 }
1363
1364 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_QueryInterface(ID3D11RenderTargetView *iface,
1365         REFIID riid, void **object)
1366 {
1367     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1368
1369     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1370
1371     if (IsEqualGUID(riid, &IID_ID3D11RenderTargetView)
1372             || IsEqualGUID(riid, &IID_ID3D11View)
1373             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1374             || IsEqualGUID(riid, &IID_IUnknown))
1375     {
1376         ID3D11RenderTargetView_AddRef(iface);
1377         *object = iface;
1378         return S_OK;
1379     }
1380
1381     if (IsEqualGUID(riid, &IID_ID3D10RenderTargetView)
1382             || IsEqualGUID(riid, &IID_ID3D10View)
1383             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1384     {
1385         ID3D10RenderTargetView_AddRef(&view->ID3D10RenderTargetView_iface);
1386         *object = &view->ID3D10RenderTargetView_iface;
1387         return S_OK;
1388     }
1389
1390     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1391
1392     *object = NULL;
1393     return E_NOINTERFACE;
1394 }
1395
1396 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_AddRef(ID3D11RenderTargetView *iface)
1397 {
1398     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1399     ULONG refcount = InterlockedIncrement(&view->refcount);
1400
1401     TRACE("%p increasing refcount to %u.\n", view, refcount);
1402
1403     return refcount;
1404 }
1405
1406 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_Release(ID3D11RenderTargetView *iface)
1407 {
1408     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1409     ULONG refcount = InterlockedDecrement(&view->refcount);
1410
1411     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1412
1413     if (!refcount)
1414     {
1415         wined3d_mutex_lock();
1416         wined3d_rendertarget_view_decref(view->wined3d_view);
1417         ID3D11Resource_Release(view->resource);
1418         ID3D11Device_Release(view->device);
1419         wined3d_private_store_cleanup(&view->private_store);
1420         wined3d_mutex_unlock();
1421         HeapFree(GetProcessHeap(), 0, view);
1422     }
1423
1424     return refcount;
1425 }
1426
1427 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDevice(ID3D11RenderTargetView *iface,
1428         ID3D11Device **device)
1429 {
1430     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1431
1432     TRACE("iface %p, device %p.\n", iface, device);
1433
1434     *device = view->device;
1435     ID3D11Device_AddRef(*device);
1436 }
1437
1438 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_GetPrivateData(ID3D11RenderTargetView *iface,
1439         REFGUID guid, UINT *data_size, void *data)
1440 {
1441     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1442
1443     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1444
1445     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1446 }
1447
1448 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateData(ID3D11RenderTargetView *iface,
1449         REFGUID guid, UINT data_size, const void *data)
1450 {
1451     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1452
1453     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1454
1455     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1456 }
1457
1458 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateDataInterface(ID3D11RenderTargetView *iface,
1459         REFGUID guid, const IUnknown *data)
1460 {
1461     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1462
1463     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1464
1465     return d3d_set_private_data_interface(&view->private_store, guid, data);
1466 }
1467
1468 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetResource(ID3D11RenderTargetView *iface,
1469         ID3D11Resource **resource)
1470 {
1471     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1472
1473     TRACE("iface %p, resource %p.\n", iface, resource);
1474
1475     *resource = view->resource;
1476     ID3D11Resource_AddRef(*resource);
1477 }
1478
1479 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDesc(ID3D11RenderTargetView *iface,
1480         D3D11_RENDER_TARGET_VIEW_DESC *desc)
1481 {
1482     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1483
1484     TRACE("iface %p, desc %p.\n", iface, desc);
1485
1486     *desc = view->desc;
1487 }
1488
1489 static const struct ID3D11RenderTargetViewVtbl d3d11_rendertarget_view_vtbl =
1490 {
1491     /* IUnknown methods */
1492     d3d11_rendertarget_view_QueryInterface,
1493     d3d11_rendertarget_view_AddRef,
1494     d3d11_rendertarget_view_Release,
1495     /* ID3D11DeviceChild methods */
1496     d3d11_rendertarget_view_GetDevice,
1497     d3d11_rendertarget_view_GetPrivateData,
1498     d3d11_rendertarget_view_SetPrivateData,
1499     d3d11_rendertarget_view_SetPrivateDataInterface,
1500     /* ID3D11View methods */
1501     d3d11_rendertarget_view_GetResource,
1502     /* ID3D11RenderTargetView methods */
1503     d3d11_rendertarget_view_GetDesc,
1504 };
1505
1506 /* ID3D10RenderTargetView methods */
1507
1508 static inline struct d3d_rendertarget_view *impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1509 {
1510     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D10RenderTargetView_iface);
1511 }
1512
1513 /* IUnknown methods */
1514
1515 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_QueryInterface(ID3D10RenderTargetView *iface,
1516         REFIID riid, void **object)
1517 {
1518     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1519
1520     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1521
1522     return d3d11_rendertarget_view_QueryInterface(&view->ID3D11RenderTargetView_iface, riid, object);
1523 }
1524
1525 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_AddRef(ID3D10RenderTargetView *iface)
1526 {
1527     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1528
1529     TRACE("iface %p.\n", iface);
1530
1531     return d3d11_rendertarget_view_AddRef(&view->ID3D11RenderTargetView_iface);
1532 }
1533
1534 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_Release(ID3D10RenderTargetView *iface)
1535 {
1536     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1537
1538     TRACE("iface %p.\n", iface);
1539
1540     return d3d11_rendertarget_view_Release(&view->ID3D11RenderTargetView_iface);
1541 }
1542
1543 /* ID3D10DeviceChild methods */
1544
1545 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDevice(ID3D10RenderTargetView *iface, ID3D10Device **device)
1546 {
1547     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1548
1549     TRACE("iface %p, device %p.\n", iface, device);
1550
1551     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1552 }
1553
1554 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_GetPrivateData(ID3D10RenderTargetView *iface,
1555         REFGUID guid, UINT *data_size, void *data)
1556 {
1557     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1558
1559     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1560             iface, debugstr_guid(guid), data_size, data);
1561
1562     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1563 }
1564
1565 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateData(ID3D10RenderTargetView *iface,
1566         REFGUID guid, UINT data_size, const void *data)
1567 {
1568     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1569
1570     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1571             iface, debugstr_guid(guid), data_size, data);
1572
1573     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1574 }
1575
1576 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateDataInterface(ID3D10RenderTargetView *iface,
1577         REFGUID guid, const IUnknown *data)
1578 {
1579     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1580
1581     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1582
1583     return d3d_set_private_data_interface(&view->private_store, guid, data);
1584 }
1585
1586 /* ID3D10View methods */
1587
1588 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTargetView *iface,
1589         ID3D10Resource **resource)
1590 {
1591     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1592
1593     TRACE("iface %p, resource %p\n", iface, resource);
1594
1595     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1596 }
1597
1598 /* ID3D10RenderTargetView methods */
1599
1600 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDesc(ID3D10RenderTargetView *iface,
1601         D3D10_RENDER_TARGET_VIEW_DESC *desc)
1602 {
1603     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1604
1605     TRACE("iface %p, desc %p\n", iface, desc);
1606
1607     memcpy(desc, &view->desc, sizeof(*desc));
1608 }
1609
1610 static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl =
1611 {
1612     /* IUnknown methods */
1613     d3d10_rendertarget_view_QueryInterface,
1614     d3d10_rendertarget_view_AddRef,
1615     d3d10_rendertarget_view_Release,
1616     /* ID3D10DeviceChild methods */
1617     d3d10_rendertarget_view_GetDevice,
1618     d3d10_rendertarget_view_GetPrivateData,
1619     d3d10_rendertarget_view_SetPrivateData,
1620     d3d10_rendertarget_view_SetPrivateDataInterface,
1621     /* ID3D10View methods */
1622     d3d10_rendertarget_view_GetResource,
1623     /* ID3D10RenderTargetView methods */
1624     d3d10_rendertarget_view_GetDesc,
1625 };
1626
1627 static void wined3d_rendertarget_view_desc_from_d3d11(struct wined3d_rendertarget_view_desc *wined3d_desc,
1628         const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1629 {
1630     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1631
1632     switch (desc->ViewDimension)
1633     {
1634         case D3D11_RTV_DIMENSION_BUFFER:
1635             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
1636             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
1637             break;
1638
1639         case D3D11_RTV_DIMENSION_TEXTURE1D:
1640             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1641             wined3d_desc->u.texture.layer_idx = 0;
1642             wined3d_desc->u.texture.layer_count = 1;
1643             break;
1644
1645         case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
1646             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1647             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1648             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1649             break;
1650
1651         case D3D11_RTV_DIMENSION_TEXTURE2D:
1652             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1653             wined3d_desc->u.texture.layer_idx = 0;
1654             wined3d_desc->u.texture.layer_count = 1;
1655             break;
1656
1657         case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
1658             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1659             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1660             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1661             break;
1662
1663         case D3D11_RTV_DIMENSION_TEXTURE2DMS:
1664             wined3d_desc->u.texture.level_idx = 0;
1665             wined3d_desc->u.texture.layer_idx = 0;
1666             wined3d_desc->u.texture.layer_count = 1;
1667             break;
1668
1669         case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
1670             wined3d_desc->u.texture.level_idx = 0;
1671             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1672             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1673             break;
1674
1675         case D3D11_RTV_DIMENSION_TEXTURE3D:
1676             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
1677             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
1678             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
1679             break;
1680
1681         default:
1682             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1683             wined3d_desc->u.texture.level_idx = 0;
1684             wined3d_desc->u.texture.layer_idx = 0;
1685             wined3d_desc->u.texture.layer_count = 1;
1686             break;
1687     }
1688 }
1689
1690 static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, struct d3d_device *device,
1691         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1692 {
1693     struct wined3d_rendertarget_view_desc wined3d_desc;
1694     struct wined3d_resource *wined3d_resource;
1695     HRESULT hr;
1696
1697     view->ID3D11RenderTargetView_iface.lpVtbl = &d3d11_rendertarget_view_vtbl;
1698     view->ID3D10RenderTargetView_iface.lpVtbl = &d3d10_rendertarget_view_vtbl;
1699     view->refcount = 1;
1700
1701     if (!desc)
1702     {
1703         hr = set_rtv_desc_from_resource(&view->desc, resource);
1704     }
1705     else
1706     {
1707         view->desc = *desc;
1708         hr = normalize_rtv_desc(&view->desc, resource);
1709     }
1710     if (FAILED(hr))
1711         return hr;
1712
1713     wined3d_mutex_lock();
1714     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1715     {
1716         wined3d_mutex_unlock();
1717         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1718         return E_FAIL;
1719     }
1720
1721     wined3d_rendertarget_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1722     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1723             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
1724     {
1725         wined3d_mutex_unlock();
1726         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1727         return hr;
1728     }
1729
1730     wined3d_private_store_init(&view->private_store);
1731     wined3d_mutex_unlock();
1732     view->resource = resource;
1733     ID3D11Resource_AddRef(resource);
1734     view->device = &device->ID3D11Device_iface;
1735     ID3D11Device_AddRef(view->device);
1736
1737     return S_OK;
1738 }
1739
1740 HRESULT d3d_rendertarget_view_create(struct d3d_device *device, ID3D11Resource *resource,
1741         const D3D11_RENDER_TARGET_VIEW_DESC *desc, struct d3d_rendertarget_view **view)
1742 {
1743     struct d3d_rendertarget_view *object;
1744     HRESULT hr;
1745
1746     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1747         return E_OUTOFMEMORY;
1748
1749     if (FAILED(hr = d3d_rendertarget_view_init(object, device, resource, desc)))
1750     {
1751         WARN("Failed to initialize rendertarget view, hr %#x.\n", hr);
1752         HeapFree(GetProcessHeap(), 0, object);
1753         return hr;
1754     }
1755
1756     TRACE("Created rendertarget view %p.\n", object);
1757     *view = object;
1758
1759     return S_OK;
1760 }
1761
1762 struct d3d_rendertarget_view *unsafe_impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
1763 {
1764     if (!iface)
1765         return NULL;
1766     assert(iface->lpVtbl == &d3d11_rendertarget_view_vtbl);
1767
1768     return impl_from_ID3D11RenderTargetView(iface);
1769 }
1770
1771 struct d3d_rendertarget_view *unsafe_impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1772 {
1773     if (!iface)
1774         return NULL;
1775     assert(iface->lpVtbl == &d3d10_rendertarget_view_vtbl);
1776
1777     return impl_from_ID3D10RenderTargetView(iface);
1778 }
1779
1780 /* ID3D11ShaderResourceView methods */
1781
1782 static inline struct d3d_shader_resource_view *impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
1783 {
1784     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D11ShaderResourceView_iface);
1785 }
1786
1787 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_QueryInterface(ID3D11ShaderResourceView *iface,
1788         REFIID riid, void **object)
1789 {
1790     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1791
1792     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1793
1794     if (IsEqualGUID(riid, &IID_ID3D11ShaderResourceView)
1795             || IsEqualGUID(riid, &IID_ID3D11View)
1796             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1797             || IsEqualGUID(riid, &IID_IUnknown))
1798     {
1799         ID3D11ShaderResourceView_AddRef(iface);
1800         *object = iface;
1801         return S_OK;
1802     }
1803
1804     if (IsEqualGUID(riid, &IID_ID3D10ShaderResourceView1)
1805             || IsEqualGUID(riid, &IID_ID3D10ShaderResourceView)
1806             || IsEqualGUID(riid, &IID_ID3D10View)
1807             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1808     {
1809         ID3D10ShaderResourceView1_AddRef(&view->ID3D10ShaderResourceView1_iface);
1810         *object = &view->ID3D10ShaderResourceView1_iface;
1811         return S_OK;
1812     }
1813
1814     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1815
1816     *object = NULL;
1817     return E_NOINTERFACE;
1818 }
1819
1820 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_AddRef(ID3D11ShaderResourceView *iface)
1821 {
1822     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1823     ULONG refcount = InterlockedIncrement(&view->refcount);
1824
1825     TRACE("%p increasing refcount to %u.\n", view, refcount);
1826
1827     return refcount;
1828 }
1829
1830 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_Release(ID3D11ShaderResourceView *iface)
1831 {
1832     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1833     ULONG refcount = InterlockedDecrement(&view->refcount);
1834
1835     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1836
1837     if (!refcount)
1838     {
1839         wined3d_mutex_lock();
1840         wined3d_shader_resource_view_decref(view->wined3d_view);
1841         ID3D11Resource_Release(view->resource);
1842         ID3D11Device_Release(view->device);
1843         wined3d_private_store_cleanup(&view->private_store);
1844         wined3d_mutex_unlock();
1845         HeapFree(GetProcessHeap(), 0, view);
1846     }
1847
1848     return refcount;
1849 }
1850
1851 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDevice(ID3D11ShaderResourceView *iface,
1852         ID3D11Device **device)
1853 {
1854     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1855
1856     TRACE("iface %p, device %p.\n", iface, device);
1857
1858     *device = view->device;
1859     ID3D11Device_AddRef(*device);
1860 }
1861
1862 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_GetPrivateData(ID3D11ShaderResourceView *iface,
1863         REFGUID guid, UINT *data_size, void *data)
1864 {
1865     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1866
1867     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1868
1869     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1870 }
1871
1872 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateData(ID3D11ShaderResourceView *iface,
1873         REFGUID guid, UINT data_size, const void *data)
1874 {
1875     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1876
1877     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1878
1879     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1880 }
1881
1882 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateDataInterface(ID3D11ShaderResourceView *iface,
1883         REFGUID guid, const IUnknown *data)
1884 {
1885     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1886
1887     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1888
1889     return d3d_set_private_data_interface(&view->private_store, guid, data);
1890 }
1891
1892 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetResource(ID3D11ShaderResourceView *iface,
1893         ID3D11Resource **resource)
1894 {
1895     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1896
1897     TRACE("iface %p, resource %p.\n", iface, resource);
1898
1899     *resource = view->resource;
1900     ID3D11Resource_AddRef(*resource);
1901 }
1902
1903 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDesc(ID3D11ShaderResourceView *iface,
1904         D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
1905 {
1906     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1907
1908     TRACE("iface %p, desc %p.\n", iface, desc);
1909
1910     *desc = view->desc;
1911 }
1912
1913 static const struct ID3D11ShaderResourceViewVtbl d3d11_shader_resource_view_vtbl =
1914 {
1915     /* IUnknown methods */
1916     d3d11_shader_resource_view_QueryInterface,
1917     d3d11_shader_resource_view_AddRef,
1918     d3d11_shader_resource_view_Release,
1919     /* ID3D11DeviceChild methods */
1920     d3d11_shader_resource_view_GetDevice,
1921     d3d11_shader_resource_view_GetPrivateData,
1922     d3d11_shader_resource_view_SetPrivateData,
1923     d3d11_shader_resource_view_SetPrivateDataInterface,
1924     /* ID3D11View methods */
1925     d3d11_shader_resource_view_GetResource,
1926     /* ID3D11ShaderResourceView methods */
1927     d3d11_shader_resource_view_GetDesc,
1928 };
1929
1930 /* ID3D10ShaderResourceView methods */
1931
1932 static inline struct d3d_shader_resource_view *impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView1 *iface)
1933 {
1934     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
1935 }
1936
1937 /* IUnknown methods */
1938
1939 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_QueryInterface(ID3D10ShaderResourceView1 *iface,
1940         REFIID riid, void **object)
1941 {
1942     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1943
1944     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1945
1946     return d3d11_shader_resource_view_QueryInterface(&view->ID3D11ShaderResourceView_iface, riid, object);
1947 }
1948
1949 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_AddRef(ID3D10ShaderResourceView1 *iface)
1950 {
1951     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1952
1953     TRACE("iface %p.\n", iface);
1954
1955     return d3d11_shader_resource_view_AddRef(&view->ID3D11ShaderResourceView_iface);
1956 }
1957
1958 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_Release(ID3D10ShaderResourceView1 *iface)
1959 {
1960     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1961
1962     TRACE("iface %p.\n", iface);
1963
1964     return d3d11_shader_resource_view_Release(&view->ID3D11ShaderResourceView_iface);
1965 }
1966
1967 /* ID3D10DeviceChild methods */
1968
1969 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDevice(ID3D10ShaderResourceView1 *iface,
1970         ID3D10Device **device)
1971 {
1972     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1973
1974     TRACE("iface %p, device %p.\n", iface, device);
1975
1976     ID3D11Device_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1977 }
1978
1979 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_GetPrivateData(ID3D10ShaderResourceView1 *iface,
1980         REFGUID guid, UINT *data_size, void *data)
1981 {
1982     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1983
1984     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1985             iface, debugstr_guid(guid), data_size, data);
1986
1987     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1988 }
1989
1990 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateData(ID3D10ShaderResourceView1 *iface,
1991         REFGUID guid, UINT data_size, const void *data)
1992 {
1993     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1994
1995     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1996             iface, debugstr_guid(guid), data_size, data);
1997
1998     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1999 }
2000
2001 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateDataInterface(ID3D10ShaderResourceView1 *iface,
2002         REFGUID guid, const IUnknown *data)
2003 {
2004     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2005
2006     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2007
2008     return d3d_set_private_data_interface(&view->private_store, guid, data);
2009 }
2010
2011 /* ID3D10View methods */
2012
2013 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetResource(ID3D10ShaderResourceView1 *iface,
2014         ID3D10Resource **resource)
2015 {
2016     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2017
2018     TRACE("iface %p, resource %p.\n", iface, resource);
2019
2020     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
2021 }
2022
2023 /* ID3D10ShaderResourceView methods */
2024
2025 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc(ID3D10ShaderResourceView1 *iface,
2026         D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
2027 {
2028     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2029
2030     TRACE("iface %p, desc %p.\n", iface, desc);
2031
2032     memcpy(desc, &view->desc, sizeof(*desc));
2033 }
2034
2035 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc1(ID3D10ShaderResourceView1 *iface,
2036         D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc)
2037 {
2038     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2039
2040     TRACE("iface %p, desc %p.\n", iface, desc);
2041
2042     memcpy(desc, &view->desc, sizeof(*desc));
2043 }
2044
2045 static const struct ID3D10ShaderResourceView1Vtbl d3d10_shader_resource_view_vtbl =
2046 {
2047     /* IUnknown methods */
2048     d3d10_shader_resource_view_QueryInterface,
2049     d3d10_shader_resource_view_AddRef,
2050     d3d10_shader_resource_view_Release,
2051     /* ID3D10DeviceChild methods */
2052     d3d10_shader_resource_view_GetDevice,
2053     d3d10_shader_resource_view_GetPrivateData,
2054     d3d10_shader_resource_view_SetPrivateData,
2055     d3d10_shader_resource_view_SetPrivateDataInterface,
2056     /* ID3D10View methods */
2057     d3d10_shader_resource_view_GetResource,
2058     /* ID3D10ShaderResourceView methods */
2059     d3d10_shader_resource_view_GetDesc,
2060     /* ID3D10ShaderResourceView1 methods */
2061     d3d10_shader_resource_view_GetDesc1,
2062 };
2063
2064 static unsigned int wined3d_view_flags_from_d3d11_bufferex_flags(unsigned int d3d11_flags)
2065 {
2066     unsigned int wined3d_flags = d3d11_flags & WINED3D_VIEW_BUFFER_RAW;
2067
2068     if (d3d11_flags != wined3d_flags)
2069         FIXME("Unhandled flags %#x.\n", d3d11_flags & ~wined3d_flags);
2070
2071     return wined3d_flags;
2072 }
2073
2074 static HRESULT wined3d_shader_resource_view_desc_from_d3d11(struct wined3d_shader_resource_view_desc *wined3d_desc,
2075         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2076 {
2077     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2078     wined3d_desc->flags = 0;
2079
2080     switch (desc->ViewDimension)
2081     {
2082         case D3D11_SRV_DIMENSION_BUFFER:
2083             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
2084             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
2085             break;
2086
2087         case D3D11_SRV_DIMENSION_TEXTURE1D:
2088             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MostDetailedMip;
2089             wined3d_desc->u.texture.level_count = desc->u.Texture1D.MipLevels;
2090             wined3d_desc->u.texture.layer_idx = 0;
2091             wined3d_desc->u.texture.layer_count = 1;
2092             break;
2093
2094         case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
2095             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2096             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MostDetailedMip;
2097             wined3d_desc->u.texture.level_count = desc->u.Texture1DArray.MipLevels;
2098             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2099             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2100             break;
2101
2102         case D3D11_SRV_DIMENSION_TEXTURE2D:
2103             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MostDetailedMip;
2104             wined3d_desc->u.texture.level_count = desc->u.Texture2D.MipLevels;
2105             wined3d_desc->u.texture.layer_idx = 0;
2106             wined3d_desc->u.texture.layer_count = 1;
2107             break;
2108
2109         case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
2110             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2111             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MostDetailedMip;
2112             wined3d_desc->u.texture.level_count = desc->u.Texture2DArray.MipLevels;
2113             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2114             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2115             break;
2116
2117         case D3D11_SRV_DIMENSION_TEXTURE2DMS:
2118             wined3d_desc->u.texture.level_idx = 0;
2119             wined3d_desc->u.texture.level_count = 1;
2120             wined3d_desc->u.texture.layer_idx = 0;
2121             wined3d_desc->u.texture.layer_count = 1;
2122             break;
2123
2124         case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
2125             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2126             wined3d_desc->u.texture.level_idx = 0;
2127             wined3d_desc->u.texture.level_count = 1;
2128             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
2129             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
2130             break;
2131
2132         case D3D11_SRV_DIMENSION_TEXTURE3D:
2133             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MostDetailedMip;
2134             wined3d_desc->u.texture.level_count = desc->u.Texture3D.MipLevels;
2135             wined3d_desc->u.texture.layer_idx = 0;
2136             wined3d_desc->u.texture.layer_count = 1;
2137             break;
2138
2139         case D3D11_SRV_DIMENSION_TEXTURECUBE:
2140             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE;
2141             wined3d_desc->u.texture.level_idx = desc->u.TextureCube.MostDetailedMip;
2142             wined3d_desc->u.texture.level_count = desc->u.TextureCube.MipLevels;
2143             wined3d_desc->u.texture.layer_idx = 0;
2144             wined3d_desc->u.texture.layer_count = 6;
2145             break;
2146
2147         case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
2148             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE | WINED3D_VIEW_TEXTURE_ARRAY;
2149             wined3d_desc->u.texture.level_idx = desc->u.TextureCubeArray.MostDetailedMip;
2150             wined3d_desc->u.texture.level_count = desc->u.TextureCubeArray.MipLevels;
2151             wined3d_desc->u.texture.layer_idx = desc->u.TextureCubeArray.First2DArrayFace;
2152             wined3d_desc->u.texture.layer_count = 6 * desc->u.TextureCubeArray.NumCubes;
2153             break;
2154
2155         case D3D11_SRV_DIMENSION_BUFFEREX:
2156             wined3d_desc->flags = wined3d_view_flags_from_d3d11_bufferex_flags(desc->u.BufferEx.Flags);
2157             wined3d_desc->u.buffer.start_idx = desc->u.BufferEx.FirstElement;
2158             wined3d_desc->u.buffer.count = desc->u.BufferEx.NumElements;
2159             break;
2160
2161         default:
2162             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2163             return E_FAIL;
2164     }
2165
2166     return S_OK;
2167 }
2168
2169 static HRESULT d3d_shader_resource_view_init(struct d3d_shader_resource_view *view, struct d3d_device *device,
2170         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2171 {
2172     struct wined3d_shader_resource_view_desc wined3d_desc;
2173     struct wined3d_resource *wined3d_resource;
2174     HRESULT hr;
2175
2176     view->ID3D11ShaderResourceView_iface.lpVtbl = &d3d11_shader_resource_view_vtbl;
2177     view->ID3D10ShaderResourceView1_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
2178     view->refcount = 1;
2179
2180     if (!desc)
2181     {
2182         hr = set_srv_desc_from_resource(&view->desc, resource);
2183     }
2184     else
2185     {
2186         view->desc = *desc;
2187         hr = normalize_srv_desc(&view->desc, resource);
2188     }
2189     if (FAILED(hr))
2190         return hr;
2191
2192     if (FAILED(hr = wined3d_shader_resource_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2193         return hr;
2194
2195     wined3d_mutex_lock();
2196     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2197     {
2198         wined3d_mutex_unlock();
2199         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2200         return E_FAIL;
2201     }
2202
2203     if (FAILED(hr = wined3d_shader_resource_view_create(&wined3d_desc, wined3d_resource,
2204             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
2205     {
2206         wined3d_mutex_unlock();
2207         WARN("Failed to create wined3d shader resource view, hr %#x.\n", hr);
2208         return hr;
2209     }
2210
2211     wined3d_private_store_init(&view->private_store);
2212     wined3d_mutex_unlock();
2213     view->resource = resource;
2214     ID3D11Resource_AddRef(resource);
2215     view->device = &device->ID3D11Device_iface;
2216     ID3D11Device_AddRef(view->device);
2217
2218     return S_OK;
2219 }
2220
2221 HRESULT d3d_shader_resource_view_create(struct d3d_device *device, ID3D11Resource *resource,
2222         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, struct d3d_shader_resource_view **view)
2223 {
2224     struct d3d_shader_resource_view *object;
2225     HRESULT hr;
2226
2227     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2228         return E_OUTOFMEMORY;
2229
2230     if (FAILED(hr = d3d_shader_resource_view_init(object, device, resource, desc)))
2231     {
2232         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
2233         HeapFree(GetProcessHeap(), 0, object);
2234         return hr;
2235     }
2236
2237     TRACE("Created shader resource view %p.\n", object);
2238     *view = object;
2239
2240     return S_OK;
2241 }
2242
2243 struct d3d_shader_resource_view *unsafe_impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
2244 {
2245     if (!iface)
2246         return NULL;
2247     assert(iface->lpVtbl == &d3d11_shader_resource_view_vtbl);
2248     return impl_from_ID3D11ShaderResourceView(iface);
2249 }
2250
2251 struct d3d_shader_resource_view *unsafe_impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
2252 {
2253     if (!iface)
2254         return NULL;
2255     assert(iface->lpVtbl == (ID3D10ShaderResourceViewVtbl *)&d3d10_shader_resource_view_vtbl);
2256     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
2257 }
2258
2259 /* ID3D11UnorderedAccessView methods */
2260
2261 static inline struct d3d11_unordered_access_view *impl_from_ID3D11UnorderedAccessView(ID3D11UnorderedAccessView *iface)
2262 {
2263     return CONTAINING_RECORD(iface, struct d3d11_unordered_access_view, ID3D11UnorderedAccessView_iface);
2264 }
2265
2266 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_QueryInterface(ID3D11UnorderedAccessView *iface,
2267         REFIID riid, void **object)
2268 {
2269     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
2270
2271     if (IsEqualGUID(riid, &IID_ID3D11UnorderedAccessView)
2272             || IsEqualGUID(riid, &IID_ID3D11View)
2273             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
2274             || IsEqualGUID(riid, &IID_IUnknown))
2275     {
2276         ID3D11UnorderedAccessView_AddRef(*object = iface);
2277         return S_OK;
2278     }
2279
2280     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2281
2282     *object = NULL;
2283     return E_NOINTERFACE;
2284 }
2285
2286 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_AddRef(ID3D11UnorderedAccessView *iface)
2287 {
2288     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2289     ULONG refcount = InterlockedIncrement(&view->refcount);
2290
2291     TRACE("%p increasing refcount to %u.\n", view, refcount);
2292
2293     return refcount;
2294 }
2295
2296 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_Release(ID3D11UnorderedAccessView *iface)
2297 {
2298     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2299     ULONG refcount = InterlockedDecrement(&view->refcount);
2300
2301     TRACE("%p decreasing refcount to %u.\n", view, refcount);
2302
2303     if (!refcount)
2304     {
2305         wined3d_mutex_lock();
2306         wined3d_unordered_access_view_decref(view->wined3d_view);
2307         ID3D11Resource_Release(view->resource);
2308         ID3D11Device_Release(view->device);
2309         wined3d_private_store_cleanup(&view->private_store);
2310         wined3d_mutex_unlock();
2311         HeapFree(GetProcessHeap(), 0, view);
2312     }
2313
2314     return refcount;
2315 }
2316
2317 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDevice(ID3D11UnorderedAccessView *iface,
2318         ID3D11Device **device)
2319 {
2320     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2321
2322     TRACE("iface %p, device %p.\n", iface, device);
2323
2324     ID3D11Device_AddRef(*device = view->device);
2325 }
2326
2327 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_GetPrivateData(ID3D11UnorderedAccessView *iface,
2328         REFGUID guid, UINT *data_size, void *data)
2329 {
2330     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2331
2332     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2333
2334     return d3d_get_private_data(&view->private_store, guid, data_size, data);
2335 }
2336
2337 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateData(ID3D11UnorderedAccessView *iface,
2338         REFGUID guid, UINT data_size, const void *data)
2339 {
2340     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2341
2342     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2343
2344     return d3d_set_private_data(&view->private_store, guid, data_size, data);
2345 }
2346
2347 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateDataInterface(ID3D11UnorderedAccessView *iface,
2348         REFGUID guid, const IUnknown *data)
2349 {
2350     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2351
2352     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2353
2354     return d3d_set_private_data_interface(&view->private_store, guid, data);
2355 }
2356
2357 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetResource(ID3D11UnorderedAccessView *iface,
2358         ID3D11Resource **resource)
2359 {
2360     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2361
2362     TRACE("iface %p, resource %p.\n", iface, resource);
2363
2364     ID3D11Resource_AddRef(*resource = view->resource);
2365 }
2366
2367 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDesc(ID3D11UnorderedAccessView *iface,
2368         D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2369 {
2370     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2371
2372     TRACE("iface %p, desc %p.\n", iface, desc);
2373
2374     *desc = view->desc;
2375 }
2376
2377 static const struct ID3D11UnorderedAccessViewVtbl d3d11_unordered_access_view_vtbl =
2378 {
2379     /* IUnknown methods */
2380     d3d11_unordered_access_view_QueryInterface,
2381     d3d11_unordered_access_view_AddRef,
2382     d3d11_unordered_access_view_Release,
2383     /* ID3D11DeviceChild methods */
2384     d3d11_unordered_access_view_GetDevice,
2385     d3d11_unordered_access_view_GetPrivateData,
2386     d3d11_unordered_access_view_SetPrivateData,
2387     d3d11_unordered_access_view_SetPrivateDataInterface,
2388     /* ID3D11View methods */
2389     d3d11_unordered_access_view_GetResource,
2390     /* ID3D11UnorderedAccessView methods */
2391     d3d11_unordered_access_view_GetDesc,
2392 };
2393
2394 static unsigned int wined3d_view_flags_from_d3d11_buffer_uav_flags(unsigned int d3d11_flags)
2395 {
2396     unsigned int wined3d_flags = d3d11_flags & (WINED3D_VIEW_BUFFER_RAW
2397             | WINED3D_VIEW_BUFFER_APPEND | WINED3D_VIEW_BUFFER_COUNTER);
2398
2399     if (d3d11_flags != wined3d_flags)
2400         FIXME("Unhandled flags %#x.\n", d3d11_flags & ~wined3d_flags);
2401
2402     return wined3d_flags;
2403 }
2404
2405 static HRESULT wined3d_unordered_access_view_desc_from_d3d11(struct wined3d_unordered_access_view_desc *wined3d_desc,
2406         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2407 {
2408     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2409     wined3d_desc->flags = 0;
2410
2411     switch (desc->ViewDimension)
2412     {
2413         case D3D11_UAV_DIMENSION_BUFFER:
2414             wined3d_desc->flags = wined3d_view_flags_from_d3d11_buffer_uav_flags(desc->u.Buffer.Flags);
2415             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.FirstElement;
2416             wined3d_desc->u.buffer.count = desc->u.Buffer.NumElements;
2417             break;
2418
2419         case D3D11_UAV_DIMENSION_TEXTURE1D:
2420             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
2421             wined3d_desc->u.texture.layer_idx = 0;
2422             wined3d_desc->u.texture.layer_count = 1;
2423             break;
2424
2425         case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
2426             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2427             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
2428             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2429             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2430             break;
2431
2432         case D3D11_UAV_DIMENSION_TEXTURE2D:
2433             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
2434             wined3d_desc->u.texture.layer_idx = 0;
2435             wined3d_desc->u.texture.layer_count = 1;
2436             break;
2437
2438         case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
2439             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2440             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
2441             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2442             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2443             break;
2444
2445         case D3D11_UAV_DIMENSION_TEXTURE3D:
2446             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
2447             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
2448             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
2449             break;
2450
2451         default:
2452             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2453             return E_FAIL;
2454     }
2455
2456     return S_OK;
2457 }
2458
2459 static HRESULT d3d11_unordered_access_view_init(struct d3d11_unordered_access_view *view,
2460         struct d3d_device *device, ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2461 {
2462     struct wined3d_unordered_access_view_desc wined3d_desc;
2463     struct wined3d_resource *wined3d_resource;
2464     HRESULT hr;
2465
2466     view->ID3D11UnorderedAccessView_iface.lpVtbl = &d3d11_unordered_access_view_vtbl;
2467     view->refcount = 1;
2468
2469     if (!desc)
2470     {
2471         hr = set_uav_desc_from_resource(&view->desc, resource);
2472     }
2473     else
2474     {
2475         view->desc = *desc;
2476         hr = normalize_uav_desc(&view->desc, resource);
2477     }
2478     if (FAILED(hr))
2479         return hr;
2480
2481     if (FAILED(hr = wined3d_unordered_access_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2482         return hr;
2483
2484     wined3d_mutex_lock();
2485     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2486     {
2487         wined3d_mutex_unlock();
2488         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2489         return E_FAIL;
2490     }
2491
2492     if (FAILED(hr = wined3d_unordered_access_view_create(&wined3d_desc, wined3d_resource,
2493             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
2494     {
2495         wined3d_mutex_unlock();
2496         WARN("Failed to create wined3d unordered access view, hr %#x.\n", hr);
2497         return hr;
2498     }
2499
2500     wined3d_private_store_init(&view->private_store);
2501     wined3d_mutex_unlock();
2502     ID3D11Resource_AddRef(view->resource = resource);
2503     ID3D11Device_AddRef(view->device = &device->ID3D11Device_iface);
2504
2505     return S_OK;
2506 }
2507
2508 HRESULT d3d11_unordered_access_view_create(struct d3d_device *device, ID3D11Resource *resource,
2509         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, struct d3d11_unordered_access_view **view)
2510 {
2511     struct d3d11_unordered_access_view *object;
2512     HRESULT hr;
2513
2514     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2515         return E_OUTOFMEMORY;
2516
2517     if (FAILED(hr = d3d11_unordered_access_view_init(object, device, resource, desc)))
2518     {
2519         WARN("Failed to initialize unordered access view, hr %#x.\n", hr);
2520         HeapFree(GetProcessHeap(), 0, object);
2521         return hr;
2522     }
2523
2524     TRACE("Created unordered access view %p.\n", object);
2525     *view = object;
2526
2527     return S_OK;
2528 }