Create SharedTextureMemory from D3D12 resource

Adds support for creating SharedTextureMemory from a D3D12Resource
without the need for a shared handle - through a new
SharedTextureMemoryD3D12ResourceDescriptor.

Change-Id: Ib9ad171eb1e0892c11dbe1524d7dce792dfdc92c
Bug: 425864542
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/268055
Reviewed-by: Rafael Cintron <[email protected]>
Commit-Queue: Sahir Vellani <[email protected]>
Reviewed-by: Kai Ninomiya <[email protected]>

Author: Sahir Vellani

include/dawn/native/D3D12Backend.h

@@ -86,6 +86,17 @@ struct DAWN_NATIVE_EXPORT SharedBufferMemoryD3D12SharedMemoryFileHandleDescripto
     constexpr static uint32_t kRequiredAlignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
 };
 
+// May be chained on SharedTextureMemoryDescriptor.
+struct DAWN_NATIVE_EXPORT SharedTextureMemoryD3D12ResourceDescriptor : wgpu::ChainedStruct {
+    SharedTextureMemoryD3D12ResourceDescriptor() {
+        sType = static_cast<wgpu::SType>(WGPUSType_SharedTextureMemoryD3D12ResourceDescriptor);
+    }
+
+    // This ID3D12Resource object must be created from the same ID3D12Device used in the
+    // WGPUDevice.
+    Microsoft::WRL::ComPtr<ID3D12Resource> resource;
+};
+
 }  // namespace dawn::native::d3d12
 
 #endif  // INCLUDE_DAWN_NATIVE_D3D12BACKEND_H_

src/dawn/dawn.json

@@ -2453,7 +2453,8 @@
             {"value": 57, "name": "dawn device allocator control", "tags": ["dawn"]},
             {"value": 58, "name": "chromium experimental bindless", "tags": ["dawn"]},
             {"value": 59, "name": "adapter properties WGPU", "tags": ["dawn"]},
