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