Do not pass EngineCI do device context constructors

TheMostDiligent · TheMostDiligent · commit 70bdd5bb8a56 · 2025-02-21T11:59:41.000-08:00
diff --git a/Graphics/GraphicsEngineD3D11/include/DeviceContextD3D11Impl.hpp b/Graphics/GraphicsEngineD3D11/include/DeviceContextD3D11Impl.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -54,12 +54,11 @@ class DeviceContextD3D11Impl final : public DeviceContextBase<EngineD3D11ImplTra
 public:
     using TDeviceContextBase = DeviceContextBase<EngineD3D11ImplTraits>;
 
-    DeviceContextD3D11Impl(IReferenceCounters*          pRefCounters,
-                           IMemoryAllocator&            Allocator,
-                           RenderDeviceD3D11Impl*       pDevice,
-                           ID3D11DeviceContext1*        pd3d11DeviceContext,
-                           const EngineD3D11CreateInfo& EngineCI,
-                           const DeviceContextDesc&     Desc);
+    DeviceContextD3D11Impl(IReferenceCounters*      pRefCounters,
+                           IMemoryAllocator&        Allocator,
+                           RenderDeviceD3D11Impl*   pDevice,
+                           ID3D11DeviceContext1*    pd3d11DeviceContext,
+                           const DeviceContextDesc& Desc);
     virtual void DILIGENT_CALL_TYPE QueryInterface(const INTERFACE_ID& IID, IObject** ppInterface) override final;
 
     /// Implementation of IDeviceContext::Begin() in Direct3D11 backend.
diff --git a/Graphics/GraphicsEngineD3D11/include/RenderDeviceD3D11Impl.hpp b/Graphics/GraphicsEngineD3D11/include/RenderDeviceD3D11Impl.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -190,9 +190,19 @@ class RenderDeviceD3D11Impl final : public RenderDeviceD3DBase<EngineD3D11ImplTr
 #endif
 #undef GET_D3D11_DEVICE
 
+    struct Properties
+    {
+        D3D11_VALIDATION_FLAGS D3D11ValidationFlags = D3D11_VALIDATION_FLAG_NONE;
+    };
+
+    const Properties& GetProperties() const { return m_Properties; }
+
 private:
     virtual void TestTextureFormat(TEXTURE_FORMAT TexFormat) override final;
 
+private:
+    const Properties m_Properties;
+
     /// D3D11 device
     CComPtr<ID3D11Device> m_pd3d11Device;
 
