Integrated tests

Author: MikhailGorobets

Tests/DiligentCoreAPITest/src/CInterfaceTest.cpp

@@ -39,6 +39,7 @@ extern "C"
     int TestRenderDeviceCInterface_CreateResourceMapping(void* pRenderDevice);
     int TestRenderDeviceCInterface_CreateFence(void* pRenderDevice);
     int TestRenderDeviceCInterface_CreateQuery(void* pRenderDevice);
+    int TestRenderDeviceCInterface_CreateSuperResolutionUpscaler(void* pRenderDevice);
 }
 
 using namespace Diligent;
@@ -53,7 +54,6 @@ TEST(RenderDevice_CInterface, Misc)
     EXPECT_EQ(TestRenderDeviceCInterface_Misc(pDevice), 0);
 }
 
-
 TEST(RenderDevice_CInterface, CreateBuffer)
 {
     auto* pDevice = GPUTestingEnvironment::GetInstance()->GetDevice();
@@ -96,4 +96,10 @@ TEST(RenderDevice_CInterface, CreateQuery)
     EXPECT_EQ(TestRenderDeviceCInterface_CreateQuery(pDevice), 0);
 }
 
+TEST(RenderDevice_CInterface, CreateSuperResolutionUpscaler)
+{
+    auto* pDevice = GPUTestingEnvironment::GetInstance()->GetDevice();
+    EXPECT_EQ(TestRenderDeviceCInterface_CreateSuperResolutionUpscaler(pDevice), 0);
+}
+
 } // namespace

Tests/DiligentCoreAPITest/src/SuperResolutionTest.cpp