-            {"value": 60, "name": "shared buffer memory D3D12 shared memory file mapping handle", "tags": ["dawn"]}
+            {"value": 60, "name": "shared buffer memory D3D12 shared memory file mapping handle", "tags": ["dawn"]},
+            {"value": 61, "name": "shared texture memory D3D12 resource", "tags": ["dawn", "native"]}
         ]
     },
     "filter mode": {
@@ -3973,7 +3974,9 @@
             {"value": 77, "name": "texel buffer binding layout", "tags": ["dawn"]},
             {"value": 78, "name": "shared texture memory metal end access state", "tags": ["dawn", "native"]},
             {"value": 79, "name": "adapter properties WGPU", "tags": ["dawn"]},
-            {"value": 80, "name": "shared buffer memory D3D12 shared memory file mapping handle descriptor", "tags": ["dawn", "native"]}
+            {"value": 80, "name": "shared buffer memory D3D12 shared memory file mapping handle descriptor", "tags": ["dawn", "native"]},
+            {"value": 81, "name": "shared texture memory D3D12 resource descriptor", "tags": ["dawn", "native"]}
+
         ]
     },
     "texture": {

src/dawn/native/ChainUtilsImpl.inl

@@ -44,6 +44,7 @@ struct SharedTextureMemoryD3D11Texture2DDescriptor;
 namespace d3d12 {
 struct SharedBufferMemoryD3D12ResourceDescriptor;
 struct SharedBufferMemoryD3D12SharedMemoryFileHandleDescriptor;
+struct SharedTextureMemoryD3D12ResourceDescriptor;
 }
 
 namespace opengl {
@@ -88,10 +89,15 @@ template <>
 constexpr inline wgpu::SType STypeForImpl<d3d11::SharedTextureMemoryD3D11Texture2DDescriptor> =
     wgpu::SType(WGPUSType_SharedTextureMemoryD3D11Texture2DDescriptor);
 
+template <>
+constexpr inline wgpu::SType STypeForImpl<d3d12::SharedTextureMemoryD3D12ResourceDescriptor> =
+    wgpu::SType(WGPUSType_SharedTextureMemoryD3D12ResourceDescriptor);
+
 template <>
 struct AdditionalExtensions<SharedTextureMemoryDescriptor> {
     using List =
-        AdditionalExtensionsList<const d3d11::SharedTextureMemoryD3D11Texture2DDescriptor*>;
+        AdditionalExtensionsList<const d3d11::SharedTextureMemoryD3D11Texture2DDescriptor*,
+                                  const d3d12::SharedTextureMemoryD3D12ResourceDescriptor*>;
 };
 
 template <>

src/dawn/native/Features.cpp

@@ -442,6 +442,10 @@ static constexpr FeatureEnumAndInfo kFeatureInfo[] = {
     {Feature::SharedBufferMemoryD3D12SharedMemoryFileMappingHandle,
      {"Supports importing a shared memory file mapping handle as shared buffer memory.",
       "https://dawn.googlesource.com/dawn/+/refs/heads/main/docs/dawn/features/shared_buffer.md",
+      FeatureInfo::FeatureState::Experimental}},
+    {Feature::SharedTextureMemoryD3D12Resource,
+     {"Support importing ID3D12Resource as shared texture memory.",
+      "https://dawn.googlesource.com/dawn/+/refs/heads/main/docs/dawn/features/shared_texture.md",
       FeatureInfo::FeatureState::Experimental}}};
 
 }  // anonymous namespace

src/dawn/native/d3d12/DeviceD3D12.cpp

@@ -491,7 +491,8 @@ ResultOrError<Ref<SharedTextureMemoryBase>> Device::ImportSharedTextureMemoryImp
 
     wgpu::SType type;
     DAWN_TRY_ASSIGN(
-        type, (unpacked.ValidateBranches<Branch<SharedTextureMemoryDXGISharedHandleDescriptor>>()));
+        type, (unpacked.ValidateBranches<Branch<SharedTextureMemoryDXGISharedHandleDescriptor>,
+                                         Branch<SharedTextureMemoryD3D12ResourceDescriptor>>()));
 
     switch (type) {
         case wgpu::SType::SharedTextureMemoryDXGISharedHandleDescriptor:
@@ -501,6 +502,13 @@ ResultOrError<Ref<SharedTextureMemoryBase>> Device::ImportSharedTextureMemoryImp
             return SharedTextureMemory::Create(
                 this, descriptor->label,
                 unpacked.Get<SharedTextureMemoryDXGISharedHandleDescriptor>());
+        case wgpu::SType::SharedTextureMemoryD3D12ResourceDescriptor:
+            DAWN_INVALID_IF(!HasFeature(Feature::SharedTextureMemoryD3D12Resource),
+                            "%s is not enabled.",
+                            wgpu::FeatureName::SharedTextureMemoryD3D12Resource);
+            return SharedTextureMemory::Create(
+                this, descriptor->label,
+                unpacked.Get<SharedTextureMemoryD3D12ResourceDescriptor>());
         default:
             DAWN_UNREACHABLE();
     }

src/dawn/native/d3d12/PhysicalDeviceD3D12.cpp

@@ -212,6 +212,7 @@ void PhysicalDevice::InitializeSupportedFeaturesImpl() {
     }
 
     EnableFeature(Feature::SharedTextureMemoryDXGISharedHandle);
