Added ISuperResolutionUpscaler interface and SuperResolution device feature

Author: MikhailGorobets

Graphics/GraphicsEngine/interface/DeviceContext.h

@@ -58,6 +58,7 @@
 #include "ShaderBindingTable.h"
 #include "DeviceMemory.h"
 #include "CommandQueue.h"
+#include "SuperResolutionUpscaler.h"
 
 DILIGENT_BEGIN_NAMESPACE(Diligent)
 
@@ -3750,6 +3751,21 @@ DILIGENT_BEGIN_INTERFACE(IDeviceContext, IObject)
 
     /// Returns the device context statistics, see Diligent::DeviceContextStats.
     VIRTUAL const DeviceContextStats REF METHOD(GetStats)(THIS) CONST PURE;
+
+
+    /// Executes the hardware super resolution upscaler.
+
+    /// \param [in] Attribs    - Upscale operation attributes, see Diligent::ExecuteSuperResolutionAttribs.
+    /// \param [in] pUpscaler  - Super resolution upscaler object to execute.
+    ///
+    /// \remarks The command must be called outside of a render pass.
+    ///          All input textures must be in the appropriate states or
+    ///          TransitionMode should be set to RESOURCE_STATE_TRANSITION_MODE_TRANSITION.
+    ///
+    /// \remarks Supported contexts: graphics.
+    VIRTUAL void METHOD(ExecuteSuperResolution)(THIS_
+                                                const ExecuteSuperResolutionAttribs REF Attribs,
+                                                ISuperResolutionUpscaler*               pUpscaler) PURE;
 };
 DILIGENT_END_INTERFACE
 
@@ -3829,6 +3845,7 @@ DILIGENT_END_INTERFACE
 #    define IDeviceContext_BindSparseResourceMemory(This, ...)      CALL_IFACE_METHOD(DeviceContext, BindSparseResourceMemory,  This, __VA_ARGS__)
 #    define IDeviceContext_ClearStats(This)                         CALL_IFACE_METHOD(DeviceContext, ClearStats,                This)
 #    define IDeviceContext_GetStats(This)                           CALL_IFACE_METHOD(DeviceContext, GetStats,                  This)
+#    define IDeviceContext_ExecuteSuperResolution(This, ...)        CALL_IFACE_METHOD(DeviceContext, ExecuteSuperResolution,    This, __VA_ARGS__)
 
 // clang-format on
 

Graphics/GraphicsEngine/interface/GraphicsTypes.h

@@ -1856,6 +1856,10 @@ struct DeviceFeatures
     /// Indicates if device supports formatted buffers.
     DEVICE_FEATURE_STATE FormattedBuffers       DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
+    /// Indicates if the device supports hardware super resolution (upscaling).
+    /// MetalFX on Metal, DirectSR on D3D12.
+    DEVICE_FEATURE_STATE SuperResolution        DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
+
 #if DILIGENT_CPP_INTERFACE
     constexpr DeviceFeatures() noexcept {}
 
@@ -1906,11 +1910,12 @@ struct DeviceFeatures
 	Handler(TextureSubresourceViews)		   \
 	Handler(NativeMultiDraw)                   \
     Handler(AsyncShaderCompilation)			   \