@@ -0,0 +1,340 @@
+/*
+ *  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.
+ */
+
+#include "GPUTestingEnvironment.hpp"
+#include "GraphicsAccessories.hpp"
+
+#include "gtest/gtest.h"
+
+using namespace Diligent;
+using namespace Diligent::Testing;
+
+namespace
+{
+
+TEST(SuperResolutionTest, CheckProperties)
+{
+    auto* pEnv    = GPUTestingEnvironment::GetInstance();
+    auto* pDevice = pEnv->GetDevice();
+    if (!pDevice->GetDeviceInfo().Features.SuperResolution)
+    {
+        GTEST_SKIP() << "Super resolution is not supported by this device";
+    }
+
+    const auto& SRProps = pDevice->GetAdapterInfo().SuperResolution;
+    EXPECT_NE(SRProps.Flags, SUPER_RESOLUTION_FLAG_NONE);
+}
+
+TEST(SuperResolutionTest, CreateSpatialUpscaler)
+{
+    auto* pEnv    = GPUTestingEnvironment::GetInstance();
+    auto* pDevice = pEnv->GetDevice();
+    if (!pDevice->GetDeviceInfo().Features.SuperResolution)
+    {
+        GTEST_SKIP() << "Super resolution is not supported by this device";
+    }
+
+    const auto& SRProps = pDevice->GetAdapterInfo().SuperResolution;
+    if (!(SRProps.Flags & SUPER_RESOLUTION_FLAG_SPATIAL))
+    {
+        GTEST_SKIP() << "Spatial super resolution is not supported by this device";
+    }
+
+    GPUTestingEnvironment::ScopedReset EnvironmentAutoReset;
+
+    SuperResolutionUpscalerDesc Desc;
+    Desc.Name         = "Test Spatial Upscaler";
+    Desc.Type         = SUPER_RESOLUTION_UPSCALER_TYPE_SPATIAL;
+    Desc.OutputWidth  = 1920;
+    Desc.OutputHeight = 1080;
+    Desc.OutputFormat = TEX_FORMAT_RGBA16_FLOAT;
+    Desc.ColorFormat  = TEX_FORMAT_RGBA16_FLOAT;
+
+    RefCntAutoPtr<ISuperResolutionUpscaler> pUpscaler;
+    pDevice->CreateSuperResolutionUpscaler(Desc, &pUpscaler);
+    ASSERT_NE(pUpscaler, nullptr) << "Failed to create spatial super resolution upscaler";
+
+    const auto& RetDesc = pUpscaler->GetDesc();
+    EXPECT_EQ(RetDesc.Type, SUPER_RESOLUTION_UPSCALER_TYPE_SPATIAL);
+    EXPECT_EQ(RetDesc.OutputWidth, 1920u);
+    EXPECT_EQ(RetDesc.OutputHeight, 1080u);
+
+    Uint32 RenderWidth  = 0;
+    Uint32 RenderHeight = 0;
+    pUpscaler->GetRenderResolution(&RenderWidth, &RenderHeight);
+    EXPECT_GT(RenderWidth, 0u);
+    EXPECT_GT(RenderHeight, 0u);
+    EXPECT_LE(RenderWidth, 1920u);
+    EXPECT_LE(RenderHeight, 1080u);
+}
+
+TEST(SuperResolutionTest, CreateTemporalUpscaler)
+{
+    auto* pEnv    = GPUTestingEnvironment::GetInstance();
+    auto* pDevice = pEnv->GetDevice();
+    if (!pDevice->GetDeviceInfo().Features.SuperResolution)
+    {
+        GTEST_SKIP() << "Super resolution is not supported by this device";
+    }
+
+    const auto& SRProps = pDevice->GetAdapterInfo().SuperResolution;
+    if (!(SRProps.Flags & SUPER_RESOLUTION_FLAG_TEMPORAL))
+    {
+        GTEST_SKIP() << "Temporal super resolution is not supported by this device";
+    }
+
+    GPUTestingEnvironment::ScopedReset EnvironmentAutoReset;
+
+    SuperResolutionUpscalerDesc Desc;
+    Desc.Name         = "Test Temporal Upscaler";
+    Desc.Type         = SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL;
+    Desc.OutputWidth  = 1920;
+    Desc.OutputHeight = 1080;
+    Desc.OutputFormat = TEX_FORMAT_RGBA16_FLOAT;
+    Desc.ColorFormat  = TEX_FORMAT_RGBA16_FLOAT;
+    Desc.DepthFormat  = TEX_FORMAT_D32_FLOAT;
+    Desc.MotionFormat = TEX_FORMAT_RG16_FLOAT;
+
+    RefCntAutoPtr<ISuperResolutionUpscaler> pUpscaler;
+    pDevice->CreateSuperResolutionUpscaler(Desc, &pUpscaler);
+    ASSERT_NE(pUpscaler, nullptr) << "Failed to create temporal super resolution upscaler";
+
+    const auto& RetDesc = pUpscaler->GetDesc();
+    EXPECT_EQ(RetDesc.Type, SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL);
+    EXPECT_EQ(RetDesc.OutputWidth, 1920u);
+    EXPECT_EQ(RetDesc.OutputHeight, 1080u);
+
+    Uint32 RenderWidth  = 0;
+    Uint32 RenderHeight = 0;
+    pUpscaler->GetRenderResolution(&RenderWidth, &RenderHeight);
+    EXPECT_GT(RenderWidth, 0u);
+    EXPECT_GT(RenderHeight, 0u);
+    EXPECT_LE(RenderWidth, 1920u);
+    EXPECT_LE(RenderHeight, 1080u);
+}
+
+TEST(SuperResolutionTest, ExecuteSpatialUpscaler)
+{
+    auto* pEnv    = GPUTestingEnvironment::GetInstance();
+    auto* pDevice = pEnv->GetDevice();
+    if (!pDevice->GetDeviceInfo().Features.SuperResolution)
+    {
+        GTEST_SKIP() << "Super resolution is not supported by this device";
+    }
+
+    const auto& SRProps = pDevice->GetAdapterInfo().SuperResolution;
+    if (!(SRProps.Flags & SUPER_RESOLUTION_FLAG_SPATIAL))
+    {
+        GTEST_SKIP() << "Spatial super resolution is not supported by this device";
+    }
+
+    GPUTestingEnvironment::ScopedReset EnvironmentAutoReset;
+
+    constexpr Uint32 OutputWidth  = 256;
+    constexpr Uint32 OutputHeight = 256;
+
+    // Create upscaler
+    SuperResolutionUpscalerDesc UpscalerDesc;
+    UpscalerDesc.Name         = "Test Spatial Execute Upscaler";
+    UpscalerDesc.Type         = SUPER_RESOLUTION_UPSCALER_TYPE_SPATIAL;
+    UpscalerDesc.OutputWidth  = OutputWidth;
+    UpscalerDesc.OutputHeight = OutputHeight;
+    UpscalerDesc.OutputFormat = TEX_FORMAT_RGBA16_FLOAT;
+    UpscalerDesc.ColorFormat  = TEX_FORMAT_RGBA16_FLOAT;
+
+    RefCntAutoPtr<ISuperResolutionUpscaler> pUpscaler;
+    pDevice->CreateSuperResolutionUpscaler(UpscalerDesc, &pUpscaler);
+    ASSERT_NE(pUpscaler, nullptr);
+
+    Uint32 RenderWidth  = 0;
+    Uint32 RenderHeight = 0;
+    pUpscaler->GetRenderResolution(&RenderWidth, &RenderHeight);
+    ASSERT_GT(RenderWidth, 0u);
+    ASSERT_GT(RenderHeight, 0u);
+
+    // Create input color texture
+    TextureDesc ColorTexDesc;
+    ColorTexDesc.Name      = "SR Color Input";
+    ColorTexDesc.Type      = RESOURCE_DIM_TEX_2D;
+    ColorTexDesc.Width     = RenderWidth;
+    ColorTexDesc.Height    = RenderHeight;
+    ColorTexDesc.Format    = TEX_FORMAT_RGBA16_FLOAT;
+    ColorTexDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_RENDER_TARGET;
+    ColorTexDesc.Usage     = USAGE_DEFAULT;
+
+    RefCntAutoPtr<ITexture> pColorTex;
+    pDevice->CreateTexture(ColorTexDesc, nullptr, &pColorTex);
+    ASSERT_NE(pColorTex, nullptr);
+
+    // Create output texture
+    TextureDesc OutputTexDesc;
+    OutputTexDesc.Name      = "SR Output";
+    OutputTexDesc.Type      = RESOURCE_DIM_TEX_2D;
+    OutputTexDesc.Width     = OutputWidth;
+    OutputTexDesc.Height    = OutputHeight;
+    OutputTexDesc.Format    = TEX_FORMAT_RGBA16_FLOAT;
+    OutputTexDesc.BindFlags = BIND_RENDER_TARGET | BIND_UNORDERED_ACCESS;
+    OutputTexDesc.Usage     = USAGE_DEFAULT;
+
+    RefCntAutoPtr<ITexture> pOutputTex;
+    pDevice->CreateTexture(OutputTexDesc, nullptr, &pOutputTex);
+    ASSERT_NE(pOutputTex, nullptr);
+
+    // Execute spatial upscaling
+    auto* pContext = pEnv->GetDeviceContext();
+
+    ExecuteSuperResolutionAttribs Attribs;
+    Attribs.pColorTextureSRV  = pColorTex->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
+    Attribs.pOutputTextureRTV = pOutputTex->GetDefaultView(TEXTURE_VIEW_RENDER_TARGET);
+
+    pContext->ExecuteSuperResolution(Attribs, pUpscaler);
+    pContext->Flush();
+    pContext->WaitForIdle();
+}
+
+TEST(SuperResolutionTest, ExecuteTemporalUpscaler)
+{
+    auto* pEnv    = GPUTestingEnvironment::GetInstance();
+    auto* pDevice = pEnv->GetDevice();
+    if (!pDevice->GetDeviceInfo().Features.SuperResolution)
+    {
+        GTEST_SKIP() << "Super resolution is not supported by this device";
+    }
+
+    const auto& SRProps = pDevice->GetAdapterInfo().SuperResolution;
+    if (!(SRProps.Flags & SUPER_RESOLUTION_FLAG_TEMPORAL))
+    {
+        GTEST_SKIP() << "Temporal super resolution is not supported by this device";
+    }
+
+    GPUTestingEnvironment::ScopedReset EnvironmentAutoReset;
+
+    constexpr Uint32 OutputWidth  = 256;
+    constexpr Uint32 OutputHeight = 256;
+
+    // Create upscaler
+    SuperResolutionUpscalerDesc UpscalerDesc;
+    UpscalerDesc.Name         = "Test Temporal Execute Upscaler";
+    UpscalerDesc.Type         = SUPER_RESOLUTION_UPSCALER_TYPE_TEMPORAL;
+    UpscalerDesc.OutputWidth  = OutputWidth;
+    UpscalerDesc.OutputHeight = OutputHeight;
+    UpscalerDesc.OutputFormat = TEX_FORMAT_RGBA16_FLOAT;
+    UpscalerDesc.ColorFormat  = TEX_FORMAT_RGBA16_FLOAT;
+    UpscalerDesc.DepthFormat  = TEX_FORMAT_D32_FLOAT;
+    UpscalerDesc.MotionFormat = TEX_FORMAT_RG16_FLOAT;
+
+    RefCntAutoPtr<ISuperResolutionUpscaler> pUpscaler;
+    pDevice->CreateSuperResolutionUpscaler(UpscalerDesc, &pUpscaler);
+    ASSERT_NE(pUpscaler, nullptr);
+
+    Uint32 RenderWidth  = 0;
+    Uint32 RenderHeight = 0;
+    pUpscaler->GetRenderResolution(&RenderWidth, &RenderHeight);
+    ASSERT_GT(RenderWidth, 0u);
+    ASSERT_GT(RenderHeight, 0u);
+
+    // Create input color texture
+    TextureDesc ColorTexDesc;
+    ColorTexDesc.Name      = "SR Color Input";
+    ColorTexDesc.Type      = RESOURCE_DIM_TEX_2D;
+    ColorTexDesc.Width     = RenderWidth;
+    ColorTexDesc.Height    = RenderHeight;
+    ColorTexDesc.Format    = TEX_FORMAT_RGBA16_FLOAT;
+    ColorTexDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_RENDER_TARGET;
+    ColorTexDesc.Usage     = USAGE_DEFAULT;
+
+    RefCntAutoPtr<ITexture> pColorTex;
+    pDevice->CreateTexture(ColorTexDesc, nullptr, &pColorTex);
+    ASSERT_NE(pColorTex, nullptr);
+
+    // Create depth texture
+    TextureDesc DepthTexDesc;
+    DepthTexDesc.Name      = "SR Depth Input";
+    DepthTexDesc.Type      = RESOURCE_DIM_TEX_2D;
+    DepthTexDesc.Width     = RenderWidth;
+    DepthTexDesc.Height    = RenderHeight;
+    DepthTexDesc.Format    = TEX_FORMAT_D32_FLOAT;
+    DepthTexDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_DEPTH_STENCIL;
+    DepthTexDesc.Usage     = USAGE_DEFAULT;
+
+    RefCntAutoPtr<ITexture> pDepthTex;
+    pDevice->CreateTexture(DepthTexDesc, nullptr, &pDepthTex);
+    ASSERT_NE(pDepthTex, nullptr);
+
+    // Create motion vectors texture
+    TextureDesc MotionTexDesc;
+    MotionTexDesc.Name      = "SR Motion Vectors";
+    MotionTexDesc.Type      = RESOURCE_DIM_TEX_2D;
+    MotionTexDesc.Width     = RenderWidth;
+    MotionTexDesc.Height    = RenderHeight;
+    MotionTexDesc.Format    = TEX_FORMAT_RG16_FLOAT;
+    MotionTexDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_RENDER_TARGET;
+    MotionTexDesc.Usage     = USAGE_DEFAULT;
+
+    RefCntAutoPtr<ITexture> pMotionTex;
+    pDevice->CreateTexture(MotionTexDesc, nullptr, &pMotionTex);
+    ASSERT_NE(pMotionTex, nullptr);
+
+    // Create output texture
+    TextureDesc OutputTexDesc;
+    OutputTexDesc.Name      = "SR Output";
+    OutputTexDesc.Type      = RESOURCE_DIM_TEX_2D;
+    OutputTexDesc.Width     = OutputWidth;
+    OutputTexDesc.Height    = OutputHeight;
+    OutputTexDesc.Format    = TEX_FORMAT_RGBA16_FLOAT;
+    OutputTexDesc.BindFlags = BIND_RENDER_TARGET | BIND_UNORDERED_ACCESS;
+    OutputTexDesc.Usage     = USAGE_DEFAULT;
+
+    RefCntAutoPtr<ITexture> pOutputTex;
+    pDevice->CreateTexture(OutputTexDesc, nullptr, &pOutputTex);
+    ASSERT_NE(pOutputTex, nullptr);
+
+    // Execute temporal upscaling with reset
+    auto* pContext = pEnv->GetDeviceContext();
+
+    ExecuteSuperResolutionAttribs Attribs;
+    Attribs.pColorTextureSRV  = pColorTex->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
+    Attribs.pDepthTextureSRV  = pDepthTex->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
+    Attribs.pMotionVectorsSRV = pMotionTex->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
+    Attribs.pOutputTextureRTV = pOutputTex->GetDefaultView(TEXTURE_VIEW_RENDER_TARGET);
+    Attribs.JitterX           = 0.5f;
+    Attribs.JitterY           = -0.5f;
+    Attribs.Reset             = True;
+
+    pContext->ExecuteSuperResolution(Attribs, pUpscaler);
+
+    // Execute a second frame without reset
+    Attribs.JitterX = -0.25f;
+    Attribs.JitterY = 0.25f;
+    Attribs.Reset   = False;
+
+    pContext->ExecuteSuperResolution(Attribs, pUpscaler);
+
+    pContext->Flush();
+    pContext->WaitForIdle();
+}
+
+} // namespace