Implement SuperResolution: DLSS (D3D11/D3D12/Vulkan), DirectSR (D3D12), MetalFX (Metal)

Author: MikhailGorobets

.github/workflows/msvc_analysis.yml

@@ -60,7 +60,7 @@ jobs:
         # Ruleset file that will determine what checks will be run
         ruleset: NativeRecommendedRules.ruleset
         # Paths to ignore analysis of CMake targets and includes
-        ignoredPaths: '${{ github.workspace }}/ThirdParty'
+        ignoredPaths: '${{ github.workspace }}/ThirdParty;${{ env.DILIGENT_BUILD_DIR }}/_deps'
 
     # Upload SARIF file to GitHub Code Scanning Alerts
     - name: Upload SARIF to GitHub

Graphics/SuperResolution/CMakeLists.txt

@@ -4,9 +4,50 @@ include(../../BuildTools/CMake/BuildUtils.cmake)
 
 project(Diligent-SuperResolution CXX)
 
+set(DILIGENT_DLSS_SUPPORTED FALSE CACHE INTERNAL "DLSS is not supported")
+set(DILIGENT_DSR_SUPPORTED  FALSE CACHE INTERNAL "DirectSR is not supported")
+
+if(PLATFORM_WIN32)
+    set(DILIGENT_DLSS_SUPPORTED TRUE CACHE INTERNAL "DLSS is supported on Win32 platform")
+    set(DILIGENT_DSR_SUPPORTED  TRUE CACHE INTERNAL "DirectSR is supported on Win32 platform")
+endif()
+
+if(${DILIGENT_NO_DLSS})
+    set(DILIGENT_DLSS_SUPPORTED FALSE CACHE INTERNAL "DLSS is forcibly disabled")
+endif()
+if(${DILIGENT_NO_DSR})
+    set(DILIGENT_DSR_SUPPORTED FALSE CACHE INTERNAL "DirectSR is forcibly disabled")
+endif()
+
+if(DILIGENT_DSR_SUPPORTED)
+    # Fetch DirectSR headers
+    FetchContent_DeclareShallowGit(DirectSR-Headers
+        GIT_REPOSITORY https://github.com/MikhailGorobets/DirectSR-Headers.git
+        GIT_TAG        master
+    )
+    FetchContent_MakeAvailable(DirectSR-Headers)
+    if(TARGET DirectSR-AgilitySDK)
+        set_target_properties(DirectSR-AgilitySDK PROPERTIES FOLDER DiligentCore/ThirdParty)
+    endif()
+endif()
+
+if(DILIGENT_DLSS_SUPPORTED)
+    # Fetch NVIDIA DLSS SDK headers
+    FetchContent_DeclareShallowGit(DLSS-Headers
+        GIT_REPOSITORY https://github.com/NVIDIA/DLSS.git
+        GIT_TAG        main
+    )
+    FetchContent_MakeAvailable(DLSS-Headers)
+endif()
+
 set(INCLUDE
     include/SuperResolutionBase.hpp
     include/SuperResolutionFactoryBase.hpp
+    include/SuperResolutionVariants.hpp
+    include/SuperResolutionFactoryD3D12_DLSS.hpp
+    include/SuperResolutionFactoryD3D11_DLSS.hpp
+    include/SuperResolutionFactoryVk_DLSS.hpp
+    include/SuperResolutionFactoryD3D12_DSR.hpp
 )
 
 set(INTERFACE
@@ -16,15 +57,22 @@ set(INTERFACE
 )
 
 set(SOURCE
+    src/SuperResolutionBase.cpp
     src/SuperResolutionFactoryBase.cpp
+    src/SuperResolutionFactory.cpp
+    src/SuperResolutionFactoryD3D12.cpp
+    src/SuperResolutionFactoryD3D11.cpp
+    src/SuperResolutionFactoryVk.cpp
+    src/SuperResolutionFactoryMtl.cpp
+    src/SuperResolutionFactoryD3D12_DLSS.cpp
+    src/SuperResolutionFactoryD3D11_DLSS.cpp
+    src/SuperResolutionFactoryVk_DLSS.cpp
+    src/SuperResolutionFactoryD3D12_DSR.cpp
 )
 
-if(D3D12_SUPPORTED)
-    list(APPEND
-    SOURCE
-        src/SuperResolutionD3D12.cpp
-        src/SuperResolutionFactoryD3D12.cpp
-    )
+if(DILIGENT_DLSS_SUPPORTED)
+    list(APPEND INCLUDE include/SuperResolutionDLSS.hpp)
+    list(APPEND SOURCE src/SuperResolutionDLSS.cpp)
 endif()
 
 set(DLL_SOURCE
@@ -57,6 +105,14 @@ PRIVATE
     ../GraphicsEngineNextGenBase/include
 )
 
+if(DILIGENT_DLSS_SUPPORTED)
+    target_compile_definitions(Diligent-SuperResolution-static PRIVATE DILIGENT_DLSS_SUPPORTED=1)
+endif()
+
+if(DILIGENT_DSR_SUPPORTED)
+    target_compile_definitions(Diligent-SuperResolution-static PRIVATE DILIGENT_DSR_SUPPORTED=1)
+endif()
+
 target_compile_definitions(Diligent-SuperResolution-shared PUBLIC DILIGENT_SUPER_RESOLUTION_SHARED=1)
 
 target_link_libraries(Diligent-SuperResolution-static
@@ -69,11 +125,35 @@ PRIVATE
     Diligent-ShaderTools
 )
 
-if(D3D12_SUPPORTED)
-    target_link_libraries(Diligent-SuperResolution-static PRIVATE Diligent-GraphicsEngineD3D12-static)
+if(DILIGENT_DSR_SUPPORTED)
+    target_link_libraries(Diligent-SuperResolution-static PRIVATE Diligent-GraphicsEngineD3D12-static DirectSR-Headers)
     target_include_directories(Diligent-SuperResolution-static PRIVATE ../GraphicsEngineD3D12/include)
 endif()
 
+if(DILIGENT_DLSS_SUPPORTED)
+    set(DLSS_SDK_DIR ${FETCHCONTENT_BASE_DIR}/dlss-headers-src)
+    target_include_directories(Diligent-SuperResolution-static PRIVATE ${DLSS_SDK_DIR}/include)
+
+    # Link NGX static library (dynamic CRT /MD variant)
+    target_link_libraries(Diligent-SuperResolution-static PRIVATE
+        debug     ${DLSS_SDK_DIR}/lib/Windows_x86_64/x64/nvsdk_ngx_d_dbg.lib
+        optimized ${DLSS_SDK_DIR}/lib/Windows_x86_64/x64/nvsdk_ngx_d.lib
+    )
+
+    if(D3D12_SUPPORTED)
+        target_link_libraries(Diligent-SuperResolution-static PRIVATE Diligent-GraphicsEngineD3D12-static)
+        target_include_directories(Diligent-SuperResolution-static PRIVATE ../GraphicsEngineD3D12/include)
+    endif()
+    if(D3D11_SUPPORTED)
+        target_link_libraries(Diligent-SuperResolution-static PRIVATE Diligent-GraphicsEngineD3D11-static)
+        target_include_directories(Diligent-SuperResolution-static PRIVATE ../GraphicsEngineD3D11/include)
+    endif()
+    if(VULKAN_SUPPORTED)
+        target_link_libraries(Diligent-SuperResolution-static PRIVATE Diligent-GraphicsEngineVk-static Vulkan::Headers)
+        target_include_directories(Diligent-SuperResolution-static PRIVATE ../GraphicsEngineVulkan/include)
+    endif()
+endif()
+
 target_link_libraries(Diligent-SuperResolution-shared
 PUBLIC
     Diligent-SuperResolutionInterface

Graphics/SuperResolution/include/SuperResolutionBase.hpp

@@ -26,27 +26,66 @@
 
 #pragma once
 
-#include "SuperResolution.h"
 #include "ObjectBase.hpp"
+#include "SuperResolution.h"
+#include "SuperResolutionFactory.h"
+#include "GraphicsAccessories.hpp"
 
 #include <vector>
 #include <string>
 
 namespace Diligent
 {
 
+#define LOG_SUPER_RESOLUTION_ERROR_AND_THROW(Name, ...) LOG_ERROR_AND_THROW("Super resolution upscaler '", ((Name) != nullptr ? (Name) : ""), "': ", ##__VA_ARGS__)
+
+#define VERIFY_SUPER_RESOLUTION(Name, Expr, ...)                     \
+    do                                                               \
+    {                                                                \
+        if (!(Expr))                                                 \
+        {                                                            \
+            LOG_SUPER_RESOLUTION_ERROR_AND_THROW(Name, __VA_ARGS__); \
+        }                                                            \
+    } while (false)
+
+/// Validates super resolution description and throws an exception in case of an error.
+void ValidateSuperResolutionDesc(const SuperResolutionDesc& Desc) noexcept(false);
+
+/// Validates super resolution description for temporal upscaling and throws an exception in case of an error.
+void ValidateTemporalSuperResolutionDesc(const SuperResolutionDesc& Desc) noexcept(false);
+
+/// Validates super resolution source settings attributes and throws an exception in case of an error.
+void ValidateSourceSettingsAttribs(const SuperResolutionSourceSettingsAttribs& Attribs) noexcept(false);
+
+/// Validates execute super resolution attributes and throws an exception in case of an error.
+void ValidateExecuteSuperResolutionAttribs(const SuperResolutionDesc&           Desc,
+                                           const ExecuteSuperResolutionAttribs& Attribs) noexcept(false);
+
+/// Validates execute super resolution attributes for temporal upscaling and throws an exception in case of an error.
+void ValidateTemporalExecuteSuperResolutionAttribs(const SuperResolutionDesc&           Desc,
+                                                   const ExecuteSuperResolutionAttribs& Attribs) noexcept(false);
+
 class SuperResolutionBase : public ObjectBase<ISuperResolution>
 {
 public:
     using TBase = ObjectBase<ISuperResolution>;
 
+    struct JitterOffset
+    {
+        float X = 0.0f;
+        float Y = 0.0f;
+    };
+
     SuperResolutionBase(IReferenceCounters*        pRefCounters,
                         const SuperResolutionDesc& Desc) :
         TBase{pRefCounters},
-        m_Name{Desc.Name != nullptr ? Desc.Name : ""},
         m_Desc{Desc}
     {
-        m_Desc.Name = m_Name.c_str();
+        if (Desc.Name != nullptr)
+        {
+            m_Name      = Desc.Name;
+            m_Desc.Name = m_Name.c_str();
+        }
     }
 
     IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_SuperResolution, TBase)
@@ -72,15 +111,12 @@ class SuperResolutionBase : public ObjectBase<ISuperResolution>
     }
 
 protected:
-    struct JitterOffset
-    {
-        float X = 0.0f;
-        float Y = 0.0f;
-    };
-
-    const std::string         m_Name;
     SuperResolutionDesc       m_Desc;
+    std::string               m_Name;
     std::vector<JitterOffset> m_JitterPattern;
 };
 
+/// Populates a Halton(2,3) jitter pattern centered at origin.
+void PopulateHaltonJitterPattern(std::vector<SuperResolutionBase::JitterOffset>& JitterPattern, Uint32 PatternSize);
+
 } // namespace Diligent

