Implement SuperResolution API and factory infrastructure

Author: MikhailGorobets

CMakeLists.txt

@@ -59,6 +59,7 @@ set(VULKAN_SUPPORTED           FALSE CACHE INTERNAL "Vulkan is not supported")
 set(METAL_SUPPORTED            FALSE CACHE INTERNAL "Metal is not supported")
 set(WEBGPU_SUPPORTED           FALSE CACHE INTERNAL "WebGPU is not supported")
 set(ARCHIVER_SUPPORTED         FALSE CACHE INTERNAL "Archiver is not supported")
+set(SUPER_RESOLUTION_SUPPORTED FALSE CACHE INTERNAL "Super resolution is not supported")
 
 set(DILIGENT_CORE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "DiligentCore module source directory")
 
@@ -180,10 +181,11 @@ if(MINGW)
 endif()
 
 if(PLATFORM_WIN32)
-    set(GL_SUPPORTED       TRUE CACHE INTERNAL "OpenGL is supported on Win32 platform")
-    set(VULKAN_SUPPORTED   TRUE CACHE INTERNAL "Vulkan is supported on Win32 platform")
-    set(WEBGPU_SUPPORTED   TRUE CACHE INTERNAL "WebGPU is supported on Win32 platform")
-    set(ARCHIVER_SUPPORTED TRUE CACHE INTERNAL "Archiver is supported on Win32 platform")
+    set(GL_SUPPORTED               TRUE CACHE INTERNAL "OpenGL is supported on Win32 platform")
+    set(VULKAN_SUPPORTED           TRUE CACHE INTERNAL "Vulkan is supported on Win32 platform")
+    set(WEBGPU_SUPPORTED           TRUE CACHE INTERNAL "WebGPU is supported on Win32 platform")
+    set(ARCHIVER_SUPPORTED         TRUE CACHE INTERNAL "Archiver is supported on Win32 platform")
+    set(SUPER_RESOLUTION_SUPPORTED TRUE CACHE INTERNAL "Super resolution is supported on Win32 platform")
     target_compile_definitions(Diligent-PublicBuildSettings INTERFACE PLATFORM_WIN32=1)
 elseif(PLATFORM_UNIVERSAL_WINDOWS)
     set(ARCHIVER_SUPPORTED TRUE CACHE INTERNAL "Archiver is supported on Universal Windows platform")
@@ -303,6 +305,7 @@ else()
     option(DILIGENT_NO_WEBGPU        "Disable WebGPU backend" ON)
 endif()
 option(DILIGENT_NO_ARCHIVER          "Do not build archiver" OFF)
+option(DILIGENT_NO_SUPER_RESOLUTION  "Do not build super resolution" OFF)
 
 option(DILIGENT_EMSCRIPTEN_STRIP_DEBUG_INFO "Strip debug information from WebAsm binaries" OFF)
 
@@ -329,6 +332,9 @@ endif()
 if(${DILIGENT_NO_ARCHIVER})
     set(ARCHIVER_SUPPORTED FALSE CACHE INTERNAL "Archiver is forcibly disabled")
 endif()
+if(${DILIGENT_NO_SUPER_RESOLUTION})
+    set(SUPER_RESOLUTION_SUPPORTED FALSE CACHE INTERNAL "Super resolution is forcibly disabled")
+endif()
 
 if(NOT (${D3D11_SUPPORTED} OR ${D3D12_SUPPORTED} OR ${GL_SUPPORTED} OR ${GLES_SUPPORTED} OR ${VULKAN_SUPPORTED} OR ${METAL_SUPPORTED} OR ${WEBGPU_SUPPORTED}))
     message(FATAL_ERROR "No rendering backends are select to build")

Graphics/CMakeLists.txt

@@ -56,4 +56,7 @@ if(ARCHIVER_SUPPORTED)
 endif()
 
 add_subdirectory(GraphicsTools)
-add_subdirectory(SuperResolution)
+
+if(SUPER_RESOLUTION_SUPPORTED)
+    add_subdirectory(SuperResolution)
+endif()

Graphics/SuperResolution/CMakeLists.txt

