dlls/d3d11/view.c

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