+    EnableFeature(Feature::SharedTextureMemoryD3D12Resource);
     EnableFeature(Feature::SharedFenceDXGISharedHandle);
 
     if (SupportsBufferMapExtendedUsages()) {

src/dawn/native/d3d12/SharedTextureMemoryD3D12.cpp

@@ -30,6 +30,7 @@
 #include <utility>
 
 #include "dawn/native/ChainUtils.h"
+#include "dawn/native/D3D12Backend.h"
 #include "dawn/native/d3d/D3DError.h"
 #include "dawn/native/d3d/KeyedMutex.h"
 #include "dawn/native/d3d/UtilsD3D.h"
@@ -49,7 +50,35 @@ ResultOrError<Ref<SharedTextureMemory>> SharedTextureMemory::Create(
     Ref<d3d::KeyedMutex> keyedMutex;
     DAWN_TRY(device->ImportSharedHandleResource(descriptor->handle, descriptor->useKeyedMutex,
                                                 d3d12Resource, keyedMutex));
+    return CreateSharedTextureMemoryFromD3D12Resource(device, label, d3d12Resource, keyedMutex);
+}
+
+// static
+ResultOrError<Ref<SharedTextureMemory>> SharedTextureMemory::Create(
+    Device* device,
+    StringView label,
+    const SharedTextureMemoryD3D12ResourceDescriptor* descriptor) {
+    DAWN_INVALID_IF(descriptor->resource == nullptr, "D3D12Resource is missing.");
+    ComPtr<ID3D12Resource> d3d12Resource = descriptor->resource;
+    return CreateSharedTextureMemoryFromD3D12Resource(device, label, d3d12Resource, nullptr);
+}
+
+SharedTextureMemory::SharedTextureMemory(Device* device,
+                                         StringView label,
+                                         SharedTextureMemoryProperties properties,
+                                         ComPtr<ID3D12Resource> resource,
+                                         Ref<d3d::KeyedMutex> keyedMutex)
+    : d3d::SharedTextureMemory(device, label, properties),
+      mResource(std::move(resource)),
+      mKeyedMutex(std::move(keyedMutex)) {}
 
+// static
+ResultOrError<Ref<SharedTextureMemory>>
+SharedTextureMemory::CreateSharedTextureMemoryFromD3D12Resource(
+    Device* device,
+    StringView label,
+    ComPtr<ID3D12Resource> d3d12Resource,
+    Ref<d3d::KeyedMutex> keyedMutex) {
     D3D12_RESOURCE_DESC desc = d3d12Resource->GetDesc();
     DAWN_INVALID_IF(desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D,
                     "Resource dimension (%d) was not Texture2D", desc.Dimension);
@@ -98,15 +127,6 @@ ResultOrError<Ref<SharedTextureMemory>> SharedTextureMemory::Create(
     return result;
 }
 
-SharedTextureMemory::SharedTextureMemory(Device* device,
-                                         StringView label,
-                                         SharedTextureMemoryProperties properties,
-                                         ComPtr<ID3D12Resource> resource,
-                                         Ref<d3d::KeyedMutex> keyedMutex)
-    : d3d::SharedTextureMemory(device, label, properties),
-      mResource(std::move(resource)),
-      mKeyedMutex(std::move(keyedMutex)) {}
-
 void SharedTextureMemory::DestroyImpl() {
     ToBackend(GetDevice())->ReferenceUntilUnused(std::move(mResource));
     mKeyedMutex = nullptr;

src/dawn/native/d3d12/SharedTextureMemoryD3D12.h

@@ -39,6 +39,7 @@ class KeyedMutex;
 
 namespace d3d12 {
 class Device;
+struct SharedTextureMemoryD3D12ResourceDescriptor;
 
 class SharedTextureMemory final : public d3d::SharedTextureMemory {
   public:
@@ -47,6 +48,11 @@ class SharedTextureMemory final : public d3d::SharedTextureMemory {
         StringView label,
         const SharedTextureMemoryDXGISharedHandleDescriptor* descriptor);
 
+    static ResultOrError<Ref<SharedTextureMemory>> Create(
+        Device* device,
+        StringView label,
+        const SharedTextureMemoryD3D12ResourceDescriptor* descriptor);
+
     ID3D12Resource* GetD3DResource() const;
 
     d3d::KeyedMutex* GetKeyedMutex() const;
@@ -58,6 +64,12 @@ class SharedTextureMemory final : public d3d::SharedTextureMemory {
                         ComPtr<ID3D12Resource> resource,
                         Ref<d3d::KeyedMutex> keyedMutex);
 
+    static ResultOrError<Ref<SharedTextureMemory>> CreateSharedTextureMemoryFromD3D12Resource(
+        Device* device,
+        StringView label,
+        ComPtr<ID3D12Resource> d3d12Resource,
+        Ref<d3d::KeyedMutex> keyedMutex);
+
     void DestroyImpl() override;
 
     ResultOrError<Ref<TextureBase>> CreateTextureImpl(

src/dawn/node/binding/Converter.cpp

@@ -1752,6 +1752,7 @@ bool Converter::Convert(interop::GPUFeatureName& out, wgpu::FeatureName in) {
         case wgpu::FeatureName::ChromiumExperimentalBindless:
         case wgpu::FeatureName::AdapterPropertiesWGPU:
         case wgpu::FeatureName::SharedBufferMemoryD3D12SharedMemoryFileMappingHandle:
+        case wgpu::FeatureName::SharedTextureMemoryD3D12Resource:
             return false;
     }
     return false;

src/dawn/tests/BUILD.gn

@@ -834,6 +834,7 @@ source_set("white_box_tests_sources") {
     sources += [
       "white_box/SharedBufferMemoryTests_win.cpp",
       "white_box/SharedTextureMemoryTests_win.cpp",
+      "white_box/SharedTextureMemoryTests_win_d3d12.cpp",
     ]
   }