-	Handler(FormattedBuffers)
+	Handler(FormattedBuffers)                  \
+    Handler(SuperResolution)
 
     explicit constexpr DeviceFeatures(DEVICE_FEATURE_STATE State) noexcept
     {
-        static_assert(sizeof(*this) == 47, "Did you add a new feature to DeviceFeatures? Please add it to ENUMERATE_DEVICE_FEATURES.");
+        static_assert(sizeof(*this) == 48, "Did you add a new feature to DeviceFeatures? Please add it to ENUMERATE_DEVICE_FEATURES.");
     #define INIT_FEATURE(Feature) Feature = State;
         ENUMERATE_DEVICE_FEATURES(INIT_FEATURE)
     #undef INIT_FEATURE
@@ -3251,6 +3256,38 @@ struct SparseResourceProperties
 typedef struct SparseResourceProperties SparseResourceProperties;
 
 
+/// Super resolution capability flags
+DILIGENT_TYPED_ENUM(SUPER_RESOLUTION_FLAGS, Uint32)
+{
+    SUPER_RESOLUTION_FLAG_NONE     = 0u,
+
+    /// Supports spatial-only upscaling (single frame).
+    SUPER_RESOLUTION_FLAG_SPATIAL  = 1u << 0,
+
+    /// Supports temporal upscaling (uses motion vectors and history).
+    SUPER_RESOLUTION_FLAG_TEMPORAL = 1u << 1,
+
+    SUPER_RESOLUTION_FLAG_LAST     = SUPER_RESOLUTION_FLAG_TEMPORAL
+};
+DEFINE_FLAG_ENUM_OPERATORS(SUPER_RESOLUTION_FLAGS)
+
+
+/// Super resolution properties, reported via GraphicsAdapterInfo
+struct SuperResolutionProperties
+{
+    /// Capability flags indicating supported upscaler types, see Diligent::SUPER_RESOLUTION_FLAGS.
+    SUPER_RESOLUTION_FLAGS Flags DEFAULT_INITIALIZER(SUPER_RESOLUTION_FLAG_NONE);
+
+#if DILIGENT_CPP_INTERFACE
+    constexpr bool operator==(const SuperResolutionProperties& RHS) const
+    {
+        return Flags == RHS.Flags;
+    }
+#endif
+};
+typedef struct SuperResolutionProperties SuperResolutionProperties;
+
+
 /// Command queue properties
 struct CommandQueueInfo
 {
@@ -3342,6 +3379,9 @@ struct GraphicsAdapterInfo
     /// Sparse resource properties, see Diligent::SparseResourceProperties.
     SparseResourceProperties SparseResources;
 
+    /// Super resolution upscaler properties, see Diligent::SuperResolutionProperties.
+    SuperResolutionProperties SuperResolution;
+
     /// Supported device features, see Diligent::DeviceFeatures.
 
     /// The feature state indicates:
@@ -3372,23 +3412,24 @@ struct GraphicsAdapterInfo
             if (!(Queues[i] == RHS.Queues[i]))
                 return false;
 
-        return Type            == RHS.Type            &&
-               Vendor          == RHS.Vendor          &&
-               VendorId        == RHS.VendorId        &&
-               DeviceId        == RHS.DeviceId        &&
-               NumOutputs      == RHS.NumOutputs      &&
-               Memory          == RHS.Memory          &&
-               RayTracing      == RHS.RayTracing      &&
-               WaveOp          == RHS.WaveOp          &&
-               Buffer          == RHS.Buffer          &&
-               Texture         == RHS.Texture         &&
-               Sampler         == RHS.Sampler         &&
-               MeshShader      == RHS.MeshShader      &&
-               ShadingRate     == RHS.ShadingRate     &&
-               ComputeShader   == RHS.ComputeShader   &&
-               DrawCommand     == RHS.DrawCommand     &&
-               SparseResources == RHS.SparseResources &&
-               Features        == RHS.Features        &&
+        return Type             == RHS.Type            &&
+               Vendor           == RHS.Vendor          &&
+               VendorId         == RHS.VendorId        &&
+               DeviceId         == RHS.DeviceId        &&
+               NumOutputs       == RHS.NumOutputs      &&
+               Memory           == RHS.Memory          &&
+               RayTracing       == RHS.RayTracing      &&
+               WaveOp           == RHS.WaveOp          &&
+               Buffer           == RHS.Buffer          &&
+               Texture          == RHS.Texture         &&
+               Sampler          == RHS.Sampler         &&
+               MeshShader       == RHS.MeshShader      &&
+               ShadingRate      == RHS.ShadingRate     &&
+               ComputeShader    == RHS.ComputeShader   &&
+               DrawCommand      == RHS.DrawCommand     &&
+               SparseResources  == RHS.SparseResources &&
+               SuperResolution  == RHS.SuperResolution &&
+               Features         == RHS.Features        &&
                memcmp(Description, RHS.Description, sizeof(Description)) == 0;
     }
 #endif

Graphics/GraphicsEngine/interface/RenderDevice.h

@@ -343,6 +343,21 @@ DILIGENT_BEGIN_INTERFACE(IRenderDevice, IObject)
                                                   IPipelineStateCache**                  ppPSOCache) PURE;
 
 
