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,86 @@
+/*
+ *  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 "SuperResolution.h"
+#include "ObjectBase.hpp"
+
+#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_Name{Desc.Name != nullptr ? Desc.Name : ""},
+        m_Desc{Desc}
+    {
+        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& JitterX, float& JitterY) const override final
+    {
+        if (!m_JitterPattern.empty())
+        {
+            const Uint32 WrappedIndex = Index % static_cast<Uint32>(m_JitterPattern.size());
+            JitterX                   = m_JitterPattern[WrappedIndex].X;
+            JitterY                   = m_JitterPattern[WrappedIndex].Y;
+        }
+        else
+        {
+            JitterX = 0.0f;
+            JitterY = 0.0f;
+        }
+    }
+
+protected:
+    struct JitterOffset
+    {
+        float X = 0.0f;
+        float Y = 0.0f;
+    };
+
+    const std::string         m_Name;
+    SuperResolutionDesc       m_Desc;
+    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,35 +259,33 @@ 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.
 
-    /// \param [in]  Index    - Frame index. The sequence wraps automatically.
-    /// \param [out] pJitterX - Jitter offset X in pixel space, typically in [-0.5, 0.5] range.
-    /// \param [out] pJitterY - Jitter offset Y in pixel space, typically in [-0.5, 0.5] range.
+    /// \param [in]  Index   - Frame index. The sequence wraps automatically.
+    /// \param [out] JitterX - Jitter offset X in pixel space, typically in [-0.5, 0.5] range.
+    /// \param [out] JitterY - Jitter offset Y in pixel space, typically in [-0.5, 0.5] range.
     ///
     /// For temporal upscaling, the upscaler provides a recommended jitter pattern
     /// (e.g. Halton sequence) that should be applied to the projection matrix each frame.
     /// For spatial upscaling, both values are set to zero.
     VIRTUAL void METHOD(GetJitterOffset)(THIS_
                                          Uint32 Index,
-                                         float* pJitterX,
-                                         float* pJitterY) CONST PURE;
+                                         float REF JitterX,
+                                         float REF JitterY) CONST PURE;
 
 
     /// Executes the super resolution upscaler.
@@ -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__)