@@ -1,10 +1,12 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.11)
 
 include(../../BuildTools/CMake/BuildUtils.cmake)
 
 project(Diligent-SuperResolution CXX)
 
 set(INCLUDE
+    include/SuperResolutionBase.hpp
+    include/SuperResolutionInternal.hpp
 )
 
 set(INTERFACE
@@ -29,6 +31,7 @@ set(DLL_SOURCE
 add_library(Diligent-SuperResolutionInterface INTERFACE)
 target_link_libraries     (Diligent-SuperResolutionInterface INTERFACE Diligent-GraphicsEngineInterface)
 target_include_directories(Diligent-SuperResolutionInterface INTERFACE interface)
+target_compile_definitions(Diligent-SuperResolutionInterface INTERFACE SUPER_RESOLUTION_SUPPORTED=1)
 
 add_library(Diligent-SuperResolution-static STATIC
     ${SOURCE} ${INTERFACE} ${INCLUDE}
@@ -45,17 +48,21 @@ endif()
 target_include_directories(Diligent-SuperResolution-static
 PRIVATE
     include
+    ../GraphicsEngine/include
+    ../GraphicsEngineD3DBase/include
+    ../GraphicsEngineNextGenBase/include
 )
 
 target_compile_definitions(Diligent-SuperResolution-shared PUBLIC DILIGENT_SUPER_RESOLUTION_SHARED=1)
 
-
 target_link_libraries(Diligent-SuperResolution-static
 PUBLIC
     Diligent-SuperResolutionInterface
 PRIVATE
     Diligent-BuildSettings
     Diligent-Common
+    Diligent-GraphicsAccessories
+    Diligent-ShaderTools
 )
 
 if(D3D12_SUPPORTED)
@@ -86,7 +93,7 @@ endif()
 if (MINGW_BUILD)
     # Restrict export to GetSuperResolutionFactory
     file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/export.map
-        "{ global: *GetSuperResolutionFactory*; local: *; };"
+        "{ global: *CreateSuperResolutionFactory*; local: *; };"
     )
     target_link_options(Diligent-SuperResolution-shared PRIVATE LINKER:--version-script=export.map)
 endif()

Graphics/SuperResolution/include/SuperResolutionBase.hpp

@@ -0,0 +1,91 @@
+/*
+ *  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
+
+#include "ObjectBase.hpp"
+#include "SuperResolution.h"
+
+#include <vector>
+#include <string>
+
+namespace Diligent
+{
+
+class SuperResolutionBase : public ObjectBase<ISuperResolution>
+{
+public:
+    using TBase = ObjectBase<ISuperResolution>;
+
+    SuperResolutionBase(IReferenceCounters*        pRefCounters,
+                        const SuperResolutionDesc& Desc) :
+        TBase{pRefCounters},
+        m_Desc{Desc}
+    {
+        if (Desc.Name != nullptr)
+        {
+            m_Name      = Desc.Name;
+            m_Desc.Name = m_Name.c_str();
+        }
+    }
+
+    IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_SuperResolution, TBase)
+
+    virtual const SuperResolutionDesc& DILIGENT_CALL_TYPE GetDesc() const override final
+    {
+        return m_Desc;
+    }
+
+    virtual void DILIGENT_CALL_TYPE GetJitterOffset(Uint32 Index, float* pJitterX, float* pJitterY) const override final
+    {
+        DEV_CHECK_ERR(pJitterX != nullptr && pJitterY != nullptr, "pJitterX and pJitterY must not be null");
+
+        if (!m_JitterPattern.empty())
+        {
+            const Uint32 WrappedIndex = Index % static_cast<Uint32>(m_JitterPattern.size());
+            *pJitterX                 = m_JitterPattern[WrappedIndex].X;
+            *pJitterY                 = m_JitterPattern[WrappedIndex].Y;
+        }
+        else
+        {
+            *pJitterX = 0.0f;
+            *pJitterY = 0.0f;
+        }
+    }
+
+protected:
+    struct JitterOffset
+    {
+        float X = 0.0f;
+        float Y = 0.0f;
+    };
+
+    SuperResolutionDesc       m_Desc;
+    std::string               m_Name;
+    std::vector<JitterOffset> m_JitterPattern;
+};
+
+} // namespace Diligent

Graphics/SuperResolution/include/SuperResolutionInternal.hpp

@@ -0,0 +1,47 @@
+/*
+ *  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
+
+#include "SuperResolutionFactory.h"
+
+#include <array>
+#include <vector>
+
+namespace Diligent
+{
+
+enum SUPER_RESOLUTION_BACKEND : Uint8
+{
+    SUPER_RESOLUTION_BACKEND_D3D12_DSR,
+    SUPER_RESOLUTION_BACKEND_METAL_FX,
+    SUPER_RESOLUTION_BACKEND_SOFTWARE,
+    SUPER_RESOLUTION_BACKEND_COUNT
+};
+
+using SuperResolutionVariants = std::array<std::vector<SuperResolutionInfo>, SUPER_RESOLUTION_BACKEND_COUNT>;
+
+} // namespace Diligent

Graphics/SuperResolution/interface/SuperResolution.h

@@ -29,7 +29,7 @@
 /// \file
 /// Defines Diligent::ISuperResolution interface and related data structures
 
-#include "../../GraphicsEngine/interface/DeviceObject.h"
+#include "../../../Primitives/interface/Object.h"
 #include "../../GraphicsEngine/interface/GraphicsTypes.h"
 #include "../../GraphicsEngine/interface/TextureView.h"
 #include "../../GraphicsEngine/interface/DeviceContext.h"
@@ -62,7 +62,10 @@ DEFINE_FLAG_ENUM_OPERATORS(SUPER_RESOLUTION_FLAGS)
 
 /// This structure describes the super resolution upscaler object and is part of the creation
 /// parameters given to ISuperResolutionFactory::CreateSuperResolution().
-struct SuperResolutionDesc DILIGENT_DERIVE(DeviceObjectAttribs)
+struct SuperResolutionDesc
+{
+    /// Object name.
+    const Char* Name DEFAULT_INITIALIZER(nullptr);
 
     /// Unique identifier of the super resolution variant to create.
     ///
@@ -107,13 +110,6 @@ struct SuperResolutionDesc DILIGENT_DERIVE(DeviceObjectAttribs)
     /// Optional. Used for temporal upscaling to guide the denoiser for areas with inaccurate motion information (e.g., alpha-blended objects).
     TEXTURE_FORMAT ReactiveMaskFormat DEFAULT_INITIALIZER(TEX_FORMAT_UNKNOWN);
 
-    /// Ignore history mask texture format.
-    ///
-    /// Optional. Used for temporal upscaling to indicate regions where temporal history
-    /// should be completely discarded (binary mask: 0 = use history, 1 = ignore history).
-    /// Unlike the reactive mask which provides proportional control, this is a binary decision.
-    TEXTURE_FORMAT IgnoreHistoryMaskFormat DEFAULT_INITIALIZER(TEX_FORMAT_UNKNOWN);
-
     /// Exposure scale texture format.
     ///
     /// Optional. When auto-exposure is disabled, specifies the format of the 1x1 exposure
@@ -178,7 +174,7 @@ struct ExecuteSuperResolutionAttribs
     /// where temporal history should be completely discarded.
     /// Unlike the reactive mask which provides proportional control,
     /// this is a binary decision (discard or keep).
-    /// Only used when SuperResolutionDesc::IgnoreHistoryMaskFormat != TEX_FORMAT_UNKNOWN.
+    /// Format must be TEX_FORMAT_R8_UINT.
     ITextureView* pIgnoreHistoryMaskTextureSRV DEFAULT_INITIALIZER(nullptr);
 
     /// Jitter offset X applied to the projection matrix (in pixels).
@@ -263,21 +259,19 @@ typedef struct ExecuteSuperResolutionAttribs ExecuteSuperResolutionAttribs;
 #define DILIGENT_INTERFACE_NAME ISuperResolution
 #include "../../../Primitives/interface/DefineInterfaceHelperMacros.h"
 
-#define ISuperResolutionInclusiveMethods    \
-    IDeviceObjectInclusiveMethods;                  \
+#define ISuperResolutionInclusiveMethods   \
+    IObjectInclusiveMethods;               \
     ISuperResolutionMethods SuperResolution
 
 /// Super resolution upscaler interface.
 ///
 /// The super resolution object encapsulates a hardware-accelerated or software-based super resolution
 /// effect (e.g., MetalFX on Metal, DirectSR on D3D12).
 /// It is created via ISuperResolutionFactory::CreateSuperResolution().
-DILIGENT_BEGIN_INTERFACE(ISuperResolution, IDeviceObject)
+DILIGENT_BEGIN_INTERFACE(ISuperResolution, IObject)
 {
-#if DILIGENT_CPP_INTERFACE
     /// Returns the super resolution description used to create the object.
-    virtual const SuperResolutionDesc& METHOD(GetDesc)() const override = 0;
-#endif
+    VIRTUAL const SuperResolutionDesc REF METHOD(GetDesc)(THIS) CONST PURE;
 
     /// Returns the optimal jitter offset for the given frame index.
 
@@ -315,8 +309,7 @@ DILIGENT_END_INTERFACE
 #if DILIGENT_C_INTERFACE
 
 // clang-format off
-#    define ISuperResolution_GetDesc(This) (const struct SuperResolutionDesc*)IDeviceObject_GetDesc(This)
-
+#    define ISuperResolution_GetDesc(This)              CALL_IFACE_METHOD(SuperResolution, GetDesc, This)
 #    define ISuperResolution_GetJitterOffset(This, ...) CALL_IFACE_METHOD(SuperResolution, GetJitterOffset, This, __VA_ARGS__)
 #    define ISuperResolution_Execute(This, ...)         CALL_IFACE_METHOD(SuperResolution, Execute, This, __VA_ARGS__)
 

Graphics/SuperResolution/interface/SuperResolutionFactory.h

@@ -233,11 +233,14 @@ typedef struct SuperResolutionSourceSettingsAttribs SuperResolutionSourceSetting
 // clang-format off
 
 /// SuperResolution factory interface
+///
+/// The factory is created per render device using CreateSuperResolutionFactory().
+/// It enumerates available super resolution backends, queries optimal settings,
+/// and creates upscaler instances for the device it was created with.
 DILIGENT_BEGIN_INTERFACE(ISuperResolutionFactory, IObject)
 {
-    /// Enumerates the supported super resolution variants for the given render device.
+    /// Enumerates the supported super resolution variants.
 
-    /// \param [in]      pDevice     - Render device to query the supported super resolution variants for.
     /// \param [in, out] NumVariants - Number of super resolution variants. If `Variants` is null, this
     ///                                parameter is used to return the number of supported variants.
     ///                                If `Variants` is not null, this parameter should contain the maximum number
@@ -246,14 +249,12 @@ DILIGENT_BEGIN_INTERFACE(ISuperResolutionFactory, IObject)
     /// \param [out]     Variants    - Array to receive the supported super resolution variants.
     ///                                Each variant is described by SuperResolutionInfo structure.
     VIRTUAL void METHOD(EnumerateVariants)(THIS_
-                                           IRenderDevice*       pDevice,
                                            Uint32 REF           NumVariants,
                                            SuperResolutionInfo* Variants) PURE;
 
 
     /// Returns the optimal source (input) settings for super resolution upscaling.
 
-    /// \param [in]  pDevice  - Render device to query the optimal source settings for.
     /// \param [in]  Attribs  - Attributes, see Diligent::SuperResolutionSourceSettingsAttribs for details.
     /// \param [out] Settings - On success, receives the optimal source settings, 
     ///                         see Diligent::SuperResolutionSourceSettings for details.
@@ -262,14 +263,12 @@ DILIGENT_BEGIN_INTERFACE(ISuperResolutionFactory, IObject)
     ///             Use this method to determine the optimal render resolution before creating
     ///             the upscaler object.
     VIRTUAL void METHOD(GetSourceSettings)(THIS_
-                                           IRenderDevice*                                 pDevice,
                                            const SuperResolutionSourceSettingsAttribs REF Attribs,
                                            SuperResolutionSourceSettings              REF Settings) CONST PURE;
 
 
-     /// Creates a new upscaler object.
+    /// Creates a new upscaler object.
 
-    /// \param [in]  pDevice    - Render device to create the upscaler for.
     /// \param [in]  Desc       - Super resolution upscaler description, see Diligent::SuperResolutionDesc for details.
     /// \param [out] ppUpscaler - Address of the memory location where a pointer to the
     ///                           super resolution upscaler interface will be written.
@@ -279,7 +278,6 @@ DILIGENT_BEGIN_INTERFACE(ISuperResolutionFactory, IObject)
     /// \remarks    On backends that don't support hardware upscaling, the method will
     ///             return nullptr.
     VIRTUAL void METHOD(CreateSuperResolution)(THIS_
-                                               IRenderDevice*                pDevice,
                                                const SuperResolutionDesc REF Desc,
                                                ISuperResolution**            ppUpscaler) PURE;
 
@@ -324,4 +322,12 @@ DILIGENT_END_INTERFACE
 
 #endif
 
+/// Creates a super resolution factory for the specified render device.
+
+/// \param [in]  pDevice    - Render device to create the factory for.
+/// \param [out] ppFactory  - Address of the memory location where a pointer to the
+///                           super resolution factory interface will be written.
+void DILIGENT_GLOBAL_FUNCTION(CreateSuperResolutionFactory)(IRenderDevice*            pDevice,
+                                                            ISuperResolutionFactory** ppFactory);
+
 DILIGENT_END_NAMESPACE // namespace Diligent