+    /// Creates a new super resolution upscaler object.
+
+    /// \param [in]  Desc       - Super resolution upscaler description, see Diligent::SuperResolutionUpscalerDesc for details.
+    /// \param [out] ppUpscaler - Address of the memory location where a pointer to the
+    ///                           super resolution upscaler interface will be written.
+    ///                           The function calls AddRef(), so that the new object will have
+    ///                           one reference.
+    ///
+    /// \remarks    On backends that don't support hardware upscaling, the method will
+    ///             return nullptr.
+    VIRTUAL void METHOD(CreateSuperResolutionUpscaler)(THIS_
+                                                       const SuperResolutionUpscalerDesc REF Desc,
+                                                       ISuperResolutionUpscaler**            ppUpscaler) PURE;
+
+
     /// Creates a deferred context.
 
     /// \param [out] ppContext - Address of the memory location where a pointer to the
@@ -475,6 +490,7 @@ DILIGENT_END_INTERFACE
 #    define IRenderDevice_CreatePipelineResourceSignature(This, ...) CALL_IFACE_METHOD(RenderDevice, CreatePipelineResourceSignature, This, __VA_ARGS__)
 #    define IRenderDevice_CreateDeviceMemory(This, ...)              CALL_IFACE_METHOD(RenderDevice, CreateDeviceMemory,              This, __VA_ARGS__)
 #    define IRenderDevice_CreatePipelineStateCache(This, ...)        CALL_IFACE_METHOD(RenderDevice, CreatePipelineStateCache,        This, __VA_ARGS__)
+#    define IRenderDevice_CreateSuperResolutionUpscaler(This, ...)   CALL_IFACE_METHOD(RenderDevice, CreateSuperResolutionUpscaler,   This, __VA_ARGS__)
 #    define IRenderDevice_CreateDeferredContext(This, ...)           CALL_IFACE_METHOD(RenderDevice, CreateDeferredContext,           This, __VA_ARGS__)
 #    define IRenderDevice_GetAdapterInfo(This)                       CALL_IFACE_METHOD(RenderDevice, GetAdapterInfo,                  This)
 #    define IRenderDevice_GetDeviceInfo(This)                        CALL_IFACE_METHOD(RenderDevice, GetDeviceInfo,                   This)

Graphics/GraphicsEngine/interface/SuperResolutionUpscaler.h