diff --git a/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp
@@ -47,12 +47,11 @@
 namespace Diligent
 {
 
-DeviceContextD3D11Impl::DeviceContextD3D11Impl(IReferenceCounters*          pRefCounters,
-                                               IMemoryAllocator&            Allocator,
-                                               RenderDeviceD3D11Impl*       pDevice,
-                                               ID3D11DeviceContext1*        pd3d11DeviceContext,
-                                               const EngineD3D11CreateInfo& EngineCI,
-                                               const DeviceContextDesc&     Desc) :
+DeviceContextD3D11Impl::DeviceContextD3D11Impl(IReferenceCounters*      pRefCounters,
+                                               IMemoryAllocator&        Allocator,
+                                               RenderDeviceD3D11Impl*   pDevice,
+                                               ID3D11DeviceContext1*    pd3d11DeviceContext,
+                                               const DeviceContextDesc& Desc) :
     // clang-format off
     TDeviceContextBase
     {
@@ -62,7 +61,7 @@ DeviceContextD3D11Impl::DeviceContextD3D11Impl(IReferenceCounters*          pRef
     },
     m_pd3d11DeviceContext {pd3d11DeviceContext          },
 #ifdef DILIGENT_DEVELOPMENT
-    m_D3D11ValidationFlags{EngineCI.D3D11ValidationFlags},
+    m_D3D11ValidationFlags{pDevice->GetProperties().D3D11ValidationFlags},
 #endif
     m_CmdListAllocator    {GetRawAllocator(), sizeof(CommandListD3D11Impl), 64}
 // clang-format on
diff --git a/Graphics/GraphicsEngineD3D11/src/EngineFactoryD3D11.cpp b/Graphics/GraphicsEngineD3D11/src/EngineFactoryD3D11.cpp
@@ -389,7 +389,7 @@ void EngineFactoryD3D11Impl::AttachToD3D11Device(void*                        pd
 
         RefCntAutoPtr<DeviceContextD3D11Impl> pDeviceContextD3D11{
             NEW_RC_OBJ(RawAllocator, "DeviceContextD3D11Impl instance", DeviceContextD3D11Impl)(
-                RawAllocator, pRenderDeviceD3D11, pd3d11ImmediateCtx1, EngineCI,
+                RawAllocator, pRenderDeviceD3D11, pd3d11ImmediateCtx1,
                 DeviceContextDesc{
                     EngineCI.pImmediateContextInfo ? EngineCI.pImmediateContextInfo[0].Name : nullptr,
                     pRenderDeviceD3D11->GetAdapterInfo().Queues[0].QueueType,
@@ -416,7 +416,7 @@ void EngineFactoryD3D11Impl::AttachToD3D11Device(void*                        pd
 
             RefCntAutoPtr<DeviceContextD3D11Impl> pDeferredCtxD3D11{
                 NEW_RC_OBJ(RawAllocator, "DeviceContextD3D11Impl instance", DeviceContextD3D11Impl)(
-                    RawAllocator, pRenderDeviceD3D11, pd3d11DeferredCtx1, EngineCI,
+                    RawAllocator, pRenderDeviceD3D11, pd3d11DeferredCtx1,
                     DeviceContextDesc{
                         nullptr,
                         COMMAND_QUEUE_TYPE_UNKNOWN,
diff --git a/Graphics/GraphicsEngineD3D11/src/RenderDeviceD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/RenderDeviceD3D11Impl.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -74,6 +74,10 @@ RenderDeviceD3D11Impl::RenderDeviceD3D11Impl(IReferenceCounters*          pRefCo
         EngineCI,
         AdapterInfo
     },
+    m_Properties
+    {
+        EngineCI.D3D11ValidationFlags,
+    },
     m_pd3d11Device{pd3d11Device}
 // clang-format on
 {
@@ -135,13 +139,14 @@ RenderDeviceD3D11Impl::~RenderDeviceD3D11Impl()
 
 void RenderDeviceD3D11Impl::TestTextureFormat(TEXTURE_FORMAT TexFormat)
 {
-    auto& TexFormatInfo = m_TextureFormatsInfo[TexFormat];
+    TextureFormatInfoExt& TexFormatInfo = m_TextureFormatsInfo[TexFormat];
     VERIFY(TexFormatInfo.Supported, "Texture format is not supported");
 
-    auto DXGIFormat = TexFormatToDXGI_Format(TexFormat);
+    DXGI_FORMAT DXGIFormat = TexFormatToDXGI_Format(TexFormat);
 
     UINT FormatSupport = 0;
-    auto hr            = m_pd3d11Device->CheckFormatSupport(DXGIFormat, &FormatSupport);
+
+    HRESULT hr = m_pd3d11Device->CheckFormatSupport(DXGIFormat, &FormatSupport);
     if (FAILED(hr))
     {
         LOG_ERROR_MESSAGE("CheckFormatSupport() failed for format ", DXGIFormat);
@@ -388,7 +393,7 @@ void RenderDeviceD3D11Impl::IdleGPU()
 {
     VERIFY_EXPR(m_wpImmediateContexts.size() == 1);
 
-    if (auto pImmediateCtx = m_wpImmediateContexts[0].Lock())
+    if (RefCntAutoPtr<DeviceContextD3D11Impl> pImmediateCtx = m_wpImmediateContexts[0].Lock())
     {
         pImmediateCtx->WaitForIdle();
     }
diff --git a/Graphics/GraphicsEngineD3D12/include/DeviceContextD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/DeviceContextD3D12Impl.hpp
@@ -61,10 +61,9 @@ class DeviceContextD3D12Impl final : public DeviceContextNextGenBase<EngineD3D12
 public:
     using TDeviceContextBase = DeviceContextNextGenBase<EngineD3D12ImplTraits>;
 
-    DeviceContextD3D12Impl(IReferenceCounters*          pRefCounters,
-                           RenderDeviceD3D12Impl*       pDevice,
-                           const EngineD3D12CreateInfo& EngineCI,
-                           const DeviceContextDesc&     Desc);
+    DeviceContextD3D12Impl(IReferenceCounters*      pRefCounters,
+                           RenderDeviceD3D12Impl*   pDevice,
+                           const DeviceContextDesc& Desc);
     ~DeviceContextD3D12Impl();
 
     IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_DeviceContextD3D12, TDeviceContextBase)
diff --git a/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -34,6 +34,7 @@
 #include <vector>
 #include <memory>
 #include <unordered_map>
+#include <array>
 
 #include "EngineD3D12ImplTraits.hpp"
 #include "RenderDeviceD3DBase.hpp"
@@ -275,13 +276,25 @@ class RenderDeviceD3D12Impl final : public RenderDeviceNextGenBase<RenderDeviceD
         return m_pNVApiHeap;
     }
 
+    struct Properties
+    {
+        Uint32 DynamicHeapPageSize = 0;
+
+        std::array<Uint32, _countof(EngineD3D12CreateInfo::DynamicDescriptorAllocationChunkSize)> DynamicDescriptorAllocationChunkSize = {};
+    };
+
+    const Properties& GetProperties() const { return m_Properties; }
+
 private:
     virtual void TestTextureFormat(TEXTURE_FORMAT TexFormat) override final;
     void         FreeCommandContext(PooledCommandContext&& Ctx);
 
     CommandListManager& GetCmdListManager(SoftwareQueueIndex CommandQueueId);
     CommandListManager& GetCmdListManager(D3D12_COMMAND_LIST_TYPE CmdListType);
 
+private:
+    const Properties m_Properties;
+
     CComPtr<ID3D12Device> m_pd3d12Device;
 
     CPUDescriptorHeap m_CPUDescriptorHeaps[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES];
diff --git a/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
@@ -65,10 +65,9 @@ static std::string GetContextObjectName(const char* Object, bool bIsDeferred, Ui
     return ss.str();
 }
 
-DeviceContextD3D12Impl::DeviceContextD3D12Impl(IReferenceCounters*          pRefCounters,
-                                               RenderDeviceD3D12Impl*       pDeviceD3D12Impl,
-                                               const EngineD3D12CreateInfo& EngineCI,
-                                               const DeviceContextDesc&     Desc) :
+DeviceContextD3D12Impl::DeviceContextD3D12Impl(IReferenceCounters*      pRefCounters,
+                                               RenderDeviceD3D12Impl*   pDeviceD3D12Impl,
+                                               const DeviceContextDesc& Desc) :
     // clang-format off
     TDeviceContextBase
     {
@@ -80,39 +79,39 @@ DeviceContextD3D12Impl::DeviceContextD3D12Impl(IReferenceCounters*          pRef
     {
         pDeviceD3D12Impl->GetDynamicMemoryManager(),
         GetContextObjectName("Dynamic heap", Desc.IsDeferred, Desc.ContextId),
-        EngineCI.DynamicHeapPageSize
+        pDeviceD3D12Impl->GetProperties().DynamicHeapPageSize
     },
     m_DynamicGPUDescriptorAllocator
     {
         {
             GetRawAllocator(),
             pDeviceD3D12Impl->GetGPUDescriptorHeap(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV),
-            EngineCI.DynamicDescriptorAllocationChunkSize[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV],
+            pDeviceD3D12Impl->GetProperties().DynamicDescriptorAllocationChunkSize[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV],
             GetContextObjectName("CBV_SRV_UAV dynamic descriptor allocator", Desc.IsDeferred, Desc.ContextId)
         },
         {
             GetRawAllocator(),
             pDeviceD3D12Impl->GetGPUDescriptorHeap(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER),
-            EngineCI.DynamicDescriptorAllocationChunkSize[D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER],
+            pDeviceD3D12Impl->GetProperties().DynamicDescriptorAllocationChunkSize[D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER],
             GetContextObjectName("SAMPLER     dynamic descriptor allocator", Desc.IsDeferred, Desc.ContextId)
         }
     },
     m_CmdListAllocator{GetRawAllocator(), sizeof(CommandListD3D12Impl), 64},
     m_NullRTV{pDeviceD3D12Impl->AllocateDescriptors(D3D12_DESCRIPTOR_HEAP_TYPE_RTV, 1)}
 // clang-format on
 {
-    auto* pd3d12Device = pDeviceD3D12Impl->GetD3D12Device();
+    ID3D12Device* pd3d12Device = pDeviceD3D12Impl->GetD3D12Device();
     if (!IsDeferred())
     {
         RequestCommandContext();
         m_QueryMgr = &pDeviceD3D12Impl->GetQueryMgr(GetCommandQueueId());
     }
 
-    auto* pDrawIndirectSignature = GetDrawIndirectSignature(sizeof(UINT) * 4);
+    ID3D12CommandSignature* pDrawIndirectSignature = GetDrawIndirectSignature(sizeof(UINT) * 4);
     if (pDrawIndirectSignature == nullptr)
         LOG_ERROR_AND_THROW("Failed to create indirect draw command signature");
 
-    auto* pDrawIndexedIndirectSignature = GetDrawIndexedIndirectSignature(sizeof(UINT) * 5);
+    ID3D12CommandSignature* pDrawIndexedIndirectSignature = GetDrawIndexedIndirectSignature(sizeof(UINT) * 5);
     if (pDrawIndexedIndirectSignature == nullptr)
         LOG_ERROR_AND_THROW("Failed to create draw indexed indirect command signature");
 
@@ -125,7 +124,7 @@ DeviceContextD3D12Impl::DeviceContextD3D12Impl(IReferenceCounters*          pRef
 
     CmdSignatureDesc.ByteStride = sizeof(UINT) * 3;
     IndirectArg.Type            = D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH;
-    auto hr                     = pd3d12Device->CreateCommandSignature(&CmdSignatureDesc, nullptr, __uuidof(m_pDispatchIndirectSignature), reinterpret_cast<void**>(static_cast<ID3D12CommandSignature**>(&m_pDispatchIndirectSignature)));
+    HRESULT hr                  = pd3d12Device->CreateCommandSignature(&CmdSignatureDesc, nullptr, __uuidof(m_pDispatchIndirectSignature), reinterpret_cast<void**>(static_cast<ID3D12CommandSignature**>(&m_pDispatchIndirectSignature)));
     CHECK_D3D_RESULT_THROW(hr, "Failed to create dispatch indirect command signature");
 
 #ifdef D3D12_H_HAS_MESH_SHADER
diff --git a/Graphics/GraphicsEngineD3D12/src/EngineFactoryD3D12.cpp b/Graphics/GraphicsEngineD3D12/src/EngineFactoryD3D12.cpp
@@ -623,7 +623,6 @@ void EngineFactoryD3D12Impl::AttachToD3D12Device(void*                        pd
             RefCntAutoPtr<DeviceContextD3D12Impl> pImmediateCtxD3D12{
                 NEW_RC_OBJ(RawMemAllocator, "DeviceContextD3D12Impl instance", DeviceContextD3D12Impl)(
                     pRenderDeviceD3D12,
-                    EngineCI,
                     DeviceContextDesc{
                         pImmediateContextInfo[CtxInd].Name,
                         AdapterInfo.Queues[QueueId].QueueType,
@@ -642,7 +641,6 @@ void EngineFactoryD3D12Impl::AttachToD3D12Device(void*                        pd
             RefCntAutoPtr<DeviceContextD3D12Impl> pDeferredCtxD3D12{
                 NEW_RC_OBJ(RawMemAllocator, "DeviceContextD3D12Impl instance", DeviceContextD3D12Impl)(
                     pRenderDeviceD3D12,
-                    EngineCI,
                     DeviceContextDesc{
                         nullptr,
                         COMMAND_QUEUE_TYPE_UNKNOWN,
diff --git a/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -142,7 +142,18 @@ RenderDeviceD3D12Impl::RenderDeviceD3D12Impl(IReferenceCounters*          pRefCo
         EngineCI,
         AdapterInfo
     },
-    m_pd3d12Device   {pd3d12Device},
+    m_Properties
+    {
+        EngineCI.DynamicHeapPageSize,
+        [](const EngineD3D12CreateInfo& CI)
+        {
+            decltype(Properties::DynamicDescriptorAllocationChunkSize) ChunkSizeArr{};
+            for (size_t i=0; i < ChunkSizeArr.size(); ++i)
+				ChunkSizeArr[i] = CI.DynamicDescriptorAllocationChunkSize[i];
+            return ChunkSizeArr;
+        }(EngineCI),
+    },
+    m_pd3d12Device{pd3d12Device},
     m_CPUDescriptorHeaps
     {
         {RawMemAllocator, *this, EngineCI.CPUDescriptorHeapAllocationSize[0], D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, D3D12_DESCRIPTOR_HEAP_FLAG_NONE},
diff --git a/Graphics/GraphicsEngineVulkan/include/DeviceContextVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/DeviceContextVkImpl.hpp
@@ -71,10 +71,9 @@ class DeviceContextVkImpl final : public DeviceContextNextGenBase<EngineVkImplTr
 public:
     using TDeviceContextBase = DeviceContextNextGenBase<EngineVkImplTraits>;
 
-    DeviceContextVkImpl(IReferenceCounters*       pRefCounters,
-                        RenderDeviceVkImpl*       pDevice,
-                        const EngineVkCreateInfo& EngineCI,
-                        const DeviceContextDesc&  Desc);
+    DeviceContextVkImpl(IReferenceCounters*      pRefCounters,
+                        RenderDeviceVkImpl*      pDevice,
+                        const DeviceContextDesc& Desc);
     ~DeviceContextVkImpl();
 
     IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_DeviceContextVk, TDeviceContextBase)
diff --git a/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.hpp
@@ -260,14 +260,12 @@ class RenderDeviceVkImpl final : public RenderDeviceNextGenBase<RenderDeviceBase
 
     struct Properties
     {
-        const Uint32 ShaderGroupHandleSize;
-        const Uint32 MaxShaderRecordStride;
-        const Uint32 ShaderGroupBaseAlignment;
-        const Uint32 MaxDrawMeshTasksCount;
-        const Uint32 MaxRayTracingRecursionDepth;
-        const Uint32 MaxRayGenThreads;
+        Uint32 UploadHeapPageSize  = 0;
+        Uint32 DynamicHeapPageSize = 0;
     };
 
+    const Properties& GetProperties() const { return m_Properties; }
+
     // TODO: use small_vector
     std::vector<uint32_t> ConvertCmdQueueIdsToQueueFamilies(Uint64 CommandQueueMask) const;
 
@@ -294,6 +292,9 @@ class RenderDeviceVkImpl final : public RenderDeviceNextGenBase<RenderDeviceBase
                              Uint64&                                                     SubmittedFenceValue,
                              std::vector<std::pair<Uint64, RefCntAutoPtr<FenceVkImpl>>>* pFences);
 
+private:
+    const Properties m_Properties;
+
     std::shared_ptr<VulkanUtilities::VulkanInstance>       m_VulkanInstance;
     std::unique_ptr<VulkanUtilities::VulkanPhysicalDevice> m_PhysicalDevice;
     std::shared_ptr<VulkanUtilities::VulkanLogicalDevice>  m_LogicalVkDevice;
diff --git a/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp
@@ -61,10 +61,9 @@ static std::string GetContextObjectName(const char* Object, bool bIsDeferred, Ui
     return ss.str();
 }
 
-DeviceContextVkImpl::DeviceContextVkImpl(IReferenceCounters*       pRefCounters,
-                                         RenderDeviceVkImpl*       pDeviceVkImpl,
-                                         const EngineVkCreateInfo& EngineCI,
-                                         const DeviceContextDesc&  Desc) :
+DeviceContextVkImpl::DeviceContextVkImpl(IReferenceCounters*      pRefCounters,
+                                         RenderDeviceVkImpl*      pDeviceVkImpl,
+                                         const DeviceContextDesc& Desc) :
     // clang-format off
     TDeviceContextBase
     {
@@ -86,13 +85,13 @@ DeviceContextVkImpl::DeviceContextVkImpl(IReferenceCounters*       pRefCounters,
     {
         *pDeviceVkImpl,
         GetContextObjectName("Upload heap", Desc.IsDeferred, Desc.ContextId),
-        EngineCI.UploadHeapPageSize
+        pDeviceVkImpl->GetProperties().UploadHeapPageSize
     },
     m_DynamicHeap
     {
         pDeviceVkImpl->GetDynamicMemoryManager(),
         GetContextObjectName("Dynamic heap", Desc.IsDeferred, Desc.ContextId),
-        EngineCI.DynamicHeapPageSize
+        pDeviceVkImpl->GetProperties().DynamicHeapPageSize
     },
     m_DynamicDescrSetAllocator
     {
diff --git a/Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp b/Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp
@@ -1435,7 +1435,6 @@ void EngineFactoryVkImpl::AttachToVulkanDevice(std::shared_ptr<VulkanUtilities::
             RefCntAutoPtr<DeviceContextVkImpl> pImmediateCtxVk{
                 NEW_RC_OBJ(RawMemAllocator, "DeviceContextVkImpl instance", DeviceContextVkImpl)(
                     pRenderDeviceVk,
-                    EngineCI,
                     DeviceContextDesc{
                         pImmediateContextInfo[CtxInd].Name,
                         QueueType,
@@ -1454,7 +1453,6 @@ void EngineFactoryVkImpl::AttachToVulkanDevice(std::shared_ptr<VulkanUtilities::
             RefCntAutoPtr<DeviceContextVkImpl> pDeferredCtxVk{
                 NEW_RC_OBJ(RawMemAllocator, "DeviceContextVkImpl instance", DeviceContextVkImpl)(
                     pRenderDeviceVk,
-                    EngineCI,
                     DeviceContextDesc{
                         nullptr,
                         COMMAND_QUEUE_TYPE_UNKNOWN,
diff --git a/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp
diff --git a/Graphics/GraphicsEngineWebGPU/include/DeviceContextWebGPUImpl.hpp b/Graphics/GraphicsEngineWebGPU/include/DeviceContextWebGPUImpl.hpp
diff --git a/Graphics/GraphicsEngineWebGPU/src/DeviceContextWebGPUImpl.cpp b/Graphics/GraphicsEngineWebGPU/src/DeviceContextWebGPUImpl.cpp
diff --git a/Graphics/GraphicsEngineWebGPU/src/EngineFactoryWebGPU.cpp b/Graphics/GraphicsEngineWebGPU/src/EngineFactoryWebGPU.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2019-2024 Diligent Graphics LLC`
	`2`	`+ * Copyright 2019-2025 Diligent Graphics LLC`
`3`	`3`	`* Copyright 2015-2019 Egor Yusov`
`4`	`4`	`*`
`5`	`5`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`@@ -74,6 +74,10 @@ RenderDeviceD3D11Impl::RenderDeviceD3D11Impl(IReferenceCounters* pRefCo`
`74`	`74`	`EngineCI,`
`75`	`75`	`AdapterInfo`
`76`	`76`	`},`
	`77`	`+ m_Properties`
	`78`	`+ {`
	`79`	`+ EngineCI.D3D11ValidationFlags,`
	`80`	`+ },`
`77`	`81`	`m_pd3d11Device{pd3d11Device}`
`78`	`82`	`// clang-format on`
`79`	`83`	`{`
`@@ -135,13 +139,14 @@ RenderDeviceD3D11Impl::~RenderDeviceD3D11Impl()`
`135`	`139`
`136`	`140`	`void RenderDeviceD3D11Impl::TestTextureFormat(TEXTURE_FORMAT TexFormat)`
`137`	`141`	`{`
`138`		`- auto& TexFormatInfo = m_TextureFormatsInfo[TexFormat];`
	`142`	`+ TextureFormatInfoExt& TexFormatInfo = m_TextureFormatsInfo[TexFormat];`
`139`	`143`	`VERIFY(TexFormatInfo.Supported, "Texture format is not supported");`
`140`	`144`
`141`		`- auto DXGIFormat = TexFormatToDXGI_Format(TexFormat);`
	`145`	`+ DXGI_FORMAT DXGIFormat = TexFormatToDXGI_Format(TexFormat);`
`142`	`146`
`143`	`147`	`UINT FormatSupport = 0;`
`144`		`- auto hr = m_pd3d11Device->CheckFormatSupport(DXGIFormat, &FormatSupport);`
	`148`	`+`
	`149`	`+ HRESULT hr = m_pd3d11Device->CheckFormatSupport(DXGIFormat, &FormatSupport);`
`145`	`150`	`if (FAILED(hr))`
`146`	`151`	`{`
`147`	`152`	`LOG_ERROR_MESSAGE("CheckFormatSupport() failed for format ", DXGIFormat);`
`@@ -388,7 +393,7 @@ void RenderDeviceD3D11Impl::IdleGPU()`
`388`	`393`	`{`
`389`	`394`	`VERIFY_EXPR(m_wpImmediateContexts.size() == 1);`
`390`	`395`
`391`		`- if (auto pImmediateCtx = m_wpImmediateContexts[0].Lock())`
	`396`	`+ if (RefCntAutoPtr<DeviceContextD3D11Impl> pImmediateCtx = m_wpImmediateContexts[0].Lock())`
`392`	`397`	`{`
`393`	`398`	`pImmediateCtx->WaitForIdle();`
`394`	`399`	`}`