diff --git a/src/d3d11/d3d11_device.cpp b/src/d3d11/d3d11_device.cpp
index 606b64ec..8d09d885 100644
--- a/src/d3d11/d3d11_device.cpp
+++ b/src/d3d11/d3d11_device.cpp
@@ -238,13 +238,13 @@ namespace dxvk {
     
     // The description is optional. If omitted, we'll create
     // a view that covers all subresources of the image.
-    D3D11_SHADER_RESOURCE_VIEW_DESC desc;
+    D3D11_SHADER_RESOURCE_VIEW_DESC1 desc;
     
     if (pDesc == nullptr) {
       if (FAILED(D3D11ShaderResourceView::GetDescFromResource(pResource, &desc)))
         return E_INVALIDARG;
     } else {
-      desc = *pDesc;
+      desc = D3D11ShaderResourceView::PromoteDesc(pDesc);
       
       if (FAILED(D3D11ShaderResourceView::NormalizeDesc(pResource, &desc)))
         return E_INVALIDARG;
diff --git a/src/d3d11/d3d11_view_srv.cpp b/src/d3d11/d3d11_view_srv.cpp
index 5d6875c8..c1155474 100644
--- a/src/d3d11/d3d11_view_srv.cpp
+++ b/src/d3d11/d3d11_view_srv.cpp
@@ -9,7 +9,7 @@ namespace dxvk {
   D3D11ShaderResourceView::D3D11ShaderResourceView(
           D3D11Device*                      pDevice,
           ID3D11Resource*                   pResource,
-    const D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc)
+    const D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc)
   : m_device(pDevice), m_resource(pResource), m_desc(*pDesc), m_d3d10(this) {
     ResourceAddRefPrivate(m_resource);
 
@@ -191,7 +191,8 @@ namespace dxvk {
     if (riid == __uuidof(IUnknown)
      || riid == __uuidof(ID3D11DeviceChild)
      || riid == __uuidof(ID3D11View)
-     || riid == __uuidof(ID3D11ShaderResourceView)) {
+     || riid == __uuidof(ID3D11ShaderResourceView)
+     || riid == __uuidof(ID3D11ShaderResourceView1)) {
       *ppvObject = ref(this);
       return S_OK;
     }
@@ -221,13 +222,72 @@ namespace dxvk {
   
   
   void STDMETHODCALLTYPE D3D11ShaderResourceView::GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) {
+    pDesc->Format            = m_desc.Format;
+    pDesc->ViewDimension     = m_desc.ViewDimension;
+
+    switch (m_desc.ViewDimension) {
+      case D3D11_SRV_DIMENSION_UNKNOWN:
+        break;
+
+      case D3D11_SRV_DIMENSION_BUFFER:
+        pDesc->Buffer = m_desc.Buffer;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE1D:
+        pDesc->Texture1D = m_desc.Texture1D;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
+        pDesc->Texture1DArray = m_desc.Texture1DArray;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2D:
+        pDesc->Texture2D.MostDetailedMip = m_desc.Texture2D.MostDetailedMip;
+        pDesc->Texture2D.MipLevels       = m_desc.Texture2D.MipLevels;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
+        pDesc->Texture2DArray.MostDetailedMip = m_desc.Texture2DArray.MostDetailedMip;
+        pDesc->Texture2DArray.MipLevels       = m_desc.Texture2DArray.MipLevels;
+        pDesc->Texture2DArray.FirstArraySlice = m_desc.Texture2DArray.FirstArraySlice;
+        pDesc->Texture2DArray.ArraySize       = m_desc.Texture2DArray.ArraySize;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2DMS:
+        pDesc->Texture2DMS = m_desc.Texture2DMS;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
+        pDesc->Texture2DMSArray = m_desc.Texture2DMSArray;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE3D:
+        pDesc->Texture3D = m_desc.Texture3D;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURECUBE:
+        pDesc->TextureCube = m_desc.TextureCube;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
+        pDesc->TextureCubeArray = m_desc.TextureCubeArray;
+        break;
+
+      case D3D11_SRV_DIMENSION_BUFFEREX:
+        pDesc->BufferEx = m_desc.BufferEx;
+        break;
+    }
+  }
+  
+  
+  void STDMETHODCALLTYPE D3D11ShaderResourceView::GetDesc1(D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc) {
     *pDesc = m_desc;
   }
   
   
   HRESULT D3D11ShaderResourceView::GetDescFromResource(
           ID3D11Resource*                   pResource,
-          D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc) {
+          D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc) {
     D3D11_RESOURCE_DIMENSION resourceDim = D3D11_RESOURCE_DIMENSION_UNKNOWN;
     pResource->GetType(&resourceDim);
     
@@ -275,12 +335,14 @@ namespace dxvk {
             pDesc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
             pDesc->Texture2D.MostDetailedMip = 0;
             pDesc->Texture2D.MipLevels       = resourceDesc.MipLevels;
+            pDesc->Texture2D.PlaneSlice      = 0;
           } else {
             pDesc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
             pDesc->Texture2DArray.MostDetailedMip = 0;
             pDesc->Texture2DArray.MipLevels       = resourceDesc.MipLevels;
             pDesc->Texture2DArray.FirstArraySlice = 0;
             pDesc->Texture2DArray.ArraySize       = resourceDesc.ArraySize;
+            pDesc->Texture2DArray.PlaneSlice      = 0;
           }
         } else {
           if (resourceDesc.ArraySize == 1) {
@@ -312,9 +374,74 @@ namespace dxvk {
   }
   
   
+  D3D11_SHADER_RESOURCE_VIEW_DESC1 D3D11ShaderResourceView::PromoteDesc(
+    const D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc) {
+    D3D11_SHADER_RESOURCE_VIEW_DESC1 dstDesc;
+    dstDesc.Format            = pDesc->Format;
+    dstDesc.ViewDimension     = pDesc->ViewDimension;
+
+    switch (pDesc->ViewDimension) {
+      case D3D11_SRV_DIMENSION_UNKNOWN:
+        break;
+
+      case D3D11_SRV_DIMENSION_BUFFER:
+        dstDesc.Buffer = pDesc->Buffer;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE1D:
+        dstDesc.Texture1D = pDesc->Texture1D;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
+        dstDesc.Texture1DArray = pDesc->Texture1DArray;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2D:
+        dstDesc.Texture2D.MostDetailedMip = pDesc->Texture2D.MostDetailedMip;
+        dstDesc.Texture2D.MipLevels       = pDesc->Texture2D.MipLevels;
+        dstDesc.Texture2D.PlaneSlice      = 0;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
+        dstDesc.Texture2DArray.MostDetailedMip = pDesc->Texture2DArray.MostDetailedMip;
+        dstDesc.Texture2DArray.MipLevels       = pDesc->Texture2DArray.MipLevels;
+        dstDesc.Texture2DArray.FirstArraySlice = pDesc->Texture2DArray.FirstArraySlice;
+        dstDesc.Texture2DArray.ArraySize       = pDesc->Texture2DArray.ArraySize;
+        dstDesc.Texture2DArray.PlaneSlice      = 0;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2DMS:
+        dstDesc.Texture2DMS = pDesc->Texture2DMS;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
+        dstDesc.Texture2DMSArray = pDesc->Texture2DMSArray;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURE3D:
+        dstDesc.Texture3D = pDesc->Texture3D;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURECUBE:
+        dstDesc.TextureCube = pDesc->TextureCube;
+        break;
+
+      case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
+        dstDesc.TextureCubeArray = pDesc->TextureCubeArray;
+        break;
+
+      case D3D11_SRV_DIMENSION_BUFFEREX:
+        dstDesc.BufferEx = pDesc->BufferEx;
+        break;
+    }
+
+    return dstDesc;
+  }
+
+
   HRESULT D3D11ShaderResourceView::NormalizeDesc(
           ID3D11Resource*                   pResource,
-          D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc) {
+          D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc) {
     D3D11_RESOURCE_DIMENSION resourceDim = D3D11_RESOURCE_DIMENSION_UNKNOWN;
     pResource->GetType(&resourceDim);
     
@@ -412,6 +539,9 @@ namespace dxvk {
       case D3D11_SRV_DIMENSION_TEXTURE2D:
         if (pDesc->Texture2D.MipLevels > mipLevels - pDesc->Texture2D.MostDetailedMip)
           pDesc->Texture2D.MipLevels = mipLevels - pDesc->Texture2D.MostDetailedMip;
+        
+        if (pDesc->Texture2D.PlaneSlice != 0)
+          return E_INVALIDARG;
         break;
       
       case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
@@ -419,6 +549,9 @@ namespace dxvk {
           pDesc->Texture2DArray.MipLevels = mipLevels - pDesc->Texture2DArray.MostDetailedMip;
         if (pDesc->Texture2DArray.ArraySize > numLayers - pDesc->Texture2DArray.FirstArraySlice)
           pDesc->Texture2DArray.ArraySize = numLayers - pDesc->Texture2DArray.FirstArraySlice;
+        
+        if (pDesc->Texture2DArray.PlaneSlice != 0)
+          return E_INVALIDARG;
         break;
       
       case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
diff --git a/src/d3d11/d3d11_view_srv.h b/src/d3d11/d3d11_view_srv.h
index fc24718e..62fbbb77 100644
--- a/src/d3d11/d3d11_view_srv.h
+++ b/src/d3d11/d3d11_view_srv.h
@@ -14,14 +14,14 @@ namespace dxvk {
   /**
    * \brief Shader resource view
    */
-  class D3D11ShaderResourceView : public D3D11DeviceChild<ID3D11ShaderResourceView> {
+  class D3D11ShaderResourceView : public D3D11DeviceChild<ID3D11ShaderResourceView1> {
     
   public:
     
     D3D11ShaderResourceView(
             D3D11Device*                      pDevice,
             ID3D11Resource*                   pResource,
-      const D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc);
+      const D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc);
     
     ~D3D11ShaderResourceView();
     
@@ -32,6 +32,8 @@ namespace dxvk {
     void STDMETHODCALLTYPE GetResource(ID3D11Resource** ppResource) final;
     
     void STDMETHODCALLTYPE GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) final;
+
+    void STDMETHODCALLTYPE GetDesc1(D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc) final;
     
     const D3D11_VK_VIEW_INFO& GetViewInfo() const {
       return m_info;
@@ -67,17 +69,20 @@ namespace dxvk {
     
     static HRESULT GetDescFromResource(
             ID3D11Resource*                   pResource,
-            D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc);
+            D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc);
+    
+    static D3D11_SHADER_RESOURCE_VIEW_DESC1 PromoteDesc(
+      const D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc);
     
     static HRESULT NormalizeDesc(
             ID3D11Resource*                   pResource,
-            D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc);
+            D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc);
     
   private:
     
     Com<D3D11Device>                  m_device;
     ID3D11Resource*                   m_resource;
-    D3D11_SHADER_RESOURCE_VIEW_DESC   m_desc;
+    D3D11_SHADER_RESOURCE_VIEW_DESC1  m_desc;
     D3D11_VK_VIEW_INFO                m_info;
     Rc<DxvkBufferView>                m_bufferView;
     Rc<DxvkImageView>                 m_imageView;