@@ -0,0 +1,183 @@
+/*
+ *  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
+/// Defines Diligent::ISuperResolutionUpscaler interface and related data structures
+
+#include "DeviceObject.h"
+#include "GraphicsTypes.h"
+#include "TextureView.h"
+
+DILIGENT_BEGIN_NAMESPACE(Diligent)
+
+// {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}
+static DILIGENT_CONSTEXPR INTERFACE_ID IID_SuperResolutionUpscaler =
+    {0xa1b2c3d4, 0xe5f6, 0x7890, {0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90}};
+
+
+/// Super resolution upscaler type
+DILIGENT_TYPED_ENUM(SUPER_RESOLUTION_UPSCALER_TYPE, Uint8)
+{
+    /// Spatial upscaling only (single frame, no motion vectors required).
+    SUPER_RESOLUTION_UPSCALER_TYPE_SPATIAL  = 0,
+
+    /// Temporal upscaling (uses motion vectors and history accumulation).
+    SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL = 1,
+
+    SUPER_RESOLUTION_UPSCALER_TYPE_LAST     = SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL
+};
+
+
+/// Super resolution upscaler description
+
+/// This structure describes the super resolution upscaler object and is part of the creation
+/// parameters given to IRenderDevice::CreateSuperResolutionUpscaler().
+struct SuperResolutionUpscalerDesc DILIGENT_DERIVE(DeviceObjectAttribs)
+
+    /// Upscaler type, see Diligent::SUPER_RESOLUTION_UPSCALER_TYPE.
+    SUPER_RESOLUTION_UPSCALER_TYPE Type DEFAULT_INITIALIZER(SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL);
+
+    /// Target (output) texture width.
+    Uint32 OutputWidth            DEFAULT_INITIALIZER(0);
+
+    /// Target (output) texture height.
+    Uint32 OutputHeight           DEFAULT_INITIALIZER(0);
+
+    /// Output texture format.
+    TEXTURE_FORMAT OutputFormat   DEFAULT_INITIALIZER(TEX_FORMAT_RGBA16_FLOAT);
+
+    /// Color input texture format.
+    TEXTURE_FORMAT ColorFormat    DEFAULT_INITIALIZER(TEX_FORMAT_RGBA16_FLOAT);
+
+    /// Depth input texture format.
+    /// Required for temporal upscaling.
+    TEXTURE_FORMAT DepthFormat    DEFAULT_INITIALIZER(TEX_FORMAT_D32_FLOAT);
+
+    /// Motion vectors texture format.
+    /// Required for temporal upscaling.
+    TEXTURE_FORMAT MotionFormat   DEFAULT_INITIALIZER(TEX_FORMAT_RG16_FLOAT);
+
+    /// Input (render) width.
+    /// If zero, the upscaler will calculate optimal render resolution.
+    Uint32 InputWidth             DEFAULT_INITIALIZER(0);
+
+    /// Input (render) height.
+    /// If zero, the upscaler will calculate optimal render resolution.
+    Uint32 InputHeight            DEFAULT_INITIALIZER(0);
+
+    /// Indicates if depth buffer uses reversed-Z (1 at near, 0 at far).
+    Bool ReversedDepth            DEFAULT_INITIALIZER(False);
+};
+typedef struct SuperResolutionUpscalerDesc SuperResolutionUpscalerDesc;
+
+
+/// Super resolution upscaler execute attributes
+
+/// This structure is used by IDeviceContext::ExecuteSuperResolution().
+struct ExecuteSuperResolutionAttribs
+{
+    /// Low-resolution color texture (shader resource view).
+    /// This is the input image to be upscaled.
+    ITextureView* pColorTextureSRV      DEFAULT_INITIALIZER(nullptr);
+
+    /// Depth buffer of the low-resolution render (shader resource view).
+    /// Required for temporal upscaling (SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL).
+    ITextureView* pDepthTextureSRV      DEFAULT_INITIALIZER(nullptr);
+
+    /// Motion vectors texture (shader resource view).
+    /// Required for temporal upscaling (SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL).
+    /// Expected to contain per-pixel 2D motion vectors in pixel space.
+    ITextureView* pMotionVectorsSRV     DEFAULT_INITIALIZER(nullptr);
+
+    /// Output (upscaled) texture (unordered access view or render target view).
+    /// Must match SuperResolutionUpscalerDesc::OutputWidth x OutputHeight.
+    ITextureView* pOutputTextureRTV     DEFAULT_INITIALIZER(nullptr);
+
+    /// Jitter offset X applied to the projection matrix (in pixels).
+    /// Used for temporal upscaling.
+    float JitterX                       DEFAULT_INITIALIZER(0.0f);
+
+    /// Jitter offset Y applied to the projection matrix (in pixels).
+    /// Used for temporal upscaling. 
+    float JitterY                       DEFAULT_INITIALIZER(0.0f);
+
+    /// Set to true to reset temporal history (e.g., on camera cut).
+    Bool Reset                          DEFAULT_INITIALIZER(False);
+};
+typedef struct ExecuteSuperResolutionAttribs ExecuteSuperResolutionAttribs;
+
+
+// clang-format off
+
+#define DILIGENT_INTERFACE_NAME ISuperResolutionUpscaler
+#include "../../../Primitives/interface/DefineInterfaceHelperMacros.h"
+
+#define ISuperResolutionUpscalerInclusiveMethods    \
+    IDeviceObjectInclusiveMethods;   \
+    ISuperResolutionUpscalerMethods SuperResolutionUpscaler
+
+/// Hardware super resolution upscaler interface.
+///
+/// The super resolution upscaler object encapsulates a hardware-accelerated super resolution
+/// effect (e.g., MetalFX on Metal, DirectSR on D3D12).
+/// It is created via IRenderDevice::CreateSuperResolutionUpscaler() and executed
+/// via IDeviceContext::ExecuteSuperResolution().
+DILIGENT_BEGIN_INTERFACE(ISuperResolutionUpscaler, IDeviceObject)
+{
+#if DILIGENT_CPP_INTERFACE
+    /// Returns the super resolution upscaler description used to create the object.
+    virtual const SuperResolutionUpscalerDesc& METHOD(GetDesc)() const override = 0;
+#endif
+
+    /// Returns the recommended render resolution for the current configuration.
+    ///
+    /// \param [out] pWidth  - Recommended render width.
+    /// \param [out] pHeight - Recommended render height.
+    ///
+    /// The upscaler calculates the optimal input resolution based on the
+    /// target resolution specified in SuperResolutionUpscalerDesc.
+    VIRTUAL void METHOD(GetRenderResolution)(THIS_
+                                             Uint32* pWidth,
+                                             Uint32* pHeight) CONST PURE;
+};
+DILIGENT_END_INTERFACE
+
+#include "../../../Primitives/interface/UndefInterfaceHelperMacros.h"
+
+#if DILIGENT_C_INTERFACE
+
+// clang-format off
+
+#    define ISuperResolutionUpscaler_GetDesc(This)                  CALL_IFACE_METHOD(SuperResolutionUpscaler, GetDesc,             This)
+#    define ISuperResolutionUpscaler_GetRenderResolution(This, ...) CALL_IFACE_METHOD(SuperResolutionUpscaler, GetRenderResolution, This, __VA_ARGS__)
+
+// clang-format on
+
+#endif
+
+DILIGENT_END_NAMESPACE // namespace Diligent

Graphics/GraphicsEngine/src/RenderDeviceBase.cpp

@@ -120,9 +120,10 @@ DeviceFeatures EnableDeviceFeatures(const DeviceFeatures& SupportedFeatures,
     ENABLE_FEATURE(NativeMultiDraw,                   "Native multi-draw commands are");
     ENABLE_FEATURE(AsyncShaderCompilation,            "Async shader compilation is");
     ENABLE_FEATURE(FormattedBuffers,                  "Formatted buffers are");
+    ENABLE_FEATURE(SuperResolutionUpscaler,           "Super resolution upscaler is");
     // clang-format on
 
-    ASSERT_SIZEOF(DeviceFeatures, 47, "Did you add a new feature to DeviceFeatures? Please handle its status here (if necessary).");
+    ASSERT_SIZEOF(DeviceFeatures, 48, "Did you add a new feature to DeviceFeatures? Please handle its status here (if necessary).");
 
     return EnabledFeatures;
 }

Graphics/GraphicsEngineD3D11/include/DeviceContextD3D11Impl.hpp

@@ -284,6 +284,10 @@ class DeviceContextD3D11Impl final : public DeviceContextBase<EngineD3D11ImplTra
                                                    SHADING_RATE_COMBINER PrimitiveCombiner,
                                                    SHADING_RATE_COMBINER TextureCombiner) override final;
 
+    /// Implementation of IDeviceContext::ExecuteSuperResolution() in Direct3D11 backend.
+    virtual void DILIGENT_CALL_TYPE ExecuteSuperResolution(const ExecuteSuperResolutionAttribs& Attribs,
+                                                           ISuperResolutionUpscaler*            pUpscaler) override final;
+
     /// Implementation of IDeviceContext::BindSparseResourceMemory() in Direct3D11 backend.
     virtual void DILIGENT_CALL_TYPE BindSparseResourceMemory(const BindSparseResourceMemoryAttribs& Attribs) override final;