Graphics/SuperResolution/include/SuperResolutionDLSS.hpp

@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2026 Diligent Graphics LLC
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  In no event and under no legal theory, whether in tort (including negligence),
+ *  contract, or otherwise, unless required by applicable law (such as deliberate
+ *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ *  liable for any damages, including any direct, indirect, special, incidental,
+ *  or consequential damages of any character arising as a result of this License or
+ *  out of the use or inability to use the software (including but not limited to damages
+ *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and
+ *  all other commercial damages or losses), even if such Contributor has been advised
+ *  of the possibility of such damages.
+ */
+
+#pragma once
+
+/// \file
+/// Shared DLSS utilities used by per-API DLSS backend implementations.
+
+#include <vector>
+
+#include <nvsdk_ngx_defs.h>
+
+#include "SuperResolutionFactory.h"
+#include "SuperResolution.h"
+
+struct NVSDK_NGX_Parameter;
+
+namespace Diligent
+{
+
+extern const char*    DLSSProjectId;
+extern const wchar_t* DLSSAppDataPath;
+
+/// Maps Diligent optimization type to NGX performance/quality preset.
+NVSDK_NGX_PerfQuality_Value OptimizationTypeToNGXPerfQuality(SUPER_RESOLUTION_OPTIMIZATION_TYPE Type);
+
+/// Maps Diligent super resolution flags to DLSS feature flags.
+Int32 SuperResolutionFlagsToDLSSFeatureFlags(SUPER_RESOLUTION_FLAGS Flags);
+
+/// Populates DLSS variant info using NGX capability parameters.
+void EnumerateDLSSVariants(NVSDK_NGX_Parameter* pNGXParams, std::vector<SuperResolutionInfo>& Variants);
+
+/// Queries DLSS optimal source settings using NGX capability parameters.
+void GetDLSSSourceSettings(NVSDK_NGX_Parameter*                        pNGXParams,
+                           const SuperResolutionSourceSettingsAttribs& Attribs,
+                           SuperResolutionSourceSettings&              Settings);
+
+} // namespace Diligent

Graphics/SuperResolution/include/SuperResolutionFactoryBase.hpp

@@ -27,34 +27,91 @@
 #pragma once
 
 #include "SuperResolutionFactory.h"
+#include "SuperResolution.h"
 #include "ObjectBase.hpp"
-#include "RefCntAutoPtr.hpp"
 
 #include <vector>
+#include <memory>
 
 namespace Diligent
 {
 
+struct BackendEntry
+{
+    struct IHolder
+    {
+        virtual ~IHolder() = default;
+
+        virtual void GetSourceSettings(const SuperResolutionSourceSettingsAttribs& Attribs, SuperResolutionSourceSettings& Settings) = 0;
+
+        virtual void CreateSuperResolution(const SuperResolutionDesc& Desc, ISuperResolution** ppUpscaler) = 0;
+    };
+
+    template <typename T>
+    struct Holder final : IHolder
+    {
+        T Instance;
+        template <typename... Args>
+        explicit Holder(Args&&... args) :
+            Instance(std::forward<Args>(args)...) {}
+
+        void GetSourceSettings(const SuperResolutionSourceSettingsAttribs& Attribs, SuperResolutionSourceSettings& Settings) override { Instance.GetSourceSettings(Attribs, Settings); }
+
+        void CreateSuperResolution(const SuperResolutionDesc& Desc, ISuperResolution** ppUpscaler) override { Instance.CreateSuperResolution(Desc, ppUpscaler); }
+    };
+
+    std::unique_ptr<IHolder>         pBackend;
+    std::vector<SuperResolutionInfo> Variants;
+};
+
 class SuperResolutionFactoryBase : public ObjectBase<ISuperResolutionFactory>
 {
 public:
     using TBase = ObjectBase<ISuperResolutionFactory>;
 
-    SuperResolutionFactoryBase(IReferenceCounters* pRefCounters, IRenderDevice* pDevice);
+    SuperResolutionFactoryBase(IReferenceCounters* pRefCounters);
 
     IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_SuperResolutionFactory, TBase)
 
     virtual void DILIGENT_CALL_TYPE EnumerateVariants(Uint32& NumVariants, SuperResolutionInfo* Variants) override final;
 
+    virtual void DILIGENT_CALL_TYPE GetSourceSettings(const SuperResolutionSourceSettingsAttribs& Attribs, SuperResolutionSourceSettings& Settings) const override final;
+
+    virtual void DILIGENT_CALL_TYPE CreateSuperResolution(const SuperResolutionDesc& Desc, ISuperResolution** ppUpscaler) override final;
+
     virtual void DILIGENT_CALL_TYPE SetMessageCallback(DebugMessageCallbackType MessageCallback) const override final;
 
     virtual void DILIGENT_CALL_TYPE SetBreakOnError(bool BreakOnError) const override final;
 
     virtual void DILIGENT_CALL_TYPE SetMemoryAllocator(IMemoryAllocator* pAllocator) const override final;
 
+    template <typename BackendType, typename... Args>
+    void AddBackend(Args&&... args);
+
 private:
-    RefCntAutoPtr<IRenderDevice>     m_pDevice;
-    std::vector<SuperResolutionInfo> m_Variants{};
+    BackendEntry* FindBackend(const INTERFACE_ID& VariantId) const;
+
+    std::vector<BackendEntry> m_Backends;
 };
 
+template <typename BackendType, typename... Args>
+void SuperResolutionFactoryBase::AddBackend(Args&&... args)
+{
+    try
+    {
+        auto pHolder = std::make_unique<BackendEntry::Holder<BackendType>>(std::forward<Args>(args)...);
+
+        BackendEntry Entry;
+        pHolder->Instance.EnumerateVariants(Entry.Variants);
+        if (Entry.Variants.empty())
+            return;
+
+        Entry.pBackend = std::move(pHolder);
+        m_Backends.push_back(std::move(Entry));
+    }
+    catch (...)
+    {
+    }
+}
+
 } // namespace Diligent