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.ArraySize;
 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.ArraySize;
 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.ArraySize;
 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 HRESULT wined3d_shader_resource_view_desc_from_d3d11(struct wined3d_shader_resource_view_desc *wined3d_desc,
2065         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2066 {
2067     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2068     wined3d_desc->flags = 0;
2069
2070     switch (desc->ViewDimension)
2071     {
2072         case D3D11_SRV_DIMENSION_BUFFER:
2073             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
2074             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
2075             break;
2076
2077         case D3D11_SRV_DIMENSION_TEXTURE1D:
2078             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MostDetailedMip;
2079             wined3d_desc->u.texture.level_count = desc->u.Texture1D.MipLevels;
2080             wined3d_desc->u.texture.layer_idx = 0;
2081             wined3d_desc->u.texture.layer_count = 1;
2082             break;
2083
2084         case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
2085             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2086             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MostDetailedMip;
2087             wined3d_desc->u.texture.level_count = desc->u.Texture1DArray.MipLevels;
2088             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2089             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2090             break;
2091
2092         case D3D11_SRV_DIMENSION_TEXTURE2D:
2093             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MostDetailedMip;
2094             wined3d_desc->u.texture.level_count = desc->u.Texture2D.MipLevels;
2095             wined3d_desc->u.texture.layer_idx = 0;
2096             wined3d_desc->u.texture.layer_count = 1;
2097             break;
2098
2099         case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
2100             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2101             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MostDetailedMip;
2102             wined3d_desc->u.texture.level_count = desc->u.Texture2DArray.MipLevels;
2103             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2104             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2105             break;
2106
2107         case D3D11_SRV_DIMENSION_TEXTURE2DMS:
2108             wined3d_desc->u.texture.level_idx = 0;
2109             wined3d_desc->u.texture.level_count = 1;
2110             wined3d_desc->u.texture.layer_idx = 0;
2111             wined3d_desc->u.texture.layer_count = 1;
2112             break;
2113
2114         case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
2115             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2116             wined3d_desc->u.texture.level_idx = 0;
2117             wined3d_desc->u.texture.level_count = 1;
2118             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
2119             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
2120             break;
2121
2122         case D3D11_SRV_DIMENSION_TEXTURE3D:
2123             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MostDetailedMip;
2124             wined3d_desc->u.texture.level_count = desc->u.Texture3D.MipLevels;
2125             wined3d_desc->u.texture.layer_idx = 0;
2126             wined3d_desc->u.texture.layer_count = 1;
2127             break;
2128
2129         case D3D11_SRV_DIMENSION_TEXTURECUBE:
2130             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE;
2131             wined3d_desc->u.texture.level_idx = desc->u.TextureCube.MostDetailedMip;
2132             wined3d_desc->u.texture.level_count = desc->u.TextureCube.MipLevels;
2133             wined3d_desc->u.texture.layer_idx = 0;
2134             wined3d_desc->u.texture.layer_count = 6;
2135             break;
2136
2137         case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
2138             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE | WINED3D_VIEW_TEXTURE_ARRAY;
2139             wined3d_desc->u.texture.level_idx = desc->u.TextureCubeArray.MostDetailedMip;
2140             wined3d_desc->u.texture.level_count = desc->u.TextureCubeArray.MipLevels;
2141             wined3d_desc->u.texture.layer_idx = desc->u.TextureCubeArray.First2DArrayFace;
2142             wined3d_desc->u.texture.layer_count = 6 * desc->u.TextureCubeArray.NumCubes;
2143             break;
2144
2145         case D3D11_SRV_DIMENSION_BUFFEREX:
2146             wined3d_desc->flags = desc->u.BufferEx.Flags;
2147             wined3d_desc->u.buffer.start_idx = desc->u.BufferEx.FirstElement;
2148             wined3d_desc->u.buffer.count = desc->u.BufferEx.NumElements;
2149             break;
2150
2151         default:
2152             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2153             return E_FAIL;
2154     }
2155
2156     return S_OK;
2157 }
2158
2159 static HRESULT d3d_shader_resource_view_init(struct d3d_shader_resource_view *view, struct d3d_device *device,
2160         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2161 {
2162     struct wined3d_shader_resource_view_desc wined3d_desc;
2163     struct wined3d_resource *wined3d_resource;
2164     HRESULT hr;
2165
2166     view->ID3D11ShaderResourceView_iface.lpVtbl = &d3d11_shader_resource_view_vtbl;
2167     view->ID3D10ShaderResourceView1_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
2168     view->refcount = 1;
2169
2170     if (!desc)
2171     {
2172         hr = set_srv_desc_from_resource(&view->desc, resource);
2173     }
2174     else
2175     {
2176         view->desc = *desc;
2177         hr = normalize_srv_desc(&view->desc, resource);
2178     }
2179     if (FAILED(hr))
2180         return hr;
2181
2182     if (FAILED(hr = wined3d_shader_resource_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2183         return hr;
2184
2185     wined3d_mutex_lock();
2186     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2187     {
2188         wined3d_mutex_unlock();
2189         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2190         return E_FAIL;
2191     }
2192
2193     if (FAILED(hr = wined3d_shader_resource_view_create(&wined3d_desc, wined3d_resource,
2194             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
2195     {
2196         wined3d_mutex_unlock();
2197         WARN("Failed to create wined3d shader resource view, hr %#x.\n", hr);
2198         return hr;
2199     }
2200
2201     wined3d_private_store_init(&view->private_store);
2202     wined3d_mutex_unlock();
2203     view->resource = resource;
2204     ID3D11Resource_AddRef(resource);
2205     view->device = &device->ID3D11Device_iface;
2206     ID3D11Device_AddRef(view->device);
2207
2208     return S_OK;
2209 }
2210
2211 HRESULT d3d_shader_resource_view_create(struct d3d_device *device, ID3D11Resource *resource,
2212         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, struct d3d_shader_resource_view **view)
2213 {
2214     struct d3d_shader_resource_view *object;
2215     HRESULT hr;
2216
2217     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2218         return E_OUTOFMEMORY;
2219
2220     if (FAILED(hr = d3d_shader_resource_view_init(object, device, resource, desc)))
2221     {
2222         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
2223         HeapFree(GetProcessHeap(), 0, object);
2224         return hr;
2225     }
2226
2227     TRACE("Created shader resource view %p.\n", object);
2228     *view = object;
2229
2230     return S_OK;
2231 }
2232
2233 struct d3d_shader_resource_view *unsafe_impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
2234 {
2235     if (!iface)
2236         return NULL;
2237     assert(iface->lpVtbl == &d3d11_shader_resource_view_vtbl);
2238     return impl_from_ID3D11ShaderResourceView(iface);
2239 }
2240
2241 struct d3d_shader_resource_view *unsafe_impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
2242 {
2243     if (!iface)
2244         return NULL;
2245     assert(iface->lpVtbl == (ID3D10ShaderResourceViewVtbl *)&d3d10_shader_resource_view_vtbl);
2246     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
2247 }
2248
2249 /* ID3D11UnorderedAccessView methods */
2250
2251 static inline struct d3d11_unordered_access_view *impl_from_ID3D11UnorderedAccessView(ID3D11UnorderedAccessView *iface)
2252 {
2253     return CONTAINING_RECORD(iface, struct d3d11_unordered_access_view, ID3D11UnorderedAccessView_iface);
2254 }
2255
2256 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_QueryInterface(ID3D11UnorderedAccessView *iface,
2257         REFIID riid, void **object)
2258 {
2259     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
2260
2261     if (IsEqualGUID(riid, &IID_ID3D11UnorderedAccessView)
2262             || IsEqualGUID(riid, &IID_ID3D11View)
2263             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
2264             || IsEqualGUID(riid, &IID_IUnknown))
2265     {
2266         ID3D11UnorderedAccessView_AddRef(*object = iface);
2267         return S_OK;
2268     }
2269
2270     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2271
2272     *object = NULL;
2273     return E_NOINTERFACE;
2274 }
2275
2276 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_AddRef(ID3D11UnorderedAccessView *iface)
2277 {
2278     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2279     ULONG refcount = InterlockedIncrement(&view->refcount);
2280
2281     TRACE("%p increasing refcount to %u.\n", view, refcount);
2282
2283     return refcount;
2284 }
2285
2286 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_Release(ID3D11UnorderedAccessView *iface)
2287 {
2288     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2289     ULONG refcount = InterlockedDecrement(&view->refcount);
2290
2291     TRACE("%p decreasing refcount to %u.\n", view, refcount);
2292
2293     if (!refcount)
2294     {
2295         wined3d_mutex_lock();
2296         wined3d_unordered_access_view_decref(view->wined3d_view);
2297         ID3D11Resource_Release(view->resource);
2298         ID3D11Device_Release(view->device);
2299         wined3d_private_store_cleanup(&view->private_store);
2300         wined3d_mutex_unlock();
2301         HeapFree(GetProcessHeap(), 0, view);
2302     }
2303
2304     return refcount;
2305 }
2306
2307 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDevice(ID3D11UnorderedAccessView *iface,
2308         ID3D11Device **device)
2309 {
2310     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2311
2312     TRACE("iface %p, device %p.\n", iface, device);
2313
2314     ID3D11Device_AddRef(*device = view->device);
2315 }
2316
2317 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_GetPrivateData(ID3D11UnorderedAccessView *iface,
2318         REFGUID guid, UINT *data_size, void *data)
2319 {
2320     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2321
2322     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2323
2324     return d3d_get_private_data(&view->private_store, guid, data_size, data);
2325 }
2326
2327 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateData(ID3D11UnorderedAccessView *iface,
2328         REFGUID guid, UINT data_size, const void *data)
2329 {
2330     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2331
2332     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2333
2334     return d3d_set_private_data(&view->private_store, guid, data_size, data);
2335 }
2336
2337 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateDataInterface(ID3D11UnorderedAccessView *iface,
2338         REFGUID guid, const IUnknown *data)
2339 {
2340     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2341
2342     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2343
2344     return d3d_set_private_data_interface(&view->private_store, guid, data);
2345 }
2346
2347 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetResource(ID3D11UnorderedAccessView *iface,
2348         ID3D11Resource **resource)
2349 {
2350     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2351
2352     TRACE("iface %p, resource %p.\n", iface, resource);
2353
2354     ID3D11Resource_AddRef(*resource = view->resource);
2355 }
2356
2357 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDesc(ID3D11UnorderedAccessView *iface,
2358         D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2359 {
2360     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2361
2362     TRACE("iface %p, desc %p.\n", iface, desc);
2363
2364     *desc = view->desc;
2365 }
2366
2367 static const struct ID3D11UnorderedAccessViewVtbl d3d11_unordered_access_view_vtbl =
2368 {
2369     /* IUnknown methods */
2370     d3d11_unordered_access_view_QueryInterface,
2371     d3d11_unordered_access_view_AddRef,
2372     d3d11_unordered_access_view_Release,
2373     /* ID3D11DeviceChild methods */
2374     d3d11_unordered_access_view_GetDevice,
2375     d3d11_unordered_access_view_GetPrivateData,
2376     d3d11_unordered_access_view_SetPrivateData,
2377     d3d11_unordered_access_view_SetPrivateDataInterface,
2378     /* ID3D11View methods */
2379     d3d11_unordered_access_view_GetResource,
2380     /* ID3D11UnorderedAccessView methods */
2381     d3d11_unordered_access_view_GetDesc,
2382 };
2383
2384 static HRESULT wined3d_unordered_access_view_desc_from_d3d11(struct wined3d_unordered_access_view_desc *wined3d_desc,
2385         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2386 {
2387     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2388     wined3d_desc->flags = 0;
2389
2390     switch (desc->ViewDimension)
2391     {
2392         case D3D11_UAV_DIMENSION_BUFFER:
2393             wined3d_desc->flags = desc->u.Buffer.Flags;
2394             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.FirstElement;
2395             wined3d_desc->u.buffer.count = desc->u.Buffer.NumElements;
2396             break;
2397
2398         case D3D11_UAV_DIMENSION_TEXTURE1D:
2399             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
2400             wined3d_desc->u.texture.layer_idx = 0;
2401             wined3d_desc->u.texture.layer_count = 1;
2402             break;
2403
2404         case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
2405             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2406             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
2407             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2408             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2409             break;
2410
2411         case D3D11_UAV_DIMENSION_TEXTURE2D:
2412             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
2413             wined3d_desc->u.texture.layer_idx = 0;
2414             wined3d_desc->u.texture.layer_count = 1;
2415             break;
2416
2417         case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
2418             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2419             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
2420             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2421             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2422             break;
2423
2424         case D3D11_UAV_DIMENSION_TEXTURE3D:
2425             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
2426             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
2427             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
2428             break;
2429
2430         default:
2431             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2432             return E_FAIL;
2433     }
2434
2435     return S_OK;
2436 }
2437
2438 static HRESULT d3d11_unordered_access_view_init(struct d3d11_unordered_access_view *view,
2439         struct d3d_device *device, ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2440 {
2441     struct wined3d_unordered_access_view_desc wined3d_desc;
2442     struct wined3d_resource *wined3d_resource;
2443     HRESULT hr;
2444
2445     view->ID3D11UnorderedAccessView_iface.lpVtbl = &d3d11_unordered_access_view_vtbl;
2446     view->refcount = 1;
2447
2448     if (!desc)
2449     {
2450         hr = set_uav_desc_from_resource(&view->desc, resource);
2451     }
2452     else
2453     {
2454         view->desc = *desc;
2455         hr = normalize_uav_desc(&view->desc, resource);
2456     }
2457     if (FAILED(hr))
2458         return hr;
2459
2460     if (FAILED(hr = wined3d_unordered_access_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2461         return hr;
2462
2463     wined3d_mutex_lock();
2464     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2465     {
2466         wined3d_mutex_unlock();
2467         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2468         return E_FAIL;
2469     }
2470
2471     if (FAILED(hr = wined3d_unordered_access_view_create(&wined3d_desc, wined3d_resource,
2472             view, &d3d_null_wined3d_parent_ops, &view->wined3d_view)))
2473     {
2474         wined3d_mutex_unlock();
2475         WARN("Failed to create wined3d unordered access view, hr %#x.\n", hr);
2476         return hr;
2477     }
2478
2479     wined3d_private_store_init(&view->private_store);
2480     wined3d_mutex_unlock();
2481     ID3D11Resource_AddRef(view->resource = resource);
2482     ID3D11Device_AddRef(view->device = &device->ID3D11Device_iface);
2483
2484     return S_OK;
2485 }
2486
2487 HRESULT d3d11_unordered_access_view_create(struct d3d_device *device, ID3D11Resource *resource,
2488         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, struct d3d11_unordered_access_view **view)
2489 {
2490     struct d3d11_unordered_access_view *object;
2491     HRESULT hr;
2492
2493     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2494         return E_OUTOFMEMORY;
2495
2496     if (FAILED(hr = d3d11_unordered_access_view_init(object, device, resource, desc)))
2497     {
2498         WARN("Failed to initialize unordered access view, hr %#x.\n", hr);
2499         HeapFree(GetProcessHeap(), 0, object);
2500         return hr;
2501     }
2502
2503     TRACE("Created unordered access view %p.\n", object);
2504     *view = object;
2505
2506     return S_OK;
2507 }