dlss and fsr plugin added

dlss is not active. FSR is standart mode force active. We will make the arrangements together with Gurkan

Config/DefaultEngine.ini

@@ -98,7 +98,7 @@ r.DefaultFeature.LocalExposure.ShadowContrastScale=0.800000
 r.DefaultFeature.MotionBlur=False
 r.DefaultFeature.LensFlare=False
 r.TemporalAA.Upsampling=True
-r.AntiAliasingMethod=2
+r.AntiAliasingMethod=4
 r.MSAACount=1
 r.DefaultFeature.LightUnits=1
 r.DefaultBackBufferPixelFormat=4
@@ -319,3 +319,15 @@ RuntimeGeneration=Dynamic
 [/Script/AIModule.CrowdManager]
 MaxAgentRadius=100.000000
 
+[/Script/FFXFSR3Settings.FFXFSR3Settings]
+r.FidelityFX.FSR3.EnabledInEditorViewport=True
+r.FidelityFX.FSR3.UseSSRExperimentalDenoiser=True
+r.FidelityFX.FSR3.QualityMode=2
+r.FidelityFX.FSR3.Enabled=True
+
+[/Script/DLSS.DLSSSettings]
+bEnableDLSSInEditorViewports=True
+bEnableDLSSD3D12=False
+bEnableDLSSD3D11=False
+bEnableDLSSVulkan=False
+

Plugins/Marketplace/DLSS/Config/FilterPlugin.ini

@@ -0,0 +1,12 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll
+
+
+/Config/...
+

Plugins/Marketplace/DLSS/DLSS.uplugin

@@ -0,0 +1,87 @@
+{
+	"FileVersion": 3,
+	"Version": 44,
+	"VersionName": "4.0.0-NGX310.1.0.0",
+	"FriendlyName": "NVIDIA DLSS Super Resolution/Ray Reconstruction/DLAA",
+	"Description": "DLSS Super Resolution boosts frame rates by rendering fewer pixels and using AI to output high resolution frames. DLSS Ray Reconstruction enhances image quality by generating high-quality pixels between sampled rays for intensive ray traced content. DLAA is an AI-based anti-aliasing mode to improve image quality.",
+	"Category": "Rendering",
+	"CreatedBy": "NVIDIA",
+	"CreatedByURL": "https://developer.nvidia.com/dlss",
+	"DocsURL": "",
+	"MarketplaceURL": "https://www.unrealengine.com/marketplace/en-US/product/nvidia-dlss",
+	"SupportURL": "mailto:DLSS-Support@nvidia.com",
+	"EngineVersion": "5.5.0",
+	"CanContainContent": true,
+	"Installed": true,
+	"Modules": [
+		{
+			"Name": "DLSSUtility",
+			"Type": "Runtime",
+			"LoadingPhase": "PostConfigInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		},
+		{
+			"Name": "DLSS",
+			"Type": "Runtime",
+			"LoadingPhase": "PostEngineInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		},
+		{
+			"Name": "DLSSBlueprint",
+			"Type": "Runtime",
+			"LoadingPhase": "PostConfigInit"
+		},
+		{
+			"Name": "NGXRHI",
+			"Type": "Runtime",
+			"LoadingPhase": "PostEngineInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		},
+		{
+			"Name": "NGXD3D11RHI",
+			"Type": "Runtime",
+			"LoadingPhase": "PostEngineInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		},
+		{
+			"Name": "NGXD3D12RHI",
+			"Type": "Runtime",
+			"LoadingPhase": "PostEngineInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		},
+		{
+			"Name": "NGXVulkanRHIPreInit",
+			"Type": "Runtime",
+			"LoadingPhase": "PostConfigInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		},
+		{
+			"Name": "NGXVulkanRHI",
+			"Type": "Runtime",
+			"LoadingPhase": "PostEngineInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		},
+		{
+			"Name": "DLSSEditor",
+			"Type": "Editor",
+			"LoadingPhase": "PostEngineInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		}
+	]
+}

Plugins/Marketplace/DLSS/Shaders/Private/GBufferResolve.usf

@@ -0,0 +1,175 @@
+/*
+* Copyright (c) 2023 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+
+#include "/Engine/Private/Common.ush"
+#include "/Engine/Private/DeferredShadingCommon.ush"
+#include "/Engine/Private/BRDF.ush"
+#include "/Engine/Private/FastMath.ush"
+#include "/Engine/Private/ScreenPass.ush"
+#include "/Engine/Private/RayTracing/RayTracingCommon.ush"
+
+
+#ifndef DIFFUSE_SPECULAR_ALBEDO
+#define DIFFUSE_SPECULAR_ALBEDO 0
+#endif
+
+#ifndef SPECULAR_HITT
+#define SPECULAR_HITT 0
+#endif
+
+SCREEN_PASS_TEXTURE_VIEWPORT(InputViewPort)
+SCREEN_PASS_TEXTURE_VIEWPORT(OutputViewPort)
+
+
+#include "/Engine/Private/PositionReconstructionCommon.ush"
+
+Texture2D<float4> PassthroughDiffuse;
+Texture2D<float4> PassthroughSpecular;
+Texture2D<float4> PassthroughNormalRoughness;
+Texture2D<float> PassthroughDepth;
+Texture2D<float> ReflectionHitDistance;
+
+float3 EnvBRDFApproxRTG(float3 SpecularColor, float alpha, float NoV)
+{
+	NoV = abs(NoV);
+	// [Ray Tracing Gems, Chapter 32]
+	float4 X;
+	X.x = 1.f;
+	X.y = NoV;
+	X.z = NoV * NoV;
+	X.w = NoV * X.z;
+
+	float4 Y;
+	Y.x = 1.f;
+	Y.y = alpha;
+	Y.z = alpha * alpha;
+	Y.w = alpha * Y.z;
+
+	float2x2 M1 = float2x2(0.99044f, -1.28514f, 1.29678f, -0.755907f);
+	float3x3 M2 = float3x3(1.f, 2.92338f, 59.4188f, 20.3225f, -27.0302f, 222.592f, 121.563f, 626.13f, 316.627f);
+
+	float2x2 M3 = float2x2(0.0365463f, 3.32707, 9.0632f, -9.04756);
+	float3x3 M4 = float3x3(1.f, 3.59685f, -1.36772f, 9.04401f, -16.3174f, 9.22949f, 5.56589f, 19.7886f, -20.2123f);
+
+	float bias = dot(mul(M1, X.xy), Y.xy) * rcp(dot(mul(M2, X.xyw), Y.xyw));
+	float scale = dot(mul(M3, X.xy), Y.xy) * rcp(dot(mul(M4, X.xzw), Y.xyw));
+
+	// This is a hack for specular reflectance of 0
+	bias *= saturate(SpecularColor.g * 50);
+
+	return mad(SpecularColor, max(0, scale), max(0, bias));
+}
+
+void GBufferResolvePixelShader(
+	float2 InUV : TEXCOORD0,
+	float4 SvPosition : SV_Position
+#if DIFFUSE_SPECULAR_ALBEDO
+	, out float4 OutDiffuseAlbedo : SV_Target0
+	, out float4 OutSpecularAlbedo : SV_Target1
+	, out float4 OutNormal : SV_Target2
+	, out float OutRoughness : SV_Target3
+	, out float OutDepth : SV_Target4
+#endif
+#if SPECULAR_HITT
+	, out float OutHitT : SV_Target5
+#endif
+)
+{
+	uint2 PixelCoord = uint2(SvPosition.xy + InputViewPort_ViewportMin);
+
+
+#if PASSTHROUGH_FEATURE_BUFFERS
+	// In this case, everything has been pre-composited
+
+#if DIFFUSE_SPECULAR_ALBEDO
+	const float4 GuideDiffuse = PassthroughDiffuse[PixelCoord];
+	const float4 GuideSpecular = PassthroughSpecular[PixelCoord];
+	const float4 GuideNormalRoughness = PassthroughNormalRoughness[PixelCoord];
+	const float GuideDepthData = PassthroughDepth[PixelCoord];
+
+	OutDiffuseAlbedo = float4(GuideDiffuse.xyz, 1.0f);
+	OutSpecularAlbedo = float4(GuideSpecular.xyz, 1.0f);
+	OutNormal = float4(GuideNormalRoughness.xyz * 2.0 - 1.0, GuideNormalRoughness.w);
+	OutRoughness = GuideNormalRoughness.w;
+
+	OutDepth = GuideDepthData;
+#endif
+
+#if SPECULAR_HITT
+	float HitT = ReflectionHitDistance.Load(int3(SvPosition.xy + InputViewPort_ViewportMin, 0));
+
+	OutHitT = HitT;
+#endif
+
+#else
+	const float DeviceZ = SceneTexturesStruct.SceneDepthTexture[PixelCoord].x;
+
+	if (DeviceZ == 0.f)
+	{
+#if DIFFUSE_SPECULAR_ALBEDO
+		const float2 UV = SvPosition.xy * View.BufferSizeAndInvSize.zw;
+		const FRayDesc Ray = CreatePrimaryRay(UV);
+		OutDiffuseAlbedo = 0.2f;
+		OutSpecularAlbedo = 0.2f;
+		OutNormal = float4(-Ray.Direction, 0.5f);
+		OutRoughness = 0.5f;
+		OutDepth = POSITIVE_INFINITY;
+#endif
+
+#if SPECULAR_HITT
+		OutHitT = MaxHalfFloat;
+#endif
+		return;
+	}
+
+	FGBufferData GBuffer = GetGBufferDataUint(PixelCoord, true);
+
+#if DIFFUSE_SPECULAR_ALBEDO
+
+	float3 DiffuseColor = GBuffer.DiffuseColor;
+	float3 SpecularColor = GBuffer.SpecularColor;
+
+	if (UseSubsurfaceProfile(GBuffer.ShadingModelID))
+	{
+		// this is a bit odd, but the diffuse signal is multiplied by this without any conversion tied to metalness
+		// See apply code in PostprocessSubsurface
+		DiffuseColor = GBuffer.StoredBaseColor;
+
+		// the correct value here is a bit debatable, as the skin computes with one value, then applies with another
+		SpecularColor = ComputeF0(GBuffer.Specular, GBuffer.StoredBaseColor, GBuffer.Metallic);
+		//SpecularColor = 1.0;
+	}
+
+	float3 WorldPos = ReconstructWorldPositionFromDepth(ViewportUVToBufferUV(InUV), GBuffer.Depth);
+	float3 RayDirection = normalize(WorldPos - LWCHackToFloat(PrimaryView.WorldCameraOrigin));
+
+	float NoV = saturate(dot(-RayDirection, GBuffer.WorldNormal));
+	float x = NoV * NoV;
+	NoV = x / (x + (1 - NoV) * (1 - NoV));
+	float3 F = EnvBRDFApproxRTG(SpecularColor, Square(GBuffer.Roughness), NoV * 0.75f);
+
+	OutDiffuseAlbedo = float4(DiffuseColor, 1.0f);
+	OutSpecularAlbedo = float4(F, 1.0f);
+	OutNormal = float4(GBuffer.WorldNormal, GBuffer.Roughness);
+	OutRoughness = GBuffer.Roughness;
+
+	OutDepth = GBuffer.Depth;
+#endif
+
+#if SPECULAR_HITT
+	float HitT = ReflectionHitDistance.Load(int3(SvPosition.xy + InputViewPort_ViewportMin, 0));
+
+	OutHitT = HitT;
+#endif
+#endif
+}
+

Plugins/Marketplace/DLSS/Shaders/Private/VelocityCombine.usf

@@ -0,0 +1,193 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "/Engine/Private/Common.ush"
+#include "/Engine/Private/FastMath.ush"
+#include "/Engine/Private/ScreenPass.ush"
+
+#ifndef THREADGROUP_SIZEX
+#define THREADGROUP_SIZEX		8
+#endif
+#ifndef THREADGROUP_SIZEY
+#define THREADGROUP_SIZEY		8
+#endif
+#define THREADGROUP_TOTALSIZE	(THREADGROUP_SIZEX * THREADGROUP_SIZEY)
+
+#ifndef DILATE_MOTION_VECTORS
+#define DILATE_MOTION_VECTORS 0
+#endif
+
+#if DILATE_MOTION_VECTORS
+#define AA_CROSS 1
+float2 TemporalJitterPixels;
+#else
+#endif
+
+Texture2D VelocityTexture;
+SamplerState VelocityTextureSampler;
+SCREEN_PASS_TEXTURE_VIEWPORT(Velocity)
+
+Texture2D DepthTexture;
+SamplerState DepthTextureSampler;
+
+Texture2D<float2> AlternateMotionVectorsTexture;
+
+RWTexture2D<float2>	OutVelocityCombinedTexture;
+SCREEN_PASS_TEXTURE_VIEWPORT(CombinedVelocity)
+
+[numthreads(THREADGROUP_SIZEX, THREADGROUP_SIZEY, 1)]
+void VelocityCombineMain(
+	uint2 GroupId : SV_GroupID,
+	uint2 DispatchThreadId : SV_DispatchThreadID,
+	uint2 GroupThreadId : SV_GroupThreadID,
+	uint GroupIndex : SV_GroupIndex)
+{
+	const bool bInsideViewport = all(DispatchThreadId.xy < CombinedVelocity_ViewportSize);
+	
+	BRANCH
+	if (!bInsideViewport)
+	{
+		return;
+	}
+
+	// CombinedVelocity_ViewportMin is expected to be 0, but in case it is not
+	uint2 OutputPixelPos = CombinedVelocity_ViewportMin + DispatchThreadId;
+
+#if DILATE_MOTION_VECTORS // TODO: 2x2.
+
+	// Screen position of minimum depth.
+	float2 VelocityOffset = float2(0.0, 0.0);
+
+	const float2 ViewportUV = (float2(DispatchThreadId) + 0.5f) * CombinedVelocity_ViewportSizeInverse;
+	
+	// Pixel coordinate of the center of output pixel O in the input viewport.
+	const float2 PPCo = ViewportUV * Velocity_ViewportSize + TemporalJitterPixels;
+
+	// Pixel coordinate of the center of the nearest input pixel K.
+	const float2 PPCk = floor(PPCo) + 0.5;
+
+	const float2 NearestBufferUV = Velocity_ExtentInverse * (Velocity_ViewportMin + PPCk);
+	
+	// FIND MOTION OF PIXEL AND NEAREST IN NEIGHBORHOOD
+	// ------------------------------------------------
+	float3 PosN; // Position of this pixel, possibly later nearest pixel in neighborhood.
+	PosN.xy = ViewportUVToScreenPos(ViewportUV);
+	PosN.z = DepthTexture.SampleLevel(DepthTextureSampler, NearestBufferUV, 0).x;
+
+	{
+		// For motion vector, use camera/dynamic motion from min depth pixel in pattern around pixel.
+		// This enables better quality outline on foreground against different motion background.
+		// Larger 2 pixel distance "x" works best (because AA dilates surface).
+		float4 Depths;
+		Depths.x = DepthTexture.SampleLevel(DepthTextureSampler, NearestBufferUV, 0, int2(-AA_CROSS, -AA_CROSS)).x;
+		Depths.y = DepthTexture.SampleLevel(DepthTextureSampler, NearestBufferUV, 0, int2(AA_CROSS, -AA_CROSS)).x;
+		Depths.z = DepthTexture.SampleLevel(DepthTextureSampler, NearestBufferUV, 0, int2(-AA_CROSS, AA_CROSS)).x;
+		Depths.w = DepthTexture.SampleLevel(DepthTextureSampler, NearestBufferUV, 0, int2(AA_CROSS, AA_CROSS)).x;
+
+		float2 DepthOffset = float2(AA_CROSS, AA_CROSS);
+		float DepthOffsetXx = float(AA_CROSS);
+#if HAS_INVERTED_Z_BUFFER
+		// Nearest depth is the largest depth (depth surface 0=far, 1=near).
+		if (Depths.x > Depths.y)
+		{
+			DepthOffsetXx = -AA_CROSS;
+		}
+		if (Depths.z > Depths.w)
+		{
+			DepthOffset.x = -AA_CROSS;
+		}
+		float DepthsXY = max(Depths.x, Depths.y);
+		float DepthsZW = max(Depths.z, Depths.w);
+		if (DepthsXY > DepthsZW)
+		{
+			DepthOffset.y = -AA_CROSS;
+			DepthOffset.x = DepthOffsetXx;
+		}
+		float DepthsXYZW = max(DepthsXY, DepthsZW);
+		if (DepthsXYZW > PosN.z)
+		{
+			// This is offset for reading from velocity texture.
+			// This supports half or fractional resolution velocity textures.
+			// With the assumption that UV position scales between velocity and color.
+			VelocityOffset = DepthOffset * Velocity_ExtentInverse;
+			// This is [0 to 1] flipped in Y.
+			//PosN.xy = ScreenPos + DepthOffset * ViewportSize.zw * 2.0;
+			PosN.z = DepthsXYZW;
+		}
+#else // !HAS_INVERTED_Z_BUFFER
+#error Fix me!
+#endif // !HAS_INVERTED_Z_BUFFER
+	}
+	// Camera motion for pixel or nearest pixel (in ScreenPos space).
+	bool OffScreen = false;
+	float Velocity = 0;
+	float HistoryBlur = 0;
+
+	float4 ThisClip = float4(PosN.xy, PosN.z, 1);
+	float4 PrevClip = mul(ThisClip, View.ClipToPrevClip);
+	float2 PrevScreen = PrevClip.xy / PrevClip.w;
+	float2 BackN = PosN.xy - PrevScreen;
+
+	float2 BackTemp = BackN * Velocity_ViewportSize;
+
+	float4 VelocityN = VelocityTexture.SampleLevel(VelocityTextureSampler, NearestBufferUV + VelocityOffset, 0);
+	bool DynamicN = VelocityN.x > 0.0;
+	if (DynamicN)
+	{
+		BackN = DecodeVelocityFromTexture(VelocityN).xy;
+	}
+	BackTemp = BackN * CombinedVelocity_ViewportSize;
+	OutVelocityCombinedTexture[OutputPixelPos].xy = -BackTemp * float2(0.5, -0.5);
+#else
+	const uint2 PixelPos = DispatchThreadId + Velocity_ViewportMin;
+	float4 EncodedVelocity = VelocityTexture[PixelPos];
+	float Depth = DepthTexture[PixelPos].x;
+	
+	float2 Velocity = 0.0f;
+
+	if (EncodedVelocity.x > 0.0f)
+	{
+		Velocity = DecodeVelocityFromTexture(EncodedVelocity).xy;
+	}
+	else
+	{
+		float4 ClipPos;
+		ClipPos.xy = SvPositionToScreenPosition(float4(PixelPos.xy + 0.5f, 0.0f, 1.0f)).xy;
+		ClipPos.z = Depth;
+		ClipPos.w = 1;
+
+		float4 PrevClipPos = mul(ClipPos, View.ClipToPrevClip);
+
+		if (PrevClipPos.w > 0)
+		{
+			float2 PrevScreen = PrevClipPos.xy / PrevClipPos.w;
+			Velocity = ClipPos.xy - PrevScreen.xy;
+		}
+	}
+
+	float2 OutVelocity = Velocity * float2(0.5, -0.5) * CombinedVelocity_ViewportSize;
+
+#if SUPPORT_ALTERNATE_MOTION_VECTOR
+	const float2 EncodedAltVelocity = AlternateMotionVectorsTexture[PixelPos];
+
+	if (EncodedAltVelocity.x > 0.0f)
+	{
+		float2 DecodedVelocity = DecodeVelocityFromTexture(float4(EncodedAltVelocity, 0.0f, 0.0f)).xy;
+
+		// we encode in the orientation DLSS expects, so the extra negate it to make them consistent with the ones
+		// generated above
+		OutVelocity = -1.0f * DecodedVelocity * CombinedVelocity_ViewportSize;
+	}
+#endif
+
+	OutVelocityCombinedTexture[OutputPixelPos].xy = -OutVelocity;
+#endif
+}

Plugins/Marketplace/DLSS/Source/DLSS/DLSS.Build.cs

@@ -0,0 +1,84 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION.  All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+using System.IO;
+
+public class DLSS : ModuleRules
+{
+	public virtual string [] SupportedDynamicallyLoadedNGXRHIModules(ReadOnlyTargetRules Target)
+	{
+		if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
+		{
+			return new string[]
+			{
+				"NGXD3D11RHI",
+				"NGXD3D12RHI",
+				"NGXVulkanRHI"
+			};
+		}
+		return new string[] { "" };
+	}
+
+	public DLSS(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+#if !UE_5_3_OR_LATER
+		// bUseRTTI for typeid so we can detect incorrect custom upscaler history at runtime
+		bUseRTTI = true;
+#endif
+
+		PublicIncludePaths.AddRange(
+			new string[] {
+				// ... add public include paths required here ...
+			}
+			);
+				
+		
+		// for ITemporalUpscaler in PostProcess/TemporalAA.h
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				Path.Combine(GetModuleDirectory("Renderer"), "Private"),
+				// ... add other private include paths required here ...
+			}
+			);
+			
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				
+				// ... add other public dependencies that you statically link with here ...
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Core",
+					"CoreUObject",
+					"EngineSettings",
+					"Engine",
+					"RenderCore",
+					"Renderer",
+					"RHI",
+					"NGX",
+					"Projects",
+                    "DeveloperSettings",
+					"DLSSUtility",
+					"NGXRHI",
+				// ... add private dependencies that you statically link with here ...	
+			}
+			);
+
+		DynamicallyLoadedModuleNames.AddRange(SupportedDynamicallyLoadedNGXRHIModules(Target));
+	}
+}

Plugins/Marketplace/DLSS/Source/DLSS/Private/DLSS.cpp

@@ -0,0 +1,528 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+#include "DLSS.h"
+#include "Misc/EngineVersion.h"
+#include "CoreMinimal.h"
+#include "DLSSUpscalerPrivate.h"
+
+#include "DLSSUpscaler.h"
+#include "DLSSDenoiser.h"
+
+#include "NGXRHI.h"
+
+#include "Modules/ModuleManager.h"
+#include "Interfaces/IPluginManager.h"
+
+#include "GeneralProjectSettings.h"
+#include "DLSSSettings.h"
+
+#include "Runtime/Launch/Resources/Version.h"
+#include "SceneViewExtension.h"
+#include "SceneView.h"
+#include "Misc/MessageDialog.h"
+
+
+#define LOCTEXT_NAMESPACE "FDLSSModule"
+DEFINE_LOG_CATEGORY(LogDLSS);
+
+static TAutoConsoleVariable<int32> CVarNGXBinarySearchOrder(
+	TEXT("r.NGX.BinarySearchOrder"),
+	0,
+	TEXT("0: automatic: (default)\n")
+	TEXT("   use custom binaries from project and launch folder $(ProjectDir)/Binaries/ThirdParty/NVIDIA/NGX/$(Platform) if present\n")
+	TEXT("   fallback to generic binaries from plugin folder\n")
+	TEXT("1: force generic binaries from plugin folder, fail if not found\n")
+	TEXT("2: force custom binaries from project or launch folder, fail if not found\n")
+	TEXT("3: force generic development binaries from plugin folder, fail if not found. This is only supported in non-shipping build configurations\n"),
+		ECVF_ReadOnly);
+
+static TAutoConsoleVariable<int32> CVarNGXEnable(
+	TEXT("r.NGX.Enable"), 1,
+	TEXT("Whether the NGX library should be loaded. This allow to have the DLSS plugin enabled but avoiding potential ")
+	TEXT("incompatibilities by skipping the driver side NGX parts of DLSS. Can also be set on the command line via -ngxenable and -ngxdisable"),
+	ECVF_ReadOnly);
+
+static TAutoConsoleVariable<int32> CVarNGXEnableAllowCommandLine(
+	TEXT("r.NGX.Enable.AllowCommandLine"), 0,
+	TEXT("Whether to allow to override r.NGX.Enable with -ngxenable and -ngxdisable"),
+	ECVF_ReadOnly);
+
+static TAutoConsoleVariable<int32> CVarNGXDLSSMinimumWindowsBuildVersion(
+	TEXT("r.NGX.DLSS.MinimumWindowsBuildVersion"), 16299,
+	TEXT("Sets the minimum Windows 10 build version required to enable DLSS. (default: 16299 for v1709, Windows 10 Fall 2017 Creators Update 64-bit)"),
+	ECVF_Default
+);
+
+static TAutoConsoleVariable<int32> CVarNGXProjectIdentifier(
+	TEXT("r.NGX.ProjectIdentifier"),
+	0,
+	TEXT("0: automatic: (default)\n")
+	TEXT("   use NVIDIA NGX Application ID if non-zero, otherwise use UE Project ID)\n")
+	TEXT("1: force UE Project ID\n")
+	TEXT("2: force NVIDIA NGX Application ID (set via the Project Settings -> NVIDIA DLSS plugin)\n"),
+	ECVF_ReadOnly);
+
+
+static TAutoConsoleVariable<bool> CVarNGXAutomationEnable(
+	TEXT("r.NGX.Automation.Enable"),
+	false,
+	TEXT("Enable automation for NGX DLSS image quality and performance evaluation. (default = 0)\n"),
+	ECVF_RenderThreadSafe);
+
+static TAutoConsoleVariable<int> CVarNGXAutomationViewIndex(
+	TEXT("r.NGX.Automation.ViewIndex"),
+	0,
+	TEXT("Select which view to use with NGX DLSS image quality and performance automation. (default = 0). \n"),
+	ECVF_RenderThreadSafe);
+
+static TAutoConsoleVariable<int> CVarNGXAutomationNonGameViews(
+	TEXT("r.NGX.Automation.NonGameViews"),
+	0,
+	TEXT("Enable NGX DLSS image quality and performance automation for non-game views. (default = 0). \n"),
+	ECVF_RenderThreadSafe);
+
+
+class FNGXAutomationViewExtension final : public FSceneViewExtensionBase
+{
+public:
+	FNGXAutomationViewExtension(const FAutoRegister& AutoRegister): FSceneViewExtensionBase(AutoRegister)	
+	{
+		FSceneViewExtensionIsActiveFunctor IsActiveFunctor;
+
+		IsActiveFunctor.IsActiveFunction = [](const ISceneViewExtension* SceneViewExtension, const FSceneViewExtensionContext& Context)
+		{
+			return CVarNGXAutomationEnable.GetValueOnAnyThread();
+		};
+
+		IsActiveThisFrameFunctions.Add(IsActiveFunctor);
+	}
+
+	virtual void SetupViewFamily(FSceneViewFamily& InViewFamily) {}
+	virtual void SetupView(FSceneViewFamily& InViewFamily, FSceneView& InView) {}
+	virtual void SetupViewPoint(APlayerController* Player, FMinimalViewInfo& InViewInfo) {}
+	virtual void BeginRenderViewFamily(FSceneViewFamily& InViewFamily) {}
+	virtual void PreRenderView_RenderThread(FRDGBuilder& GraphBuilder, FSceneView& InView) final {}
+	virtual void PreRenderViewFamily_RenderThread(FRDGBuilder& GraphBuilder, FSceneViewFamily& InViewFamily) final
+	{
+		int32 ViewIndex = CVarNGXAutomationViewIndex.GetValueOnRenderThread();
+
+		if (InViewFamily.Views.IsValidIndex(ViewIndex))
+		{
+			const FSceneView* View = InViewFamily.Views[ViewIndex];
+			if (View->bIsGameView || CVarNGXAutomationNonGameViews.GetValueOnRenderThread())
+			{
+				SCOPED_DRAW_EVENTF(GraphBuilder.RHICmdList, r_NGX_Automation_Enable, TEXT("{\"camera\":{\"position\":{\"x\": %f, \"y\": %f, \"z\": %f},\"rotation\":{\"pitch\": %f, \"roll\": %f, \"yaw\": %f}}}"),
+					View->ViewLocation.X, View->ViewLocation.Y, View->ViewLocation.Z,
+					View->ViewRotation.Pitch, View->ViewRotation.Roll, View->ViewRotation.Yaw);
+			}
+		}
+	}
+};
+
+void FDLSSModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+	UE_LOG(LogDLSS, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+
+	if (!GDynamicRHI)
+	{
+		UE_LOG(LogDLSS, Log, TEXT("NVIDIA NGX DLSS requires an RHI"));
+		NGXSupport = ENGXSupport::NotSupported;
+		return;
+	}
+
+	// Get the base directory of this plugin
+	const FString PluginBaseDir = IPluginManager::Get().FindPlugin(TEXT("DLSS"))->GetBaseDir();
+	const FString NGXBinariesDir = FPaths::Combine(*PluginBaseDir, TEXT("Binaries/ThirdParty/Win64/"));
+	const FString RHIName = GDynamicRHI->GetName();
+
+	UE_LOG(LogDLSS, Log, TEXT("PluginBaseDir %s"), *PluginBaseDir);
+	UE_LOG(LogDLSS, Log, TEXT("NGXBinariesDir %s"), *NGXBinariesDir);
+	UE_LOG(LogDLSS, Log, TEXT("GDynamicRHIName %s %s"), RHIVendorIdToString(), *RHIName );
+
+	bool bLoadLibraries = CVarNGXEnable.GetValueOnAnyThread() != 0;
+	if (CVarNGXEnableAllowCommandLine.GetValueOnAnyThread())
+	{
+		if (FParse::Param(FCommandLine::Get(), TEXT("ngxenable")))
+		{
+			bLoadLibraries = true;
+		}
+		else if (FParse::Param(FCommandLine::Get(), TEXT("ngxdisable")))
+		{
+			bLoadLibraries = false;
+		}
+	}
+
+	const int32 NGXDLSSMinimumWindowsBuildVersion = CVarNGXDLSSMinimumWindowsBuildVersion.GetValueOnAnyThread();
+	
+	if (!IsRHIDeviceNVIDIA())
+	{
+		UE_LOG(LogDLSS, Log, TEXT("NVIDIA NGX DLSS requires an NVIDIA RTX series graphics card"));
+		NGXSupport = ENGXSupport::NotSupportedIncompatibleHardware;
+	}
+#if PLATFORM_WINDOWS
+	else if (NGXDLSSMinimumWindowsBuildVersion > 0 && !FPlatformMisc::VerifyWindowsVersion(10, 0
+		#if PLATFORM_DESKTOP
+		, NGXDLSSMinimumWindowsBuildVersion
+		#endif
+	))
+	{
+		// From https://docs.microsoft.com/en-us/windows/release-information/
+		UE_LOG(LogDLSS, Log, TEXT("NVIDIA NGX DLSS requires at least Windows 10, build %u "), NGXDLSSMinimumWindowsBuildVersion);
+		NGXSupport = ENGXSupport::NotSupportedOperatingSystemOutOfDate;
+	}
+#endif
+	else if (!bLoadLibraries)
+	{
+		UE_LOG(LogDLSS, Log, TEXT("NVIDIA NGX library loading has been disabled with r.NGX.Enable=0"));
+		NGXSupport = ENGXSupport::NotSupported;
+	}
+	else
+	{
+		const ERHIInterfaceType RHIType = RHIGetInterfaceType();
+
+		const bool bIsDX12 = (RHIType == ERHIInterfaceType::D3D12) && GetDefault<UDLSSSettings>()->bEnableDLSSD3D12;
+		const bool bIsDX11 = (RHIType == ERHIInterfaceType::D3D11) && GetDefault<UDLSSSettings>()->bEnableDLSSD3D11;
+		const bool bIsVulkan = (RHIType == ERHIInterfaceType::Vulkan) && GetDefault<UDLSSSettings>()->bEnableDLSSVulkan;
+		const TCHAR* NGXRHIModuleName = nullptr;
+
+		NGXSupport = (bIsDX11 || bIsDX12 || bIsVulkan) ? ENGXSupport::Supported : ENGXSupport::NotSupported; 
+
+		if (NGXSupport == ENGXSupport::Supported)
+		{
+			if (bIsDX11)
+			{
+				NGXRHIModuleName = TEXT("NGXD3D11RHI");
+			}
+			else if (bIsDX12)
+			{
+				NGXRHIModuleName = TEXT("NGXD3D12RHI");
+			}
+			else if (bIsVulkan)
+			{
+				NGXRHIModuleName = TEXT("NGXVulkanRHI");
+			}
+
+
+			uint32 NGXAppID = GetDefault<UDLSSSettings>()->NVIDIANGXApplicationId;
+			UE_LOG(LogDLSS, Log, TEXT("Plugin settings: NGXAppId = %u"), NGXAppID);
+
+			if (NGXAppID != 0)
+			{
+				UE_LOG(LogDLSS, Log, TEXT("NGX Application ID is specified, overriding the Project ID. Please refer to https://developer.nvidia.com/dlss."));
+			}
+			else
+			{
+				UE_LOG(LogDLSS, Log, TEXT("NGX Application ID not specified, using the Project ID by default."));
+			}
+
+			bool bAllowOTAUpdate = GetDefault<UDLSSSettings>()->bAllowOTAUpdate;
+			if (FParse::Param(FCommandLine::Get(), TEXT("ngxenableota")))
+			{
+				bAllowOTAUpdate = true;
+			}
+			else if (FParse::Param(FCommandLine::Get(), TEXT("ngxdisableota")))
+			{
+				bAllowOTAUpdate = false;
+			}
+
+			FNGXRHICreateArguments Arguments;
+			Arguments.PluginBaseDir = PluginBaseDir;
+			Arguments.DynamicRHI = GDynamicRHI;
+			Arguments.NGXBinariesSearchOrder = ENGXBinariesSearchOrder(FMath::Clamp(CVarNGXBinarySearchOrder.GetValueOnAnyThread(), int32(ENGXBinariesSearchOrder::MinValue), int32(ENGXBinariesSearchOrder::MaxValue)));
+
+			Arguments.ProjectIdentifier = ENGXProjectIdentifier(FMath::Clamp(CVarNGXProjectIdentifier.GetValueOnAnyThread(), int32(ENGXProjectIdentifier::MinValue), int32(ENGXProjectIdentifier::MaxValue)));
+			Arguments.NGXAppId = NGXAppID;
+			Arguments.UnrealEngineVersion = FString::Printf(TEXT("%u.%u"), FEngineVersion::Current().GetMajor(), FEngineVersion::Current().GetMinor());
+			Arguments.UnrealProjectID = GetDefault<UGeneralProjectSettings>()->ProjectID.ToString();
+			Arguments.bAllowOTAUpdate = bAllowOTAUpdate;
+
+			INGXRHIModule* NGXRHIModule = &FModuleManager::LoadModuleChecked<INGXRHIModule>(NGXRHIModuleName);
+			NGXRHIExtensions = NGXRHIModule->CreateNGXRHI(Arguments);
+
+			const bool bDLSSUnavailable = (!NGXRHIExtensions || !NGXRHIExtensions->IsDLSSAvailable());
+			const bool bIncompatibleAPICaptureToolActive = NGXRHI::IsIncompatibleAPICaptureToolActive();
+			if (bDLSSUnavailable && bIncompatibleAPICaptureToolActive)
+			{
+				UE_LOG(LogDLSS, Warning, TEXT("DLSS is not compatible with some API capture tools, such as RenderDoc. To enable DLSS please use an API capture tool such as NVIDIA NSIGHT graphics, which support the APIs required by DLSS."));
+
+// we don't want this ever show up in packaged builds
+#if WITH_EDITOR
+				const bool IsUnattended =  FApp::IsUnattended() || IsRunningCommandlet() || GIsRunningUnattendedScript;
+				UDLSSOverrideSettings* LocalSettings = GetMutableDefault<UDLSSOverrideSettings>();
+				const UDLSSSettings* ProjectSettings = GetDefault<UDLSSSettings>();
+				// historical note: This was originally only in the local settings, and it was a bool.
+				// Then we added a project setting because some devs want to disable the popup project-wide.
+				// But changing the type of the local setting to an enum would have complicated upgrades from previous plugin versions.
+				// So that's why the current logic is: if either the project setting or the local setting is set to false, we disable the popup
+				if (!IsUnattended && ProjectSettings->bShowDLSSIncompatiblePluginsToolsWarnings && LocalSettings->bShowDLSSIncompatiblePluginsToolsWarnings)
+				{
+					const FText DialogTitle(LOCTEXT("DLSSIncompatibleWithCaptureToolTitle", "Warning -- DLSS incompatible with plugins and/or API capture tools"));
+					const FText WarningMessage(LOCTEXT("DLSSIncompatibleWithCaptureTool",
+						"To enable DLSS, please disable the RenderDoc plugin and/or use an API capture tool such as NVIDIA NSIGHT graphics, which supports the APIs required by DLSS.\n\n"
+						"Would you like to continue to see this message for this project? It can also be disabled in the NVIDIA DLSS Overrides (Local) plugin settings."));
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+					EAppReturnType::Type YesNoCancelReply = FMessageDialog::Open(EAppMsgType::YesNoCancel, EAppReturnType::Yes, WarningMessage, DialogTitle);
+#else
+					EAppReturnType::Type YesNoCancelReply = FMessageDialog::Open(EAppMsgType::YesNoCancel, EAppReturnType::Yes, WarningMessage, &DialogTitle);
+#endif
+				
+					if(YesNoCancelReply == EAppReturnType::No)
+					{
+						LocalSettings->bShowDLSSIncompatiblePluginsToolsWarnings = false; 
+					}
+					else if (YesNoCancelReply == EAppReturnType::Cancel)
+					{
+						FPlatformMisc::RequestExit(true);
+					}
+				}
+#endif //WITH_EDITOR
+			}
+
+			if (NGXRHIExtensions)
+			{
+				if (NGXRHIExtensions->IsDLSSAvailable())
+				{
+					check(NVSDK_NGX_SUCCEED(NGXRHIExtensions->GetNGXInitResult()));
+					DLSSSRSupport = EDLSSSupport::Supported;
+					// it's possible for DLSS-SR to be supported without DLSS-RR, but not vice-versa
+					if (NGXRHIExtensions->IsDLSSRRAvailable())
+					{
+						DLSSRRSupport = EDLSSSupport::Supported;
+					}
+				}
+				else
+				{
+					// map some of the NGX error codes to something that the UI/gameplay could suggest the end user to do something about
+					if (bIncompatibleAPICaptureToolActive)
+					{
+						DLSSSRSupport = EDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive;
+						DLSSRRSupport = EDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive;
+					}
+					else if (NVSDK_NGX_Result_FAIL_OutOfDate == NGXRHIExtensions->GetNGXInitResult())
+					{
+						DLSSSRSupport = EDLSSSupport::NotSupportedDriverOutOfDate;
+						DLSSRRSupport = EDLSSSupport::NotSupportedDriverOutOfDate;
+					} 
+					else if (NVSDK_NGX_Result_FAIL_FeatureNotSupported == NGXRHIExtensions->GetNGXInitResult())
+					{
+						DLSSSRSupport = EDLSSSupport::NotSupportedIncompatibleHardware;
+						DLSSRRSupport = EDLSSSupport::NotSupportedIncompatibleHardware;
+					}
+					else
+					{
+						DLSSSRSupport = EDLSSSupport::NotSupported;
+						DLSSRRSupport = EDLSSSupport::NotSupported;
+					}
+				}
+
+				const FNGXDriverRequirements DriverRequirementsNGX = NGXRHIExtensions->GetNGXDriverRequirements();
+				MinSRDriverVersionMajor = DriverRequirementsNGX.MinDriverVersionMajor;
+				MinSRDriverVersionMinor = DriverRequirementsNGX.MinDriverVersionMinor;
+				if (DriverRequirementsNGX.DriverUpdateRequired)
+				{
+					if (NGXSupport == ENGXSupport::Supported)
+					{
+						UE_LOG(LogDLSS, Log, TEXT("NVIDIA NGX DLSS could be loaded properly. However it is recommended to update the version to at least: %u.%u"), DriverRequirementsNGX.MinDriverVersionMajor, DriverRequirementsNGX.MinDriverVersionMinor);
+					}
+					else
+					{
+						UE_LOG(LogDLSS, Log, TEXT("NVIDIA NGX DLSS cannot be loaded properly. Please verify that at least this driver version is installed: %u.%u"), DriverRequirementsNGX.MinDriverVersionMajor, DriverRequirementsNGX.MinDriverVersionMinor);
+						DLSSSRSupport = EDLSSSupport::NotSupportedDriverOutOfDate;
+						DLSSRRSupport = EDLSSSupport::NotSupportedDriverOutOfDate;
+						MinSRDriverVersionMajor = DriverRequirementsNGX.MinDriverVersionMajor;
+						MinSRDriverVersionMinor = DriverRequirementsNGX.MinDriverVersionMinor;
+					}
+				}
+				// DLSS-RR may require more recent driver than NGX or DLSS-SR
+				const FNGXDriverRequirements DriverRequirementsRR = NGXRHIExtensions->GetDLSSRRDriverRequirements();
+				MinRRDriverVersionMajor = DriverRequirementsRR.MinDriverVersionMajor;
+				MinRRDriverVersionMinor = DriverRequirementsRR.MinDriverVersionMinor;
+				if (DriverRequirementsRR.DriverUpdateRequired)
+				{
+					UE_LOG(LogDLSS, Log, TEXT("NVIDIA DLSS Ray Reconstruction will require at least this driver version: %u.%u"), DriverRequirementsRR.MinDriverVersionMajor, DriverRequirementsRR.MinDriverVersionMinor);
+					DLSSRRSupport = EDLSSSupport::NotSupportedDriverOutOfDate;
+				}
+			}
+			else
+			{
+				UE_LOG(LogDLSS, Log, TEXT("Could not load %s module"), NGXRHIModuleName);
+				NGXSupport = ENGXSupport::NotSupported;
+			}
+
+			if (NGXSupport != ENGXSupport::Supported)
+			{
+				UE_LOG(LogDLSS, Log, TEXT("DLSS not supported by the %s %s RHI in the %s module at runtime"), RHIVendorIdToString(), *RHIName, NGXRHIModuleName);
+			}
+		}
+		else
+		{
+			UE_LOG(LogDLSS, Log, TEXT("DLSS not implemented for the %s RHI, or disabled in the project settings"), *RHIName);
+			NGXSupport = ENGXSupport::NotSupported;
+		}
+	}
+
+	
+	if (DLSSSRSupport == EDLSSSupport::Supported)
+	{
+		// set the upscaler
+		DLSSUpscaler.Reset(new FDLSSUpscaler(NGXRHIExtensions.Get()));
+		check(DLSSUpscaler);
+		if (DLSSUpscaler->GetNumRuntimeQualityModes() == 0)
+		{
+			UE_LOG(LogDLSS, Log, TEXT("DLSS not available due to not supporting any quality modes at runtime"));
+			DLSSSRSupport = EDLSSSupport::NotSupported;
+			DLSSRRSupport = EDLSSSupport::NotSupported;
+			DLSSUpscaler.Reset();
+			NGXRHIExtensions.Reset();
+		}
+	}
+
+	UE_LOG(LogDLSS, Log, TEXT("NVIDIA NGX DLSS supported SR=%u RR=%u"), QueryDLSSSRSupport() == EDLSSSupport::Supported, QueryDLSSRRSupport() == EDLSSSupport::Supported);
+	
+
+	// and the other related interfaces
+
+	if (DLSSSRSupport == EDLSSSupport::Supported)
+	{
+		//	set up the view extension for setting up the FDLSSUpscaler on FSceneViewFamily
+		{
+			DLSSUpscalerViewExtension = FSceneViewExtensions::NewExtension<FDLSSUpscalerViewExtension>();
+		}
+
+		// set the denoiser
+		{
+			static const auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Reflections.Denoiser"));
+			if (CVar && (CVar->GetInt() != 2))
+			{
+				UE_LOG(LogDLSS, Warning, TEXT("For optimal results NVIDIA NGX DLSS-SR requires the use of a custom denoiser plugin, which currently is disabled. To enable, set r.Reflections.Denoiser=2"));
+			}
+
+			DLSSDenoiser.Reset(new FDLSSDenoiser(GScreenSpaceDenoiser, DLSSUpscaler.Get()));
+			GScreenSpaceDenoiser = DLSSDenoiser.Get();
+			UE_LOG(LogDLSS, Log, TEXT("%s wrapping %s"), DLSSDenoiser->GetDebugName(), DLSSDenoiser->GetWrappedDenoiser()->GetDebugName());
+		}
+
+		// set the resource pool
+		{
+			checkf(GCustomResourcePool == nullptr, TEXT("GCustomResourcePool is already in use. Please check that only one upscaling plugin is active."));
+			GCustomResourcePool = DLSSUpscaler.Get();
+		}
+	}
+	
+	// setup DLSS image quality and performance automation hooks
+	{
+		NGXAutomationViewExtension = FSceneViewExtensions::NewExtension<FNGXAutomationViewExtension>();
+	}
+
+	UE_LOG(LogDLSS, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+void FDLSSModule::ShutdownModule()
+{
+	UE_LOG(LogDLSS, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+
+	// reset DLSS image quality and performance automation hooks
+	{
+		NGXAutomationViewExtension = nullptr;
+	}
+
+	if (QueryDLSSSRSupport() == EDLSSSupport::Supported)
+	{
+		// reset the view extension
+		{
+			DLSSUpscalerViewExtension = nullptr;
+		}
+
+		// reset the resource pool
+		if (GCustomResourcePool == DLSSUpscaler.Get())
+		{
+			GCustomResourcePool = nullptr;
+		}
+
+		// reset the denoiser
+		if (GScreenSpaceDenoiser == DLSSDenoiser.Get())
+		{
+			UE_LOG(LogDLSS, Log, TEXT("%s unwrapping %s"), DLSSDenoiser->GetDebugName(), DLSSDenoiser->GetWrappedDenoiser()->GetDebugName());
+			GScreenSpaceDenoiser = DLSSDenoiser->GetWrappedDenoiser();
+			DLSSDenoiser.Reset();
+		}
+
+		// reset the upscaler
+		{
+			FDLSSUpscaler::ReleaseStaticResources();
+			DLSSUpscaler.Reset();
+		}
+
+		NGXRHIExtensions.Reset();
+	}
+
+	UE_LOG(LogDLSS, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+
+EDLSSSupport FDLSSModule::QueryDLSSSRSupport() const
+{
+	return DLSSSRSupport;
+}
+
+
+EDLSSSupport FDLSSModule::QueryDLSSRRSupport() const
+{
+	return DLSSRRSupport;
+}
+
+
+void FDLSSModule::GetDLSSSRMinDriverVersion(int32& OutMajorVersion, int32& OutMinorVersion) const
+{
+	OutMajorVersion = MinSRDriverVersionMajor;
+	OutMinorVersion = MinSRDriverVersionMinor;
+}
+
+
+void FDLSSModule::GetDLSSRRMinDriverVersion(int32& OutMajorVersion, int32& OutMinorVersion) const
+{
+	OutMajorVersion = MinRRDriverVersionMajor;
+	OutMinorVersion = MinRRDriverVersionMinor;
+}
+
+
+float FDLSSModule::GetResolutionFractionForQuality(int32 Quality) const
+{
+	checkf(QueryDLSSSRSupport() == EDLSSSupport::Supported,TEXT("GetResolutionFractionForQuality should only be called when DLSS is supported"));
+	checkf(Quality >= int32(EDLSSQualityMode::MinValue) && Quality <= int32(EDLSSQualityMode::MaxValue),TEXT("The Quality %d  argument of GetResolutionFractionForQuality is out of range and/or an unsupported DLSS quality mode"), Quality);
+	return DLSSUpscaler->GetOptimalResolutionFractionForQuality(EDLSSQualityMode(Quality));
+}
+
+FDLSSUpscaler* FDLSSModule::GetDLSSUpscaler() const
+{
+	return DLSSUpscaler.Get();
+}
+
+TSharedPtr< ISceneViewExtension, ESPMode::ThreadSafe> FDLSSModule::GetDLSSUpscalerViewExtension() const
+{
+	return StaticCastSharedPtr<ISceneViewExtension>(DLSSUpscalerViewExtension);
+}
+
+bool FDLSSModule::GetIsRRSupportedByRHI() const
+{
+	if(NGXRHIExtensions)
+		return NGXRHIExtensions.Get()->IsRRSupportedByRHI();
+
+	return false;
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FDLSSModule, DLSS)
+	
+

Plugins/Marketplace/DLSS/Source/DLSS/Private/DLSSDenoiser.cpp

@@ -0,0 +1,284 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "DLSSDenoiser.h"
+#include "DLSSUpscalerPrivate.h"
+#include "PostProcess/TemporalAA.h"
+#include "SceneTextureParameters.h"
+#include "ScenePrivate.h"
+
+
+static TAutoConsoleVariable<int32> CVarNGXDLSSReflectionsTemporalAA(
+	TEXT("r.NGX.DLSS.Reflections.TemporalAA"),
+	1,
+	TEXT("Apply a temporal AA pass on the denoised reflections"),
+	ECVF_RenderThreadSafe
+);
+
+static TAutoConsoleVariable<int32> CVarNGXDLSSWaterReflectionsTemporalAA(
+	TEXT("r.NGX.DLSS.WaterReflections.TemporalAA"),
+	1,
+	TEXT("Apply a temporal AA pass on the denoised water reflections"),
+	ECVF_RenderThreadSafe
+);
+
+static TAutoConsoleVariable<int32> CVarNGXDLSSBuiltInDenoiserOverride(
+	TEXT("r.NGX.DLSS.BuiltInDenoiserOverride"),
+	-1,
+	TEXT("Change what happens to the built-in denoisers\n")
+	TEXT("-1: automatic, depending on r.NGX.DLSS.DenoiserMode (default)\n")
+	TEXT(" 0: skip all built-in denoising\n")
+	TEXT(" 1: use built-in denoising\n")
+	,
+	ECVF_RenderThreadSafe
+);
+
+bool FDLSSDenoiser::SkipDenoiser(const FViewInfo& View) const
+{
+	static const auto CVarDLSSDenoiserMode = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.DenoiserMode"));
+	const bool bIsDLSSDenoising = CVarDLSSDenoiserMode && CVarDLSSDenoiserMode->GetInt() != 0;
+	const int32 BuiltInDenoiserOverride = CVarNGXDLSSBuiltInDenoiserOverride.GetValueOnRenderThread();
+	return IsDLSSActive(View) && bIsDLSSDenoising && BuiltInDenoiserOverride != 1;
+}
+bool FDLSSDenoiser::IsDLSSActive(const FViewInfo& View) const
+{
+	return Upscaler->IsDLSSActive() && View.Family && FDLSSSceneViewFamilyUpscaler::IsDLSSTemporalUpscaler(View.Family->GetTemporalUpscalerInterface());
+}
+
+FDLSSDenoiser::FDLSSDenoiser(const IScreenSpaceDenoiser* InWrappedDenoiser, const FDLSSUpscaler* InUpscaler)
+	: WrappedDenoiser(InWrappedDenoiser)
+	, Upscaler(InUpscaler)
+{
+	check(Upscaler);
+	check(WrappedDenoiser);
+}
+
+const TCHAR* FDLSSDenoiser::GetDebugName() const
+{
+	if (Upscaler->IsDLSSActive())
+	{
+		// we don't have the View here to check whether we have a valid GetTemporalUpscalerInterface, which we'll do when we actually get called to denoise/add TAA
+		// and this is only for profilegpu anyways so OK if it's not 100% accurate
+		return TEXT("FDLSSDenoiserWrapper(Active)");
+	}
+	else
+	{
+		return TEXT("FDLSSDenoiserWrapper(Inactive)");
+	}
+}
+
+IScreenSpaceDenoiser::EShadowRequirements FDLSSDenoiser::GetShadowRequirements(const FViewInfo& View, const FLightSceneInfo& LightSceneInfo, const FShadowRayTracingConfig& RayTracingConfig) const
+{
+	if (SkipDenoiser(View))
+	{
+		return IScreenSpaceDenoiser::EShadowRequirements::Bailout;
+	}
+
+	return WrappedDenoiser->GetShadowRequirements(View, LightSceneInfo, RayTracingConfig);
+}
+
+void FDLSSDenoiser::DenoiseShadowVisibilityMasks(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const TStaticArray<FShadowVisibilityParameters, IScreenSpaceDenoiser::kMaxBatchSize>& InputParameters, const int32 InputParameterCount, TStaticArray<FShadowVisibilityOutputs, IScreenSpaceDenoiser::kMaxBatchSize>& Outputs) const
+{
+	if (SkipDenoiser(View))
+	{
+		for (int32 Shadow = 0; Shadow < InputParameterCount; ++Shadow)
+		{
+			Outputs[Shadow].Mask = InputParameters[Shadow].InputTextures.Mask;
+		}
+	}
+	else
+	{
+
+		WrappedDenoiser->DenoiseShadowVisibilityMasks(GraphBuilder, View, PreviousViewInfos, SceneTextures, InputParameters, InputParameterCount, Outputs);
+	}
+}
+
+IScreenSpaceDenoiser::FPolychromaticPenumbraOutputs FDLSSDenoiser::DenoisePolychromaticPenumbraHarmonics(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FPolychromaticPenumbraHarmonics& Inputs) const
+{
+	if (SkipDenoiser(View))
+	{
+		IScreenSpaceDenoiser::FPolychromaticPenumbraOutputs Outputs;
+		Outputs.Diffuse = Inputs.Diffuse.Harmonics[0];
+		Outputs.Specular = Inputs.Specular.Harmonics[0];
+		return Outputs;
+	}
+	else
+	{
+		return WrappedDenoiser->DenoisePolychromaticPenumbraHarmonics(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs);
+	}
+}
+
+IScreenSpaceDenoiser::FReflectionsOutputs FDLSSDenoiser::DenoiseReflections(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FReflectionsInputs& Inputs, const FReflectionsRayTracingConfig Config) const
+{ 
+	if (SkipDenoiser(View))
+	{
+		FReflectionsOutputs Outputs;
+		Outputs.Color = Inputs.Color;
+		return Outputs;
+	}
+	else
+	{
+		FReflectionsOutputs Outputs = WrappedDenoiser->DenoiseReflections(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+		const bool bApplyTemporalAA = IsDLSSActive(View) && CVarNGXDLSSReflectionsTemporalAA.GetValueOnRenderThread() && View.ViewState && IsTemporalAccumulationBasedMethod(View.AntiAliasingMethod);
+		if(bApplyTemporalAA)
+		{
+			check(View.ViewState);
+
+			FTAAPassParameters TAASettings(View);
+			TAASettings.Pass = ETAAPassConfig::ScreenSpaceReflections;
+			TAASettings.SceneDepthTexture = SceneTextures.SceneDepthTexture;
+			TAASettings.SceneVelocityTexture = SceneTextures.GBufferVelocityTexture;
+			TAASettings.SceneColorInput = Outputs.Color;
+			TAASettings.bOutputRenderTargetable = true;
+
+			FTAAOutputs TAAOutputs = AddTemporalAAPass(
+				GraphBuilder,
+				View,
+				TAASettings,
+				View.PrevViewInfo.SSRHistory,
+				&View.ViewState->PrevFrameViewInfo.SSRHistory);
+
+			Outputs.Color = TAAOutputs.SceneColor;
+		}
+		return Outputs;
+	}
+}
+
+IScreenSpaceDenoiser::FReflectionsOutputs FDLSSDenoiser::DenoiseWaterReflections(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FReflectionsInputs& Inputs, const FReflectionsRayTracingConfig Config) const
+{
+	if (SkipDenoiser(View))
+	{
+		FReflectionsOutputs Outputs;
+		Outputs.Color = Inputs.Color;
+		return Outputs;
+	}
+	else
+	{
+		FReflectionsOutputs Outputs = WrappedDenoiser->DenoiseWaterReflections(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+		const bool bApplyTemporalAA = IsDLSSActive(View) && CVarNGXDLSSWaterReflectionsTemporalAA.GetValueOnRenderThread() && View.ViewState && IsTemporalAccumulationBasedMethod(View.AntiAliasingMethod);
+		if (bApplyTemporalAA)
+		{
+			check(View.ViewState);
+
+			FTAAPassParameters TAASettings(View);
+			TAASettings.Pass = ETAAPassConfig::ScreenSpaceReflections;
+			TAASettings.SceneDepthTexture = SceneTextures.SceneDepthTexture;
+			TAASettings.SceneVelocityTexture = SceneTextures.GBufferVelocityTexture;
+			TAASettings.SceneColorInput = Outputs.Color;
+			TAASettings.bOutputRenderTargetable = true;
+
+			FTAAOutputs TAAOutputs = AddTemporalAAPass(
+				GraphBuilder,
+				View,
+				TAASettings,
+				View.PrevViewInfo.WaterSSRHistory,
+				&View.ViewState->PrevFrameViewInfo.WaterSSRHistory);
+
+			Outputs.Color = TAAOutputs.SceneColor;
+		}
+
+		return Outputs;
+	}
+}
+
+IScreenSpaceDenoiser::FAmbientOcclusionOutputs FDLSSDenoiser::DenoiseAmbientOcclusion(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FAmbientOcclusionInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const
+{
+	if (SkipDenoiser(View))
+	{
+		FAmbientOcclusionOutputs Outputs;
+		Outputs.AmbientOcclusionMask = Inputs.Mask;
+		return Outputs;
+	}
+	else
+	{
+		return WrappedDenoiser->DenoiseAmbientOcclusion(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+	}
+}
+
+FSSDSignalTextures FDLSSDenoiser::DenoiseDiffuseIndirect(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const
+{
+	return WrappedDenoiser->DenoiseDiffuseIndirect(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+}
+
+#if defined(ENGINE_HAS_DENOISE_INDIRECT) && ENGINE_HAS_DENOISE_INDIRECT
+FSSDSignalTextures FDLSSDenoiser::DenoiseIndirect(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const
+{
+	if (SkipDenoiser(View))
+	{
+		FSSDSignalTextures Outputs;
+
+		const FRDGSystemTextures& SystemTextures = FRDGSystemTextures::Get(GraphBuilder);
+		Outputs.Textures[0] = Inputs.Diffuse;
+		Outputs.Textures[1] = SystemTextures.Black;
+		Outputs.Textures[2] = Inputs.Specular;
+		Outputs.Textures[3] = SystemTextures.Black;
+
+		return Outputs;
+	}
+	else
+	{
+		return WrappedDenoiser->DenoiseIndirect(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+	}
+}
+#endif
+
+FSSDSignalTextures FDLSSDenoiser::DenoiseScreenSpaceDiffuseIndirect(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const
+{
+	return WrappedDenoiser->DenoiseScreenSpaceDiffuseIndirect(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+}
+
+FSSDSignalTextures FDLSSDenoiser::DenoiseDiffuseIndirectHarmonic(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectHarmonic& Inputs, const HybridIndirectLighting::FCommonParameters& CommonDiffuseParameters) const
+{
+	return WrappedDenoiser->DenoiseDiffuseIndirectHarmonic(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, CommonDiffuseParameters);
+}
+
+IScreenSpaceDenoiser::FDiffuseIndirectOutputs FDLSSDenoiser::DenoiseSkyLight(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const
+{
+	if (SkipDenoiser(View))
+	{
+		FDiffuseIndirectOutputs Outputs;
+		Outputs.AmbientOcclusionMask = Inputs.AmbientOcclusionMask;
+		Outputs.Color = Inputs.Color;
+		return Outputs;
+	}
+	else
+	{
+		return WrappedDenoiser->DenoiseSkyLight(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+	}
+}
+
+#if (ENGINE_MAJOR_VERSION == 5) && (ENGINE_MINOR_VERSION < 4)
+IScreenSpaceDenoiser::FDiffuseIndirectOutputs FDLSSDenoiser::DenoiseReflectedSkyLight(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const
+{
+	if (SkipDenoiser(View))
+	{
+		FDiffuseIndirectOutputs Outputs;
+		Outputs.AmbientOcclusionMask = Inputs.AmbientOcclusionMask;
+		Outputs.Color = Inputs.Color;
+		return Outputs;
+	}
+	else
+	{
+		return WrappedDenoiser->DenoiseReflectedSkyLight(GraphBuilder, View, PreviousViewInfos, SceneTextures, Inputs, Config);
+	}
+}
+#endif
+
+
+bool FDLSSDenoiser::SupportsScreenSpaceDiffuseIndirectDenoiser(EShaderPlatform Platform) const
+{
+	return WrappedDenoiser->SupportsScreenSpaceDiffuseIndirectDenoiser(Platform);
+}
+
+const IScreenSpaceDenoiser* FDLSSDenoiser::GetWrappedDenoiser() const
+{
+	return WrappedDenoiser;
+}

Plugins/Marketplace/DLSS/Source/DLSS/Private/DLSSDenoiser.h

@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "ScreenSpaceDenoise.h"
+class FDLSSUpscaler;
+
+// wrapper for the default denoiser to add TAA after some passes
+class DLSS_API FDLSSDenoiser final : public IScreenSpaceDenoiser
+{
+
+public:
+	FDLSSDenoiser(const IScreenSpaceDenoiser* InWrappedDenoiser, const FDLSSUpscaler* InUpscaler);
+
+	// Inherited via IScreenSpaceDenoiser
+	virtual const TCHAR* GetDebugName() const final override;
+	virtual EShadowRequirements GetShadowRequirements(const FViewInfo& View, const FLightSceneInfo& LightSceneInfo, const FShadowRayTracingConfig& RayTracingConfig) const final override;
+	virtual void DenoiseShadowVisibilityMasks(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const TStaticArray<FShadowVisibilityParameters, IScreenSpaceDenoiser::kMaxBatchSize>& InputParameters, const int32 InputParameterCount, TStaticArray<FShadowVisibilityOutputs, IScreenSpaceDenoiser::kMaxBatchSize>& Outputs) const final override;
+	virtual FPolychromaticPenumbraOutputs DenoisePolychromaticPenumbraHarmonics(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FPolychromaticPenumbraHarmonics& Inputs) const final override;
+	virtual FReflectionsOutputs DenoiseReflections(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FReflectionsInputs& Inputs, const FReflectionsRayTracingConfig Config) const final override;
+	virtual FReflectionsOutputs DenoiseWaterReflections(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FReflectionsInputs& Inputs, const FReflectionsRayTracingConfig Config) const override;
+	virtual FAmbientOcclusionOutputs DenoiseAmbientOcclusion(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FAmbientOcclusionInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const final override;
+	virtual FSSDSignalTextures DenoiseDiffuseIndirect(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const final override;
+#if defined(ENGINE_HAS_DENOISE_INDIRECT) && ENGINE_HAS_DENOISE_INDIRECT
+	virtual FSSDSignalTextures DenoiseIndirect(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const final override;
+#endif
+	virtual FSSDSignalTextures DenoiseScreenSpaceDiffuseIndirect(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const final override;
+	virtual FSSDSignalTextures DenoiseDiffuseIndirectHarmonic(FRDGBuilder& GraphBuilder,const FViewInfo& View,FPreviousViewInfo* PreviousViewInfos,	const FSceneTextureParameters& SceneTextures,		const FDiffuseIndirectHarmonic& Inputs, const HybridIndirectLighting::FCommonParameters& CommonDiffuseParameters) const final override;
+	virtual FDiffuseIndirectOutputs DenoiseSkyLight(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const final override;
+#if (ENGINE_MAJOR_VERSION == 5) && (ENGINE_MINOR_VERSION < 4)
+	virtual FDiffuseIndirectOutputs DenoiseReflectedSkyLight(FRDGBuilder& GraphBuilder, const FViewInfo& View, FPreviousViewInfo* PreviousViewInfos, const FSceneTextureParameters& SceneTextures, const FDiffuseIndirectInputs& Inputs, const FAmbientOcclusionRayTracingConfig Config) const final override;
+#endif
+	virtual bool SupportsScreenSpaceDiffuseIndirectDenoiser(EShaderPlatform Platform) const final override;
+
+
+	const IScreenSpaceDenoiser* GetWrappedDenoiser() const;
+private:
+
+	bool SkipDenoiser(const FViewInfo& View) const;
+	bool IsDLSSActive(const FViewInfo& View) const;
+	const IScreenSpaceDenoiser* WrappedDenoiser;
+	const FDLSSUpscaler* Upscaler;
+};

Plugins/Marketplace/DLSS/Source/DLSS/Private/DLSSUpscalerHistory.cpp

@@ -0,0 +1,35 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "DLSSUpscalerHistory.h"
+#include "DLSSUpscalerPrivate.h"
+#include "NGXRHI.h"
+
+
+#include "PostProcess/SceneRenderTargets.h"
+#include "PostProcess/PostProcessing.h"
+
+
+
+#define LOCTEXT_NAMESPACE "FDLSSModule"
+
+
+FDLSSUpscalerHistory::FDLSSUpscalerHistory(FDLSSStateRef InDLSSState, ENGXDLSSDenoiserMode InDenoiserMode)
+	: DLSSState(InDLSSState), DenoiserMode(InDenoiserMode)
+{
+}
+
+FDLSSUpscalerHistory::~FDLSSUpscalerHistory()
+{
+}
+
+
+#undef LOCTEXT_NAMESPACE

Plugins/Marketplace/DLSS/Source/DLSS/Private/DLSSUpscalerHistory.h

@@ -0,0 +1,64 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Runtime/Launch/Resources/Version.h"
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+#include "TemporalUpscaler.h"
+#else
+#include "SceneRendering.h"
+#endif
+
+#include "DLSSUpscalerPrivate.h"
+#include "NGXRHI.h"
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+class DLSS_API FDLSSUpscalerHistory final : public ITemporalUpscaler::IHistory, public FRefCountBase
+#else
+class DLSS_API FDLSSUpscalerHistory final : public ICustomTemporalAAHistory, public FRefCountBase
+#endif
+{
+public:
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	virtual const TCHAR* GetDebugName() const final override;
+	virtual uint64 GetGPUSizeBytes() const final override;
+#endif
+
+private:
+	friend class FDLSSSceneViewFamilyUpscaler;
+
+	FDLSSStateRef DLSSState;
+	// in 5.3+ the debug name must match the upscaler's debug name, and since the name includes whether we're running DLSS-RR the history needs to know the denoiser mode
+	ENGXDLSSDenoiserMode DenoiserMode;
+
+
+	virtual uint32 AddRef() const final
+	{
+		return FRefCountBase::AddRef();
+	}
+
+	virtual uint32 Release() const final
+	{
+		return FRefCountBase::Release();
+	}
+
+	virtual uint32 GetRefCount() const final
+	{
+		return FRefCountBase::GetRefCount();
+	}
+
+	FDLSSUpscalerHistory(FDLSSStateRef InDLSSState, ENGXDLSSDenoiserMode InDenoiserMode);
+	~FDLSSUpscalerHistory();
+
+};

Plugins/Marketplace/DLSS/Source/DLSS/Private/DLSSUpscalerPrivate.h

@@ -0,0 +1,149 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "RendererInterface.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "SceneViewExtension.h"
+
+#include "DLSSUpscaler.h"
+#include "NGXRHI.h"
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+#include "TemporalUpscaler.h"
+using ITemporalUpscaler = UE::Renderer::Private::ITemporalUpscaler;
+#else
+#include "PostProcess/TemporalAA.h"
+#endif
+
+DECLARE_LOG_CATEGORY_EXTERN(LogDLSS, Verbose, All);
+
+class FDLSSUpscaler;
+struct FTemporalAAHistory;
+
+struct FDLSSPassParameters
+{
+	FIntRect InputViewRect;
+	FIntRect OutputViewRect;
+	FVector2f TemporalJitterPixels;
+	float PreExposure;
+	bool bHighResolutionMotionVectors = false;
+	ENGXDLSSDenoiserMode DenoiserMode = ENGXDLSSDenoiserMode::Off;
+
+	FRDGTexture* SceneColorInput = nullptr;
+	FRDGTexture* SceneVelocityInput = nullptr;
+	FRDGTexture* SceneDepthInput = nullptr;
+
+	// Used by denoisers
+	FRDGTexture* DiffuseAlbedo = nullptr;
+	FRDGTexture* SpecularAlbedo = nullptr;
+	FRDGTexture* Normal = nullptr;
+	FRDGTexture* Roughness = nullptr;
+	FRDGTexture* ReflectionHitDistance = nullptr;
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	FRDGTexture* EyeAdaptation = nullptr;
+
+	FDLSSPassParameters(const ITemporalUpscaler::FInputs& PassInputs)
+		: InputViewRect(PassInputs.SceneColor.ViewRect)
+		, OutputViewRect(PassInputs.OutputViewRect)
+		, TemporalJitterPixels(PassInputs.TemporalJitterPixels)
+		, PreExposure(PassInputs.PreExposure)
+		, SceneColorInput(PassInputs.SceneColor.Texture)
+		, SceneDepthInput(PassInputs.SceneDepth.Texture)
+		, EyeAdaptation(PassInputs.EyeAdaptationTexture)
+#else
+	FDLSSPassParameters(const FViewInfo& View, const ITemporalUpscaler::FPassInputs& PassInputs)
+		: InputViewRect(View.ViewRect)
+		, OutputViewRect(FIntPoint::ZeroValue, View.GetSecondaryViewRectSize())
+		, TemporalJitterPixels(View.TemporalJitterPixels)
+		, PreExposure(View.PreExposure)
+		, SceneColorInput(PassInputs.SceneColorTexture)
+		, SceneDepthInput(PassInputs.SceneDepthTexture)
+#endif
+	{
+	}
+
+	/** Returns the texture resolution that will be output. */
+	FIntPoint GetOutputExtent() const;
+
+	/** Validate the settings of TAA, to make sure there is no issue. */
+	bool Validate() const;
+};
+
+struct FDLSSOutputs
+{
+	FRDGTexture* SceneColor = nullptr;
+};
+
+class DLSS_API FDLSSUpscalerViewExtension final : public FSceneViewExtensionBase
+{
+public:
+	FDLSSUpscalerViewExtension(const FAutoRegister& AutoRegister) : FSceneViewExtensionBase(AutoRegister)
+	{ }
+
+	virtual void SetupViewFamily(FSceneViewFamily& InViewFamily) override {}
+	virtual void SetupView(FSceneViewFamily& InViewFamily, FSceneView& InView) override {}
+	virtual void BeginRenderViewFamily(FSceneViewFamily& InViewFamily) override;
+	virtual void PreRenderView_RenderThread(FRDGBuilder& GraphBuilder, FSceneView& InView) final override {}
+	virtual void PreRenderViewFamily_RenderThread(FRDGBuilder& GraphBuilder, FSceneViewFamily& InViewFamily) final override {}
+	virtual bool IsActiveThisFrame_Internal(const FSceneViewExtensionContext& Context) const override;
+};
+
+class DLSS_API FDLSSSceneViewFamilyUpscaler final : public ITemporalUpscaler
+{
+public:
+	FDLSSSceneViewFamilyUpscaler(const FDLSSUpscaler* InUpscaler, EDLSSQualityMode InDLSSQualityMode)
+		: Upscaler(InUpscaler)
+		, DLSSQualityMode(InDLSSQualityMode)
+	{ }
+
+	virtual const TCHAR* GetDebugName() const final override;
+	virtual float GetMinUpsampleResolutionFraction() const final override;
+	virtual float GetMaxUpsampleResolutionFraction() const final override;
+	virtual ITemporalUpscaler* Fork_GameThread(const class FSceneViewFamily& ViewFamily) const final override;
+	virtual ITemporalUpscaler::FOutputs AddPasses(
+		FRDGBuilder& GraphBuilder,
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+		const FSceneView& View,
+		const ITemporalUpscaler::FInputs& PassInputs
+#else
+		const FViewInfo& View,
+		const FPassInputs& PassInputs
+#endif
+	) const final override;
+
+	static bool IsDLSSTemporalUpscaler(const ITemporalUpscaler* TemporalUpscaler);
+
+private:
+	const FDLSSUpscaler* Upscaler;
+	const EDLSSQualityMode DLSSQualityMode;
+
+	FDLSSOutputs AddDLSSPass(
+		FRDGBuilder& GraphBuilder,
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+		const FSceneView& View,
+		const FDLSSPassParameters& Inputs,
+		const TRefCountPtr<ITemporalUpscaler::IHistory> InputCustomHistoryInterface,
+		TRefCountPtr<ITemporalUpscaler::IHistory>* OutputCustomHistoryInterface
+#else
+		const FViewInfo& View,
+		const FDLSSPassParameters& Inputs,
+		const FTemporalAAHistory& InputHistory,
+		FTemporalAAHistory* OutputHistory,
+		const TRefCountPtr<ICustomTemporalAAHistory> InputCustomHistoryInterface,
+		TRefCountPtr<ICustomTemporalAAHistory>* OutputCustomHistoryInterface
+#endif
+	) const;
+};
+

Plugins/Marketplace/DLSS/Source/DLSS/Public/DLSS.h

@@ -0,0 +1,91 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+class FDLSSUpscaler;
+class FDLSSDenoiser;
+class ISceneViewExtension;
+class FDLSSUpscalerViewExtension;
+class FNGXAutomationViewExtension;
+class NGXRHI;
+
+
+enum class ENGXSupport : uint8
+{
+	Supported,
+	NotSupported,
+	NotSupportedIncompatibleHardware,
+	NotSupportedDriverOutOfDate,
+	NotSupportedOperatingSystemOutOfDate,
+	NotSupportedIncompatibleAPICaptureToolActive,
+};
+
+enum class EDLSSSupport : uint8
+{
+	Supported,
+	NotSupported,
+	NotSupportedIncompatibleHardware,
+	NotSupportedDriverOutOfDate,
+	NotSupportedOperatingSystemOutOfDate,
+	NotSupportedIncompatibleAPICaptureToolActive,
+};
+
+class IDLSSModuleInterface : public IModuleInterface
+{
+	public:
+		virtual EDLSSSupport QueryDLSSSRSupport() const = 0;
+		virtual EDLSSSupport QueryDLSSRRSupport() const = 0;
+		virtual void GetDLSSSRMinDriverVersion(int32& MajorVersion, int32& MinorVersion) const = 0;
+		virtual void GetDLSSRRMinDriverVersion(int32& MajorVersion, int32& MinorVersion) const = 0;
+		virtual float GetResolutionFractionForQuality(int32 Quality) const = 0;
+		virtual FDLSSUpscaler* GetDLSSUpscaler() const = 0;
+		virtual TSharedPtr< ISceneViewExtension, ESPMode::ThreadSafe> GetDLSSUpscalerViewExtension() const = 0;
+		virtual bool GetIsRRSupportedByRHI() const = 0;
+};
+
+class FDLSSModule final: public IDLSSModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+
+	// Inherited via IDLSSModuleInterface
+	virtual EDLSSSupport QueryDLSSSRSupport() const override;
+	virtual EDLSSSupport QueryDLSSRRSupport() const override;
+	virtual void GetDLSSSRMinDriverVersion(int32& MajorVersion, int32& MinorVersion) const override;
+	virtual void GetDLSSRRMinDriverVersion(int32& MajorVersion, int32& MinorVersion) const override;
+	virtual float GetResolutionFractionForQuality(int32 Quality) const override;
+	virtual FDLSSUpscaler* GetDLSSUpscaler() const override;
+
+	virtual TSharedPtr< ISceneViewExtension, ESPMode::ThreadSafe> GetDLSSUpscalerViewExtension() const override;
+
+	virtual bool GetIsRRSupportedByRHI() const override;
+
+private:
+
+	TUniquePtr<FDLSSUpscaler> DLSSUpscaler;
+	TUniquePtr<FDLSSDenoiser> DLSSDenoiser;
+	TUniquePtr<NGXRHI> NGXRHIExtensions;
+	TSharedPtr< FDLSSUpscalerViewExtension, ESPMode::ThreadSafe> DLSSUpscalerViewExtension;
+	TSharedPtr< FNGXAutomationViewExtension, ESPMode::ThreadSafe> NGXAutomationViewExtension;
+	ENGXSupport NGXSupport = ENGXSupport::NotSupported;
+	EDLSSSupport DLSSSRSupport = EDLSSSupport::NotSupported;
+	EDLSSSupport DLSSRRSupport = EDLSSSupport::NotSupported;
+	int32 MinSRDriverVersionMinor;
+	int32 MinSRDriverVersionMajor;
+	int32 MinRRDriverVersionMinor;
+	int32 MinRRDriverVersionMajor;
+};

Plugins/Marketplace/DLSS/Source/DLSS/Public/DLSSSettings.h

@@ -0,0 +1,151 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+#pragma once
+
+#include "UObject/ObjectMacros.h"
+#include "UObject/Object.h"
+#include "Engine/DeveloperSettings.h"
+#include "SceneView.h"
+
+#include "DLSSSettings.generated.h"
+
+UENUM()
+enum class EDLSSSettingOverride : uint8
+{
+	Enabled UMETA(DisplayName = "True"),
+	Disabled UMETA(DisplayName = "False"),
+	UseProjectSettings UMETA(DisplayName = "Use project settings"),
+};
+
+UENUM()
+enum class EDLSSPreset : uint8
+{
+	Default=0 UMETA(ToolTip = "default behavior, preset specified per DLSS SDK release"),
+	A=1 UMETA(ToolTip = "force preset A"),
+	B=2 UMETA(ToolTip = "force preset B"),
+	C=3 UMETA(ToolTip = "force preset C"),
+	D=4 UMETA(ToolTip = "force preset D"),
+	E=5 UMETA(ToolTip = "force preset E"),
+	F=6 UMETA(ToolTip = "force preset F"),
+	G=7 UMETA(ToolTip = "force preset G"),
+	H=8 UMETA(Hidden, ToolTip = "force preset H - Do not use!"),
+	I=9 UMETA(Hidden, ToolTip = "force preset I - Do not use!"),
+	J=10 UMETA(ToolTip = "force preset J"),
+};
+
+UCLASS(Config = Engine, ProjectUserConfig)
+class DLSS_API UDLSSOverrideSettings : public UObject
+{
+public:
+
+	GENERATED_BODY()
+	
+	/** This enables DLSS/DLAA in editor viewports. Saved to local user config only.*/
+	UPROPERTY(Config, EditAnywhere, Category = "Level Editor - Viewport (Local)", DisplayName = "Enable DLSS/DLAA to be turned on in Editor viewports")
+	EDLSSSettingOverride EnableDLSSInEditorViewportsOverride = EDLSSSettingOverride::UseProjectSettings;
+
+	/** This enables DLSS/DLAA in play in editor viewports. Saved to local user config only. */
+	UPROPERTY(Config, EditAnywhere, Category = "Level Editor - Viewport (Local)", DisplayName = "Enable DLSS/DLAA in Play In Editor viewports")
+	EDLSSSettingOverride EnableDLSSInPlayInEditorViewportsOverride = EDLSSSettingOverride::UseProjectSettings;
+
+	/** This enables warnings about plugins & tools that are incompatible with DLSS/DLAA in the editor. This setting and the project setting both must be set to get warnings */
+	UPROPERTY(Config, EditAnywhere, Category = "Editor (Local)", DisplayName = "Warn about incompatible plugins and tools")
+	bool bShowDLSSIncompatiblePluginsToolsWarnings = true;
+
+	/** This enables on screen warnings and errors about DLSS/DLAA  */
+	UPROPERTY(Config, EditAnywhere, Category = "Editor (Local)", DisplayName = "Show various DLSS/DLAA on screen debug messages")
+	EDLSSSettingOverride ShowDLSSSDebugOnScreenMessages = EDLSSSettingOverride::UseProjectSettings;
+
+};
+
+UCLASS(Config = Engine, DefaultConfig, DisplayName="NVIDIA DLSS")
+class DLSS_API UDLSSSettings: public UObject
+{
+	GENERATED_BODY()
+
+private:
+
+public:
+
+	/** Enable DLSS/DLAA for D3D12, if the driver supports it at runtime */
+	UPROPERTY(Config, EditAnywhere, Category = "Platforms", DisplayName = "Enable DLSS/DLAA for the D3D12RHI")
+		bool bEnableDLSSD3D12 = PLATFORM_WINDOWS;
+
+	/** Enable DLSS/DLAA for D3D11, if the driver supports it at runtime */
+	UPROPERTY(Config, EditAnywhere, Category = "Platforms", DisplayName = "Enable DLSS/DLAA for the D3D11RHI")
+		bool bEnableDLSSD3D11 = PLATFORM_WINDOWS;
+
+	/** Enable DLSS/DLAA for Vulkan, if the driver supports it at runtime */
+	UPROPERTY(Config, EditAnywhere, Category = "Platforms", DisplayName = "Enable DLSS/DLAA for the VulkanRHI")
+		bool bEnableDLSSVulkan = PLATFORM_WINDOWS;
+
+	/** This enables DLSS/DLAA in editor viewports. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings.*/
+	UPROPERTY(Config, EditAnywhere, Category = "Level Editor - Viewport", DisplayName = "Enable DLSS/DLAA to be turned on in Editor viewports")
+		bool bEnableDLSSInEditorViewports = false;
+
+	/** This enables DLSS/DLAA in play in editor viewports. This project wide setting can be locally overridden in in the NVIDIA DLSS (Local) settings.*/
+	UPROPERTY(Config, EditAnywhere, Category = "Level Editor - Viewport", DisplayName = "Enable DLSS/DLAA in Play In Editor viewports")
+		bool bEnableDLSSInPlayInEditorViewports = true;
+
+	/** This enables on screen warnings and errors about DLSS/DLAA. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings. */
+	UPROPERTY(Config, EditAnywhere, Category = "Level Editor - Viewport", DisplayName = "Show various DLSS/DLAA on screen debug messages")
+		bool bShowDLSSSDebugOnScreenMessages = true;
+
+	/** This is part of the DLSS plugin and used by most projects*/
+	UPROPERTY(VisibleAnywhere, Config, Category = "General Settings", DisplayName = "Generic DLSS Binary Path")
+		FString GenericDLSSBinaryPath;
+
+	UPROPERTY(VisibleAnywhere, Config, Category = "General Settings", DisplayName = "Exists")
+		bool bGenericDLSSBinaryExists;
+
+	/** By default the DLSS plugin uses the UE Project ID to initialize DLSS. In some cases NVIDIA might provide a separate NVIDIA Application ID, which should be put here. Please refer to https://developer.nvidia.com/dlss for details*/
+	UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "NVIDIA NGX Application ID", AdvancedDisplay)
+		uint32 NVIDIANGXApplicationId;
+
+	/** In some cases NVIDIA might provide a project specific DLSS binary for your project. Please refer to https://developer.nvidia.com/dlss for details*/
+	UPROPERTY(VisibleAnywhere, Config, Category = "General Settings", DisplayName = "Custom DLSS Binary Path", AdvancedDisplay)
+		FString CustomDLSSBinaryPath;
+	UPROPERTY(VisibleAnywhere, Config, Category = "General Settings", DisplayName = "Exists", AdvancedDisplay)
+		bool bCustomDLSSBinaryExists;
+
+	/** Allow OTA updates of DLSS models */
+	UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "Allow OTA update")
+		bool bAllowOTAUpdate = true;
+
+	/** This enables warnings about plugins & tools that are incompatible with DLSS/DLAA in the editor. This setting and the local setting both must be set to get warnings */
+	UPROPERTY(Config, EditAnywhere, Category = "Editor", DisplayName = "Warn about incompatible plugins and tools")
+	bool bShowDLSSIncompatiblePluginsToolsWarnings = true;
+
+	/** DLAA preset setting. Allows selecting a different DL model than the default */
+	UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "DLAA Preset", AdvancedDisplay)
+		EDLSSPreset DLAAPreset = EDLSSPreset::Default;
+
+	/** DLSS quality mode preset setting. Allows selecting a different DL model than the default */
+	// NOT IMPLEMENTED YET UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "DLSS Ultra Quality Preset", AdvancedDisplay)
+		EDLSSPreset DLSSUltraQualityPreset = EDLSSPreset::Default;
+
+	/** DLSS quality mode preset setting. Allows selecting a different DL model than the default */
+	UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "DLSS Quality Preset", AdvancedDisplay)
+		EDLSSPreset DLSSQualityPreset = EDLSSPreset::Default;
+
+	/** DLSS balanced mode preset setting. Allows selecting a different DL model than the default */
+	UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "DLSS Balanced Preset", AdvancedDisplay)
+		EDLSSPreset DLSSBalancedPreset = EDLSSPreset::Default;
+
+	/** DLSS performance mode preset setting. Allows selecting a different DL model than the default */
+	UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "DLSS Performance Preset", AdvancedDisplay)
+		EDLSSPreset DLSSPerformancePreset = EDLSSPreset::Default;
+
+	/** DLSS ultra performance mode preset setting. Allows selecting a different DL model than the default */
+	UPROPERTY(Config, EditAnywhere, Category = "General Settings", DisplayName = "DLSS Ultra Performance Preset", AdvancedDisplay)
+		EDLSSPreset DLSSUltraPerformancePreset = EDLSSPreset::Default;
+};
+

Plugins/Marketplace/DLSS/Source/DLSS/Public/DLSSUpscaler.h

@@ -0,0 +1,97 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CustomResourcePool.h"
+
+struct FDLSSOptimalSettings;
+class FSceneViewFamily;
+class NGXRHI;
+
+enum class EDLSSQualityMode
+{
+	MinValue = -2,
+	UltraPerformance = -2,
+	Performance = -1,
+	Balanced = 0,
+	Quality = 1,
+	UltraQuality = 2,
+	DLAA = 3,
+	MaxValue = DLAA,
+	NumValues = 6
+};
+
+class DLSS_API FDLSSUpscaler final : public ICustomResourcePool
+{
+
+	friend class FDLSSModule;
+public:
+	UE_NONCOPYABLE(FDLSSUpscaler)
+
+	void SetupViewFamily(FSceneViewFamily& ViewFamily);
+
+	float GetOptimalResolutionFractionForQuality(EDLSSQualityMode Quality) const;
+	float GetOptimalSharpnessForQuality(EDLSSQualityMode Quality) const;
+	float GetMinResolutionFractionForQuality(EDLSSQualityMode Quality) const;
+	float GetMaxResolutionFractionForQuality(EDLSSQualityMode Quality) const;
+	bool IsFixedResolutionFraction(EDLSSQualityMode Quality) const;
+	
+	const NGXRHI* GetNGXRHI() const
+	{
+		return NGXRHIExtensions;
+	}
+
+	// Inherited via ICustomResourcePool
+	virtual void Tick(FRHICommandListImmediate& RHICmdList) override;
+
+	bool IsQualityModeSupported(EDLSSQualityMode InQualityMode) const;
+	uint32 GetNumRuntimeQualityModes() const
+	{
+		return NumRuntimeQualityModes;
+	}
+
+	bool IsDLSSActive() const;
+
+	// Give the suggested EDLSSQualityMode if one is appropriate for the given pixel count, or nothing if DLSS should be disabled
+	TOptional<EDLSSQualityMode> GetAutoQualityModeFromPixels(int PixelCount) const;
+
+	static void ReleaseStaticResources();
+
+	static float GetMinUpsampleResolutionFraction()
+	{
+		return MinDynamicResolutionFraction;
+	}
+
+	static float GetMaxUpsampleResolutionFraction()
+	{
+		return MaxDynamicResolutionFraction;
+	}
+
+private:
+	FDLSSUpscaler(NGXRHI* InNGXRHIExtensions);
+
+	bool EnableDLSSInPlayInEditorViewports() const;
+
+	// The FDLSSUpscaler(NGXRHI*) will update those once
+	static NGXRHI* NGXRHIExtensions;
+	static float MinDynamicResolutionFraction;
+	static float MaxDynamicResolutionFraction;
+
+	static uint32 NumRuntimeQualityModes;
+	static TArray<FDLSSOptimalSettings> ResolutionSettings;
+	float PreviousResolutionFraction;
+
+	friend class FDLSSUpscalerViewExtension;
+	friend class FDLSSSceneViewFamilyUpscaler;
+};
+

Plugins/Marketplace/DLSS/Source/DLSSBlueprint/DLSSBlueprint.Build.cs

@@ -0,0 +1,56 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+using System.IO;
+
+public class DLSSBlueprint : ModuleRules
+{
+	protected virtual bool IsSupportedPlatform(ReadOnlyTargetRules Target)
+	{
+		return Target.Platform.IsInGroup(UnrealPlatformGroup.Windows);
+	}
+
+	public DLSSBlueprint(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"Engine",
+				"RenderCore",
+				"Renderer",
+				"Projects",
+			}
+		);
+
+		bool bPlatformSupportsDLSS = IsSupportedPlatform(Target);
+	
+		PublicDefinitions.Add("WITH_DLSS=" + (bPlatformSupportsDLSS ? '1' : '0'));
+
+		if (bPlatformSupportsDLSS)
+		{ 
+			PrivateDependencyModuleNames.AddRange(
+				new string[]
+				{
+					"NGX",
+					"NGXRHI",
+					"DLSS",
+				}
+			);
+		}
+	}
+
+
+}

Plugins/Marketplace/DLSS/Source/DLSSBlueprint/Private/DLSSLibrary.cpp

@@ -0,0 +1,920 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "DLSSLibrary.h"
+
+#if WITH_DLSS
+#include "DLSS.h"
+#include "DLSSSettings.h"
+#include "DLSSUpscaler.h"
+#include "NGXRHI.h"
+#endif
+
+#include "Interfaces/IPluginManager.h"
+#include "Modules/ModuleManager.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "SceneView.h"
+#include "ShaderCore.h"
+#include "RenderUtils.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(DLSSLibrary)
+
+#define LOCTEXT_NAMESPACE "FDLSSBlueprintModule"
+DEFINE_LOG_CATEGORY_STATIC(LogDLSSBlueprint, Log, All);
+
+static TAutoConsoleVariable<int32> CVarNGXDLSSPreferNISSharpen(
+	TEXT("r.NGX.DLSS.PreferNISSharpen"),
+	2,
+	TEXT("Prefer sharpening with an extra NIS plugin sharpening pass instead of DLSS sharpening if the NIS plugin is also enabled for the project. (default: 1)\n")
+	TEXT("Requires the NIS plugin to be enabled\n")
+	TEXT("   0: Softening/sharpening with the DLSS pass.\n")
+	TEXT("   1: Sharpen with the NIS plugin. Softening is not supported. Requires the NIS plugin to be enabled.\n")
+	TEXT("   2: Sharpen with the NIS plugin. Softening (i.e. negative sharpness) with the DLSS plugin. Requires the NIS plugin to be enabled.\n")
+	TEXT("Note: This cvar is only evaluated when using the deprecated `SetDLSSSharpness` Blueprint function, from either C++ or a Blueprint event graph!")
+	TEXT("Note: DLSS sharpening is deprecated, future plugin versions will remove DLSS sharpening. Use the NIS plugin for sharpening instead\n"),
+	ECVF_RenderThreadSafe);
+
+static const FName SetDLSSModeInvalidEnumValueError= FName("SetDLSSModeInvalidEnumValueError");
+static const FName IsDLSSModeSupportedInvalidEnumValueError = FName("IsDLSSModeSupportedInvalidEnumValueError");
+
+UDLSSSupport UDLSSLibrary::DLSSSRSupport = UDLSSSupport::NotSupportedByPlatformAtBuildTime;
+UDLSSSupport UDLSSLibrary::DLSSRRSupport = UDLSSSupport::NotSupportedByPlatformAtBuildTime;
+#if WITH_DLSS
+int32 UDLSSLibrary::MinDLSSSRDriverVersionMajor = 0;
+int32 UDLSSLibrary::MinDLSSSRDriverVersionMinor = 0;
+int32 UDLSSLibrary::MinDLSSRRDriverVersionMajor = 0;
+int32 UDLSSLibrary::MinDLSSRRDriverVersionMinor = 0; // placeholder
+int32 UDLSSLibrary::PreviousShadowDenoiser = 1;
+int32 UDLSSLibrary::PreviousLumenSSR = 1;
+int32 UDLSSLibrary::PreviousLumenTemporal = 1;
+bool UDLSSLibrary::bDenoisingRequested = false;
+
+FDLSSUpscaler* UDLSSLibrary::DLSSUpscaler = nullptr;
+bool UDLSSLibrary::bDLSSLibraryInitialized = false;
+UDLSSMode UDLSSLibrary::CurrentDLSSModeDeprecated = UDLSSMode::Quality;
+bool UDLSSLibrary::bDLAAEnabledDeprecated = false;
+
+static bool ShowDLSSSDebugOnScreenMessages()
+{
+
+	if (GetDefault<UDLSSOverrideSettings>()->ShowDLSSSDebugOnScreenMessages == EDLSSSettingOverride::UseProjectSettings)
+	{
+		return GetDefault<UDLSSSettings>()->bShowDLSSSDebugOnScreenMessages;
+	}
+	else
+	{
+		return GetDefault<UDLSSOverrideSettings>()->ShowDLSSSDebugOnScreenMessages == EDLSSSettingOverride::Enabled;
+	}
+}
+
+
+#if !UE_BUILD_SHIPPING
+
+UDLSSLibrary::FDLSSErrorState UDLSSLibrary::DLSSErrorState;
+FDelegateHandle UDLSSLibrary::DLSSOnScreenMessagesDelegateHandle;
+void UDLSSLibrary::GetDLSSOnScreenMessages(TMultiMap<FCoreDelegates::EOnScreenMessageSeverity, FText>& OutMessages)
+{
+	check(IsInGameThread());
+
+	// We need a valid DLSSSRSupport, so calling this here in case other UDLSSLibrary functions which call TryInitDLSSLibrary() haven't been called
+	if (!TryInitDLSSLibrary())
+	{
+		return;
+	}
+
+	if(ShowDLSSSDebugOnScreenMessages())
+	{
+
+		if (DLSSErrorState.bIsDLSSModeUnsupported)
+		{
+			const FTextFormat Format(LOCTEXT("DLSSOnScreenDebugSetModeUnsupportedDLSSMode",
+				"DLSS Error: The DLSS mode \"{0}\" is not supported. This error can be avoided by calling SetDLSSMode({0}) only if IsDLSSModeSupported({0}) returns true."));
+			const FText Message = FText::Format(Format, StaticEnum<UDLSSMode>()->GetDisplayNameTextByValue(int64(DLSSErrorState.InvalidDLSSMode)));
+			OutMessages.Add(FCoreDelegates::EOnScreenMessageSeverity::Error, Message);
+		}
+
+		// Checking for "contains" in case virtualization is changing the GPU string
+		const bool bIsNVIDIA = FWindowsPlatformMisc::GetPrimaryGPUBrand().Contains(TEXT("NVIDIA"));
+
+		bool bShowNotSupportedMessage = bIsNVIDIA && (UDLSSSupport::Supported != DLSSSRSupport);
+
+		if ((UDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive == DLSSSRSupport) && !GetMutableDefault<UDLSSOverrideSettings>()->bShowDLSSIncompatiblePluginsToolsWarnings )
+		{
+			bShowNotSupportedMessage = false;
+		}
+
+		if (bShowNotSupportedMessage)
+		{
+			const FTextFormat Format(LOCTEXT("DLSSOnScreenDebugDLSSNotSupported",
+				"DLSS Information: DLSS is not supported due to {0}.Please see the various LogDLSS* categories in the Developer Tools -> Output Log for further detail."));
+			const FText Message = FText::Format(Format, StaticEnum<UDLSSSupport>()->GetDisplayNameTextByValue(int64(DLSSSRSupport)));
+			OutMessages.Add(FCoreDelegates::EOnScreenMessageSeverity::Warning, Message);
+		}
+	}
+}
+#endif
+
+
+static EDLSSQualityMode ToEDLSSQualityMode(UDLSSMode InDLSSQualityMode)
+{
+	static_assert(int32(EDLSSQualityMode::NumValues) == 6, "dear DLSS plugin NVIDIA developer, please update this code to translate the new EDLSSQualityMode enum values to UDLSSMode");
+
+	switch (InDLSSQualityMode)
+	{
+
+	case UDLSSMode::UltraPerformance: 
+		return EDLSSQualityMode::UltraPerformance;
+	
+	// the higher level code should catch this...
+	case UDLSSMode::Off:
+		checkf(InDLSSQualityMode != UDLSSMode::Off, TEXT("ToEDLSSQualityMode should not be called with an InDLSSQualityMode of UDLSSMode::Off from the higher level code"));
+	default:
+		checkf(false, TEXT("ToEDLSSQualityMode should not be called with an out of range InDLSSQualityMode %d InDLSSQualityMode from the higher level code"), InDLSSQualityMode);
+
+	case UDLSSMode::Performance:
+		return EDLSSQualityMode::Performance;
+	
+	case UDLSSMode::Balanced:
+		return EDLSSQualityMode::Balanced;
+	
+	case UDLSSMode::Quality:
+		return EDLSSQualityMode::Quality;
+	
+	case UDLSSMode::UltraQuality:
+		return EDLSSQualityMode::UltraQuality;
+		
+	case UDLSSMode::DLAA:
+		return EDLSSQualityMode::DLAA;
+
+	}
+}
+
+#endif
+
+bool UDLSSLibrary::IsDLSSModeSupported(UDLSSMode DLSSMode)
+{
+	const UEnum* Enum = StaticEnum<UDLSSMode>();
+
+	// UEnums are strongly typed, but then one can also cast a byte to an UEnum ...
+	if (Enum->IsValidEnumValue(int64(DLSSMode)) && (Enum->GetMaxEnumValue() != int64(DLSSMode)))
+	{
+		if (DLSSMode == UDLSSMode::Off)
+		{
+			return true;
+		}
+#if WITH_DLSS
+		if (!TryInitDLSSLibrary())
+		{
+			UE_LOG(LogDLSSBlueprint, Error, TEXT("IsDLSSModeSupported should not be called before PostEngineInit"));
+			return false;
+		}
+		if (!IsDLSSSupported())
+		{
+			return false;
+		}
+		else if (DLSSMode == UDLSSMode::Auto)
+		{
+			// support for auto quality mode was dropped with UE 5.1 (except as a way to ask for optimal screen percentage for a given resolution)
+			return false;
+		}
+		else
+		{
+			return DLSSUpscaler->IsQualityModeSupported(ToEDLSSQualityMode(DLSSMode));
+		}
+#else
+		return false;
+#endif
+	}
+	else
+	{
+#if !UE_BUILD_SHIPPING
+		FFrame::KismetExecutionMessage(*FString::Printf(
+			TEXT("IsDLSSModeSupported should not be called with an invalid DLSSMode enum value (%d) \"%s\""),
+			int64(DLSSMode), *StaticEnum<UDLSSMode>()->GetDisplayNameTextByValue(int64(DLSSMode)).ToString()),
+			ELogVerbosity::Error, IsDLSSModeSupportedInvalidEnumValueError);
+#endif 
+		return false;
+	}
+
+}
+
+void UDLSSLibrary::GetDLSSModeInformation(UDLSSMode DLSSMode, FVector2D ScreenResolution, bool& bIsSupported, float& OptimalScreenPercentage, bool& bIsFixedScreenPercentage, float& MinScreenPercentage, float& MaxScreenPercentage, float& OptimalSharpness)
+{
+	// fall back to TAA for unsupported or DLSS off
+	OptimalScreenPercentage = 0.0f;
+	bIsFixedScreenPercentage = false;
+	MinScreenPercentage = 100.0f * ISceneViewFamilyScreenPercentage::kMinTAAUpsampleResolutionFraction;
+	MaxScreenPercentage = 100.0f * ISceneViewFamilyScreenPercentage::kMaxTAAUpsampleResolutionFraction;
+	OptimalSharpness = 0.0f;
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetDLSSModeInformation should not be called before PostEngineInit"));
+		bIsSupported = false;
+		return;
+	}
+#endif
+	bIsSupported = IsDLSSModeSupported(DLSSMode);
+
+#if WITH_DLSS
+	// Auto mode is never a "supported" mode but if DLSS is supported we still need to follow this code path to get optimal screen percentage
+	if ((DLSSMode != UDLSSMode::Off) && bIsSupported || (DLSSMode == UDLSSMode::Auto) && IsDLSSSupported())
+	{
+		EDLSSQualityMode EDLSSMode;
+		if (DLSSMode != UDLSSMode::Auto)
+		{
+			EDLSSMode = ToEDLSSQualityMode(DLSSMode);
+		}
+		else
+		{
+			// Auto DLSS mode is based on total pixels
+			float PixelsFloat = ScreenResolution.X * ScreenResolution.Y;
+			int32 PixelsInt = (PixelsFloat < static_cast<float>(MAX_int32)) ? static_cast<int32>(PixelsFloat) : MAX_int32;
+			TOptional<EDLSSQualityMode> MaybeDLSSMode = DLSSUpscaler->GetAutoQualityModeFromPixels(PixelsInt);
+			if (!MaybeDLSSMode.IsSet())
+			{
+				// DLSS Off
+				return;
+			}
+			EDLSSMode = MaybeDLSSMode.GetValue();
+		}
+		bIsFixedScreenPercentage = DLSSUpscaler->IsFixedResolutionFraction(EDLSSMode);
+
+		OptimalScreenPercentage = 100.0f * DLSSUpscaler->GetOptimalResolutionFractionForQuality(EDLSSMode);
+		MinScreenPercentage = 100.0f * DLSSUpscaler->GetMinResolutionFractionForQuality(EDLSSMode);
+		MaxScreenPercentage = 100.0f * DLSSUpscaler->GetMaxResolutionFractionForQuality(EDLSSMode);
+
+		OptimalSharpness = DLSSUpscaler->GetOptimalSharpnessForQuality(EDLSSMode);
+	}
+#endif
+}
+
+void UDLSSLibrary::GetDLSSScreenPercentageRange(float& MinScreenPercentage, float& MaxScreenPercentage)
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetDLSSScreenPercentageRange should not be called before PostEngineInit"));
+		MinScreenPercentage = 100.0f;
+		MaxScreenPercentage = 100.0f;
+		return;
+	}
+
+	if (IsDLSSSupported())
+	{
+		MinScreenPercentage = 100.0f * DLSSUpscaler->GetMinUpsampleResolutionFraction();
+		MaxScreenPercentage = 100.0f * DLSSUpscaler->GetMaxUpsampleResolutionFraction();
+	}
+	else
+#endif
+	{
+		MinScreenPercentage = 100.0f;
+		MaxScreenPercentage = 100.0f;
+	}
+}
+
+TArray<UDLSSMode> UDLSSLibrary::GetSupportedDLSSModes()
+{
+	TArray<UDLSSMode> SupportedQualityModes;
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetSupportedDLSSModes should not be called before PostEngineInit"));
+		return SupportedQualityModes;
+	}
+#endif
+	{
+		const UEnum* Enum = StaticEnum<UDLSSMode>();
+		for (int32 EnumIndex = 0; EnumIndex < Enum->NumEnums(); ++EnumIndex)
+		{
+			const int64 EnumValue = Enum->GetValueByIndex(EnumIndex);
+			if (EnumValue != Enum->GetMaxEnumValue())
+			{
+				const UDLSSMode QualityMode = UDLSSMode(EnumValue);
+				if (IsDLSSModeSupported(QualityMode))
+				{
+					SupportedQualityModes.Add(QualityMode);
+				}
+			}
+		}
+	}
+	return SupportedQualityModes;
+}
+
+bool UDLSSLibrary::IsRayTracingAvailable()
+{
+	return IsRayTracingAllowed();	
+}
+
+bool UDLSSLibrary::IsDLSSSupported()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("IsDLSSSupported should not be called before PostEngineInit"));
+		return false;
+	}
+
+	return QueryDLSSSupport() == UDLSSSupport::Supported;
+#else
+	return false;
+#endif
+}
+
+UDLSSSupport UDLSSLibrary::QueryDLSSSupport()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("QueryDLSSSRSupport should not be called before PostEngineInit"));
+		return UDLSSSupport::NotSupported;
+	}
+#endif
+	return DLSSSRSupport;
+}
+
+bool UDLSSLibrary::IsDLSSRRSupported()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("IsDLSSRRSupported should not be called before PostEngineInit"));
+		return false;
+	}
+
+	return QueryDLSSRRSupport() == UDLSSSupport::Supported;
+#else
+	return false;
+#endif
+}
+
+static bool GetIsRHISupportsRR()
+{
+	bool bDoseRHISupportsRR = false;
+#if WITH_DLSS
+	static IDLSSModuleInterface* DLSSModule = FModuleManager::GetModulePtr<IDLSSModuleInterface>(TEXT("DLSS"));
+	if (DLSSModule == nullptr)
+	{
+		return false;
+	}
+
+	bDoseRHISupportsRR = DLSSModule->GetIsRRSupportedByRHI();
+#endif
+	return bDoseRHISupportsRR;
+}
+
+UDLSSSupport UDLSSLibrary::QueryDLSSRRSupport()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("QueryDLSSRRSupport should not be called before PostEngineInit"));
+		return UDLSSSupport::NotSupported;
+	}
+
+	static bool bIsRRSupportedByRHI = GetIsRHISupportsRR();
+
+	if (!bIsRRSupportedByRHI)
+	{
+		UE_LOG(LogDLSSBlueprint, Warning, TEXT("RR is not supported by current RHI, Please switch to D3D12"));
+		return UDLSSSupport::NotSupported;
+	}
+
+	if(!IsRayTracingEnabled())
+	{
+		UE_LOG(LogDLSSBlueprint, Warning, TEXT("RR is not supported because no need to reconstract rays if there are no rays to reconstruct ¯\'_(ツ)_/¯"));
+		return UDLSSSupport::NotSupported;
+	}
+
+#endif
+	return DLSSRRSupport;
+}
+
+void UDLSSLibrary::GetDLSSMinimumDriverVersion(int32& MinDriverVersionMajor, int32& MinDriverVersionMinor)
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetDLSSMinimumDriverVersion should not be called before PostEngineInit"));
+	}
+	MinDriverVersionMajor = MinDLSSSRDriverVersionMajor;
+	MinDriverVersionMinor = MinDLSSSRDriverVersionMinor;
+#else
+	MinDriverVersionMajor = 0;
+	MinDriverVersionMinor = 0;
+#endif
+}
+
+void UDLSSLibrary::GetDLSSRRMinimumDriverVersion(int32& MinDriverVersionMajor, int32& MinDriverVersionMinor)
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetDLSSRRMinimumDriverVersion should not be called before PostEngineInit"));
+	}
+	MinDriverVersionMajor = MinDLSSRRDriverVersionMajor;
+	MinDriverVersionMinor = MinDLSSRRDriverVersionMinor;
+#else
+	MinDriverVersionMajor = 0;
+	MinDriverVersionMinor = 0;
+#endif
+}
+
+void UDLSSLibrary::EnableDLSS(bool bEnabled)
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("EnableDLSS should not be called before PostEngineInit"));
+		return;
+	}
+
+	const bool bDLSSSupported = (DLSSSRSupport == UDLSSSupport::Supported);
+	if (!bDLSSSupported)
+	{
+		return;
+	}
+
+	static IConsoleVariable* CVarDLSSEnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.Enable"));
+	if (CVarDLSSEnable)
+	{
+		CVarDLSSEnable->Set(bEnabled ? 1 : 0, ECVF_SetByCommandline);
+
+		// Spatial upscalers such as NIS might set this to 0, but we need r.TemporalAA.Upscaler to be 1 for DLSS to work.
+		// but we don't want to change the Cvar if DLSS is not active as to avoid impacting other code paths
+		// we don't need to set r.TemporalAA.Upsampling since r.TemporalAA.Upscaler implies that
+		if (bEnabled)
+		{
+			static const auto CVarTemporalAAUpscaler = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TemporalAA.Upscaler"));
+			CVarTemporalAAUpscaler->Set(1, ECVF_SetByCommandline);
+			// restore denoising state in case it was disabled before
+			EnableDLSSRR(bDenoisingRequested);
+		}
+		else if (IsDLSSRREnabled())
+		{
+			// Denoising currently only runs as an upscaler pass, so if DLSS-SR is disabled, we automatically disable DLSS-RR as well
+			EnableDLSSRR(false);
+			bDenoisingRequested = true;
+			UE_LOG(LogDLSSBlueprint, Warning, TEXT("DLSS denoising unsupported without DLSS super resolution, disabled denoising"));
+		}
+	}
+#endif
+}
+
+void UDLSSLibrary::EnableDLSSRR(bool bEnabled)
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("EnableDLSSRR should not be called before PostEngineInit"));
+		return;
+	}
+
+	const bool bDLSSRRSupported = (DLSSRRSupport == UDLSSSupport::Supported);
+	if (!bDLSSRRSupported)
+	{
+		return;
+	}
+
+	bDenoisingRequested = bEnabled;
+	static IConsoleVariable* CVarDLSSRREnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.DenoiserMode"));
+	const bool bDLSSRREnabled = CVarDLSSRREnable->GetInt() != 0;
+	if (bDLSSRREnabled == bEnabled)
+	{
+		return;
+	}
+
+	// Denoising currently only runs as an upscaler pass, so only enable DLSS-RR if DLSS-SR is enabled
+	if (bEnabled && IsDLSSEnabled())
+	{
+		CVarDLSSRREnable->Set(1);
+		PreviousShadowDenoiser       = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shadow.Denoiser"))->GetInt();
+		IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shadow.Denoiser"))->Set(0);
+		PreviousLumenSSR             = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Lumen.Reflections.ScreenSpaceReconstruction"))->GetInt();
+		PreviousLumenTemporal        = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Lumen.Reflections.Temporal"))->GetInt();
+		IConsoleManager::Get().FindConsoleVariable(TEXT("r.Lumen.Reflections.ScreenSpaceReconstruction"))->Set(0);
+		IConsoleManager::Get().FindConsoleVariable(TEXT("r.Lumen.Reflections.Temporal"))->Set(0);
+		static const auto CVarTemporalAAUpscaler = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TemporalAA.Upscaler"));
+		CVarTemporalAAUpscaler->Set(1, ECVF_SetByCommandline);
+		int LumenBilateralFilter = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Lumen.Reflections.BilateralFilter"))->GetInt();
+		if (LumenBilateralFilter != 0)
+		{
+			// engine bug in 5.2 and 5.3 prevents us from changing the value of this cvar from Blueprints
+			UE_LOG(LogDLSSBlueprint, Warning, TEXT("r.Lumen.Reflections.BilateralFilter should be disabled when DLSS Ray Reconstruction is enabled"));
+		}
+	}
+	else if (!bEnabled)
+	{
+		CVarDLSSRREnable->Set(0);
+		IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shadow.Denoiser"))->Set(PreviousShadowDenoiser);
+		IConsoleManager::Get().FindConsoleVariable(TEXT("r.Lumen.Reflections.ScreenSpaceReconstruction"))->Set(PreviousLumenSSR);
+		IConsoleManager::Get().FindConsoleVariable(TEXT("r.Lumen.Reflections.Temporal"))->Set(PreviousLumenTemporal);
+	}
+#endif
+}
+
+bool UDLSSLibrary::IsDLSSEnabled()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("IsDLSSEnabled should not be called before PostEngineInit"));
+		return false;
+	}
+
+	// if NGX library loading was disabled, DLSS will be unsupported
+	const bool bDLSSSupported = (DLSSSRSupport == UDLSSSupport::Supported);
+
+	static const IConsoleVariable* CVarDLSSEnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.Enable"));
+	const bool bDLSSEnabled = CVarDLSSEnable && (CVarDLSSEnable->GetInt() != 0);
+
+	return bDLSSSupported && bDLSSEnabled;
+#else
+	return false;
+#endif
+}
+
+bool UDLSSLibrary::IsDLSSRREnabled()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("IsDLSSRREnabled should not be called before PostEngineInit"));
+		return false;
+	}
+
+	// if NGX library loading was disabled, DLSS will be unsupported
+	const bool bDLSSSupported = (DLSSSRSupport == UDLSSSupport::Supported);
+
+	static const IConsoleVariable* CVarDLSSDenoiserMode = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.DenoiserMode"));
+	const bool bDLSSRREnabled = CVarDLSSDenoiserMode && (CVarDLSSDenoiserMode->GetInt() != 0);
+
+	return bDLSSSupported && bDLSSRREnabled;
+#else
+	return false;
+#endif
+}
+
+// deprecated
+void UDLSSLibrary::EnableDLAA(bool bEnabled)
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("EnableDLAA should not be called before PostEngineInit"));
+		return;
+	}
+
+	const bool bDLAASupported = (DLSSSRSupport == UDLSSSupport::Supported);
+
+	bDLAAEnabledDeprecated = bDLAASupported && bEnabled;
+	if (bDLAAEnabledDeprecated)
+	{
+		EnableDLSS(true);
+	}
+	else
+	{
+		// fall back to last set DLSS mode
+		SetDLSSMode(nullptr, CurrentDLSSModeDeprecated);
+	}
+#endif
+}
+
+// deprecated
+bool UDLSSLibrary::IsDLAAEnabled()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("IsDLAAEnabled should not be called before PostEngineInit"));
+		return false;
+	}
+
+	const bool bDLAASupported = (DLSSSRSupport == UDLSSSupport::Supported);
+
+	return bDLAASupported && bDLAAEnabledDeprecated;
+#else
+	return false;
+#endif
+}
+
+// deprecated
+void UDLSSLibrary::SetDLSSMode(UObject* WorldContextObject, UDLSSMode DLSSMode)
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("SetDLSSMode should not be called before PostEngineInit"));
+		return;
+	}
+
+	const UEnum* Enum = StaticEnum<UDLSSMode>();
+
+	// UEnums are strongly typed, but then one can also cast a byte to an UEnum ...
+	if(Enum->IsValidEnumValue(int64(DLSSMode)) && (Enum->GetMaxEnumValue() != int64(DLSSMode)))
+	{
+		CurrentDLSSModeDeprecated = DLSSMode;
+		const bool bDLSSSupported = (DLSSSRSupport == UDLSSSupport::Supported);
+
+		TOptional<EDLSSQualityMode> MaybeQualityMode{};
+		if (bDLSSSupported)
+		{
+			if ((DLSSMode != UDLSSMode::Off) && (DLSSMode != UDLSSMode::Auto))
+			{
+				MaybeQualityMode = ToEDLSSQualityMode(DLSSMode);
+			}
+		}
+
+		static IConsoleVariable* CVarScreenPercentage = IConsoleManager::Get().FindConsoleVariable(TEXT("r.ScreenPercentage"));
+		if (MaybeQualityMode.IsSet() && DLSSUpscaler->IsQualityModeSupported(*MaybeQualityMode))
+		{
+			// enable DLSS, and set screen percentage for backward compatibility with earlier plugin versions
+			float OptimalScreenPercentage = 100.0f * DLSSUpscaler->GetOptimalResolutionFractionForQuality(*MaybeQualityMode);
+			if (CVarScreenPercentage != nullptr)
+			{
+				EConsoleVariableFlags Priority = static_cast<EConsoleVariableFlags>(CVarScreenPercentage->GetFlags() & ECVF_SetByMask);
+				CVarScreenPercentage->Set(OptimalScreenPercentage, Priority);
+			}
+			EnableDLSS(true);
+		}
+		else
+		{
+			// disable DLSS, and set screen percentage to 100 for backward compatibility with earlier plugin versions
+			if (CVarScreenPercentage != nullptr)
+			{
+				EConsoleVariableFlags Priority = static_cast<EConsoleVariableFlags>(CVarScreenPercentage->GetFlags() & ECVF_SetByMask);
+				CVarScreenPercentage->Set(100.0f, Priority);
+			}
+			// don't override DLAA if DLAA is still enabled
+			if (!bDLAAEnabledDeprecated)
+			{
+				EnableDLSS(false);
+			}
+		}
+
+		if (DLSSMode != UDLSSMode::Off)
+		{
+#if !UE_BUILD_SHIPPING
+			check(IsInGameThread());
+			DLSSErrorState.bIsDLSSModeUnsupported = !IsDLSSModeSupported(DLSSMode);
+			DLSSErrorState.InvalidDLSSMode = DLSSMode;
+#endif 
+		}
+	}
+	else
+	{
+#if !UE_BUILD_SHIPPING
+		FFrame::KismetExecutionMessage(*FString::Printf(
+			TEXT("SetDLSSMode should not be called with an invalid DLSSMode enum value (%d) \"%s\""), 
+			int64(DLSSMode), *StaticEnum<UDLSSMode>()->GetDisplayNameTextByValue(int64(DLSSMode)).ToString()),
+			ELogVerbosity::Error, SetDLSSModeInvalidEnumValueError);
+#endif 
+	}
+#endif	// WITH_DLSS
+}
+
+// deprecated
+UDLSSMode UDLSSLibrary::GetDLSSMode()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetDLSSMode should not be called before PostEngineInit"));
+		return UDLSSMode::Off;
+	}
+
+	static const auto CVarTemporalAAUpscaler = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TemporalAA.Upscaler"));
+	const bool bTemporalUpscalerActive = CVarTemporalAAUpscaler && CVarTemporalAAUpscaler->GetInt() != 0;
+
+	const bool bDLSSSupported = (DLSSSRSupport == UDLSSSupport::Supported);
+
+	static const auto CVarDLSSEnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.Enable"));
+	const bool bDLSSEnabled = CVarDLSSEnable && CVarDLSSEnable->GetInt();
+
+	if (bDLAAEnabledDeprecated)
+	{
+		// DLSS is mutually exclusive with DLAA, DLAA wins
+		return UDLSSMode::Off;
+	}
+	else if (bTemporalUpscalerActive && bDLSSSupported && bDLSSEnabled)
+	{
+		return CurrentDLSSModeDeprecated;
+	}
+#endif
+	return UDLSSMode::Off;
+}
+
+#ifndef ENGINE_CAN_SUPPORT_NIS_PLUGIN
+#define ENGINE_CAN_SUPPORT_NIS_PLUGIN 1
+#endif
+
+// deprecated
+void UDLSSLibrary::SetDLSSSharpness(float Sharpness)
+{
+#if WITH_DLSS
+
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("SetDLSSSharpness should not be called before PostEngineInit"));
+		return;
+	}
+	static const auto CVarNGXDLSSharpness = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.Sharpness"));
+	if (CVarNGXDLSSharpness)
+	{
+#if ENGINE_CAN_SUPPORT_NIS_PLUGIN
+		static const auto CVarNISSharpness = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Sharpness"));
+		static const auto CVarNISEnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Enable"));
+		const bool bHasNISPlugin = CVarNISSharpness != nullptr && CVarNISEnable != nullptr;
+		const bool bIsNISEnabled = bHasNISPlugin && CVarNISEnable->GetBool();
+
+		if (bHasNISPlugin && bIsNISEnabled)
+		{
+			const int32 PreferNISSharpen = CVarNGXDLSSPreferNISSharpen.GetValueOnAnyThread();
+			const bool bUseNISSharpen = PreferNISSharpen == 1 || (PreferNISSharpen == 2 && Sharpness > 0);
+			if (bUseNISSharpen)
+			{
+				Sharpness = FMath::Clamp(Sharpness, 0.0f, 1.0f);
+			}
+			// Quantize here so we can have sharpness snap to 0, which downstream is used to turn off the NGX sharpening flag
+			// CVarNGXDLSSharpness->Set(Sharpness, ECVF_SetByCommandline)  internally uses	Set(*FString::Printf(TEXT("%g"), InValue), SetBy);
+			CVarNGXDLSSharpness->Set(*FString::Printf(TEXT("%2.2f"), bUseNISSharpen ? 0.0f : Sharpness), ECVF_SetByCommandline);
+			CVarNISSharpness->Set(   *FString::Printf(TEXT("%2.2f"), bUseNISSharpen ? Sharpness : 0.0f), ECVF_SetByCommandline);
+		}
+		else
+#endif	// ENGINE_CAN_SUPPORT_NIS_PLUGIN
+		{
+			// Quantize here so we can have sharpness snap to 0, which downstream is used to turn off the NGX sharpening flag
+			// CVarNGXDLSSharpness->Set(Sharpness, ECVF_SetByCommandline)  internally uses	Set(*FString::Printf(TEXT("%g"), InValue), SetBy);
+			CVarNGXDLSSharpness->Set(*FString::Printf(TEXT("%2.2f"), Sharpness), ECVF_SetByCommandline);
+		}
+	}
+#endif
+}
+
+// deprecated
+float UDLSSLibrary::GetDLSSSharpness()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetDLSSSharpness should not be called before PostEngineInit"));
+		return 0.0f;
+	}
+
+	static const auto CVarNGXDLSSharpness = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NGX.DLSS.Sharpness"));
+	
+	if (CVarNGXDLSSharpness)
+	{
+#if ENGINE_CAN_SUPPORT_NIS_PLUGIN
+		static const auto CVarNISSharpness = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Sharpness"));
+		static const auto CVarNISEnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Enable"));
+		const bool bHasNISPlugin = CVarNISSharpness != nullptr && CVarNISEnable != nullptr;
+		const bool bIsNISEnabled = bHasNISPlugin && CVarNISEnable->GetBool();
+		const int32 PreferNISSharpen = CVarNGXDLSSPreferNISSharpen.GetValueOnAnyThread();
+		if (bHasNISPlugin && bIsNISEnabled && (PreferNISSharpen == 1))
+		{
+			return CVarNISSharpness->GetFloat();
+		}
+		else if (bHasNISPlugin && bIsNISEnabled && (PreferNISSharpen == 2))
+		{
+			const float DLSSSharpness = CVarNGXDLSSharpness->GetFloat();
+			if (DLSSSharpness < 0)
+			{
+				return DLSSSharpness;
+			}
+			else
+			{
+				return CVarNISSharpness->GetFloat();
+			}
+		}
+		else
+#endif
+		{
+			return CVarNGXDLSSharpness->GetFloat();
+		}
+	}
+#endif
+
+	return 0.0f;
+}
+
+UDLSSMode UDLSSLibrary::GetDefaultDLSSMode()
+{
+#if WITH_DLSS
+	if (!TryInitDLSSLibrary())
+	{
+		UE_LOG(LogDLSSBlueprint, Error, TEXT("GetDefaultDLSSMode should not be called before PostEngineInit"));
+		return UDLSSMode::Off;
+	}
+#endif
+	if (UDLSSLibrary::IsDLSSSupported())
+	{
+		return UDLSSMode::Auto;
+	}
+	else
+	{
+		return UDLSSMode::Off;
+	}
+}
+
+#if WITH_DLSS
+static UDLSSSupport ToUDLSSSupport(EDLSSSupport InDLSSSupport)
+{
+	switch (InDLSSSupport)
+	{
+		case EDLSSSupport::Supported:
+			return UDLSSSupport::Supported;
+
+		// this should be resolved at development time
+		default:
+			checkf(false, TEXT("ToUDLSSSupport should not be called with an out of range InDLSSSupport from the higher level code"));
+		case EDLSSSupport::NotSupported:
+			return UDLSSSupport::NotSupported;
+
+		case EDLSSSupport::NotSupportedIncompatibleHardware:
+			return UDLSSSupport::NotSupportedIncompatibleHardware;
+		case EDLSSSupport::NotSupportedDriverOutOfDate:
+			return UDLSSSupport::NotSupportedDriverOutOfDate;
+		case EDLSSSupport::NotSupportedOperatingSystemOutOfDate:
+			return UDLSSSupport::NotSupportedOperatingSystemOutOfDate;
+		case EDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive:
+			return UDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive;
+	}
+}
+
+// Delayed initialization, which allows this module to be available early so blueprints can be loaded before DLSS is available in PostEngineInit
+bool UDLSSLibrary::TryInitDLSSLibrary()
+{
+	if (bDLSSLibraryInitialized)
+	{
+		return true;
+	}
+
+	// Register this before we bail out so we can show error messages
+#if !UE_BUILD_SHIPPING
+	if (!DLSSOnScreenMessagesDelegateHandle.IsValid())
+	{
+		DLSSOnScreenMessagesDelegateHandle = FCoreDelegates::OnGetOnScreenMessages.AddStatic(&GetDLSSOnScreenMessages);
+	}
+#endif
+
+	IDLSSModuleInterface* DLSSModule = FModuleManager::GetModulePtr<IDLSSModuleInterface>(TEXT("DLSS"));
+	if (DLSSModule == nullptr)
+	{
+		return false;
+	}
+
+	DLSSUpscaler = DLSSModule->GetDLSSUpscaler();
+	DLSSSRSupport = ToUDLSSSupport(DLSSModule->QueryDLSSSRSupport());
+	DLSSRRSupport = ToUDLSSSupport(DLSSModule->QueryDLSSRRSupport());
+	DLSSModule->GetDLSSSRMinDriverVersion(MinDLSSSRDriverVersionMajor, MinDLSSSRDriverVersionMinor);
+	DLSSModule->GetDLSSRRMinDriverVersion(MinDLSSRRDriverVersionMajor, MinDLSSRRDriverVersionMinor);
+
+	checkf((DLSSModule->GetDLSSUpscaler() != nullptr) || (DLSSModule->QueryDLSSSRSupport() != EDLSSSupport::Supported), TEXT("mismatch between not having a valid DLSSModule->GetDLSSUpscaler() while also reporting DLSS as being supported by DLSSModule->QueryDLSSSRSupport() %u "), DLSSModule->QueryDLSSSRSupport());
+
+	bDLSSLibraryInitialized = true;
+
+	return true;
+}
+#endif // WITH_DLSS
+
+void FDLSSBlueprintModule::StartupModule()
+{
+	// write the plugin version to the log
+	// we use the DLSSBlueprint module to write this information because it is loaded on all platforms, in an early loading phase
+	TSharedPtr<IPlugin> ThisPlugin = IPluginManager::Get().FindPlugin(TEXT("DLSS"));
+	UE_LOG(LogDLSSBlueprint, Log, TEXT("Loaded DLSS-SR plugin version %s"), *ThisPlugin->GetDescriptor().VersionName);
+
+#if WITH_DLSS
+	// This initialization will likely not succeed unless this module has been moved to PostEngineInit, and that's ok
+	UDLSSLibrary::TryInitDLSSLibrary();
+#else
+	UE_LOG(LogDLSSBlueprint, Log, TEXT("DLSS is not supported on this platform at build time. The DLSS Blueprint library however is supported and stubbed out to ignore any calls to enable DLSS and will always return UDLSSSupport::NotSupportedByPlatformAtBuildTime, regardless of the underlying hardware. This can be used to e.g. to turn off DLSS related UI elements."));
+	UDLSSLibrary::DLSSSRSupport = UDLSSSupport::NotSupportedByPlatformAtBuildTime;
+#endif
+}
+
+void FDLSSBlueprintModule::ShutdownModule()
+{
+#if WITH_DLSS && !UE_BUILD_SHIPPING
+	if (UDLSSLibrary::DLSSOnScreenMessagesDelegateHandle.IsValid())
+	{
+		FCoreDelegates::OnGetOnScreenMessages.Remove(UDLSSLibrary::DLSSOnScreenMessagesDelegateHandle);
+		UDLSSLibrary::DLSSOnScreenMessagesDelegateHandle.Reset();
+	}
+#endif
+}
+
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FDLSSBlueprintModule, DLSSBlueprint)
+

Plugins/Marketplace/DLSS/Source/DLSSBlueprint/Public/DLSSLibrary.h

@@ -0,0 +1,202 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+#include "UObject/ObjectMacros.h"
+#include "UObject/Object.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Misc/CoreDelegates.h"
+
+#include "DLSSLibrary.generated.h"
+
+class FDLSSUpscaler;
+class FDelegateHandle;
+
+#ifndef WITH_DLSS
+#define WITH_DLSS 0
+#endif
+
+UENUM(BlueprintType)
+enum class UDLSSSupport : uint8
+{
+	Supported UMETA(DisplayName = "Supported"),
+
+	NotSupported UMETA(DisplayName = "Not Supported"),
+	NotSupportedIncompatibleHardware UMETA(DisplayName = "Incompatible Hardware", ToolTip = "DLSS requires an NVIDIA RTX GPU"),
+	NotSupportedDriverOutOfDate UMETA(DisplayName = "Driver Out of Date", ToolTip = "The driver is outdated. Also see GetDLSSMinimumDriverVersion"),
+	NotSupportedOperatingSystemOutOfDate UMETA(DisplayName = "Operating System Out of Date", ToolTip = "DLSS requires at least Windows 10 Fall 2017 Creators Update 64-bit, (v1709, build 16299)"),
+	NotSupportedByPlatformAtBuildTime UMETA(DisplayName = "Platform Not Supported At Build Time", ToolTip = "This platform doesn't not support DLSS at build time. Currently DLSS is only supported on Windows 64"),
+	NotSupportedIncompatibleAPICaptureToolActive UMETA(DisplayName = "Incompatible API Capture Tool Active", ToolTip = "DLSS is not compatible with an active API capture tool such as RenderDoc.")
+};
+
+
+UENUM(BlueprintType)
+enum class UDLSSMode : uint8
+{
+	Off              UMETA(DisplayName = "Off"),
+	Auto             UMETA(DisplayName = "Auto", ToolTip = "Not a real quality mode. Use Auto to query best settings for a given resolution with GetDLSSModeInformation"),
+	DLAA             UMETA(DisplayName = "DLAA"),
+	UltraQuality     UMETA(DisplayName = "Ultra Quality"),
+	Quality          UMETA(DisplayName = "Quality"),
+	Balanced         UMETA(DisplayName = "Balanced"),
+	Performance      UMETA(DisplayName = "Performance"),
+	UltraPerformance UMETA(DisplayName = "Ultra Performance")
+};
+
+UCLASS(MinimalAPI)
+class  UDLSSLibrary : public UBlueprintFunctionLibrary
+{
+	friend class FDLSSBlueprintModule;
+	GENERATED_BODY()
+public:
+
+	/** Check whether NVIDIA DLSS Super Resolution/DLAA is supported. Further details can be retrieved via 'Query DLSS-SR Support' */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Is DLSS-SR Supported"))
+	static DLSSBLUEPRINT_API bool IsDLSSSupported();
+
+	/** Check whether NVIDIA DLSS Ray Reconstruction is supported. Further details can be retrieved via 'Query DLSS-RR Support' */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Is DLSS-RR Supported"))
+	static DLSSBLUEPRINT_API bool IsDLSSRRSupported();
+
+	/** Check whether NVIDIA DLSS Super Resolution/DLAA is supported */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Query DLSS-SR Support"))
+	static DLSSBLUEPRINT_API UDLSSSupport QueryDLSSSupport();
+
+	/** Check whether NVIDIA DLSS Ray Reconstruction is supported */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Query DLSS-RR Support"))
+	static DLSSBLUEPRINT_API UDLSSSupport QueryDLSSRRSupport();
+
+	/** If QueryDLSSSupport returns "NotSupportedDriverOutOfDate", then MinDriverVersionMajor and MinDriverVersionMinor contains the required driver version.*/
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get DLSS-SR Minimum DriverVersion"))
+	static DLSSBLUEPRINT_API void GetDLSSMinimumDriverVersion(int32& MinDriverVersionMajor, int32& MinDriverVersionMinor);
+
+	/** If QueryDLSSRRSupport returns "NotSupportedDriverOutOfDate", then MinDriverVersionMajor and MinDriverVersionMinor contains the required driver version.*/
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get DLSS-RR Minimum DriverVersion"))
+	static DLSSBLUEPRINT_API void GetDLSSRRMinimumDriverVersion(int32& MinDriverVersionMajor, int32& MinDriverVersionMinor);
+
+	/**
+	 * Enable/disable DLSS Super Resolution/DLAA
+	 * To select a DLSS-SR quality mode, set an appropriate upscale screen percentage with r.ScreenPercentage. Use GetDlssModeInformation to find optimal screen percentage
+	 * To select DLAA, set the upscale screen percentage to 100 (r.ScreenPercentage=100)
+	 */
+	UFUNCTION(BlueprintCallable, Category = "DLSS", meta = (DisplayName = "Enable DLSS-SR"))
+	static DLSSBLUEPRINT_API void EnableDLSS(bool bEnabled);
+
+	/** Check whether DLSS Super Resolution/DLAA is enabled */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Is DLSS-SR Enabled"))
+	static DLSSBLUEPRINT_API bool IsDLSSEnabled();
+
+	/** (Unsupported in this release) Enable/disable DLSS Ray Reconstruction */
+	UFUNCTION(BlueprintCallable, Category = "DLSS", meta = (DisplayName = "Enable DLSS-RR"))
+	static DLSSBLUEPRINT_API void EnableDLSSRR(bool bEnabled);
+
+	/** Check whether DLSS Ray Reconstruction is enabled */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Is DLSS-RR Enabled"))
+	static DLSSBLUEPRINT_API bool IsDLSSRREnabled();
+
+	/** Enable/disable DLAA. Note that while DLAA is enabled, DLSS will be automatically disabled */
+	UFUNCTION(BlueprintCallable, Category = "DLSS", meta = (DisplayName = "Enable DLAA", DeprecatedFunction, DeprecationMessage = "Use 'Enable DLSS-SR' instead"))
+	static DLSSBLUEPRINT_API void EnableDLAA(bool bEnabled);
+
+	/** Check whether DLAA is enabled */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Is DLAA Enabled", DeprecatedFunction, DeprecationMessage = "Use 'Is DLSS-SR Enabled' instead"))
+	static DLSSBLUEPRINT_API bool IsDLAAEnabled();
+
+	/** Check whether a DLSS mode is supported */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Is DLSS-SR Mode Supported"))
+	static DLSSBLUEPRINT_API bool IsDLSSModeSupported(UDLSSMode DLSSMode);
+
+	/** Retrieve all supported DLSS modes. Can be used to populate UI */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get Supported DLSS-SR Modes"))
+	static DLSSBLUEPRINT_API TArray<UDLSSMode> GetSupportedDLSSModes();
+
+	/** Returns 'true' when running on RT-capable machine */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Is RayTracing Available"))
+	static DLSSBLUEPRINT_API bool IsRayTracingAvailable();
+
+	/** Provide additional details (such as screen percentage ranges) about a DLSS mode. Screen Resolution is required for Auto mode */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get DLSS-SR Mode Information"))
+	static DLSSBLUEPRINT_API void GetDLSSModeInformation(UDLSSMode DLSSMode, FVector2D ScreenResolution, bool& bIsSupported, float& OptimalScreenPercentage, bool& bIsFixedScreenPercentage, float& MinScreenPercentage, float& MaxScreenPercentage, float& OptimalSharpness);
+
+	/** The global screen percentage range that DLSS supports. Excludes DLSS modes with fixed screen percentage. Also see GetDLSSModeInformation*/
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get DLSS-SR Screenpercentage Range"))
+	static DLSSBLUEPRINT_API void GetDLSSScreenPercentageRange(float& MinScreenPercentage, float& MaxScreenPercentage);
+
+	/** Enable/disable DLSS */
+	UFUNCTION(BlueprintCallable, Category = "DLSS", meta=(WorldContext="WorldContextObject", DisplayName = "Set DLSS Mode", DeprecatedFunction, DeprecationMessage = "Use 'Enable DLSS-SR' instead"))
+	static DLSSBLUEPRINT_API void SetDLSSMode(UObject* WorldContextObject, UDLSSMode DLSSMode);
+
+	/* Read the current DLSS mode */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get DLSS Mode", DeprecatedFunction, DeprecationMessage = "Use 'Is DLSS-SR Enabled' instead"))
+	static DLSSBLUEPRINT_API UDLSSMode GetDLSSMode();
+
+	/* Set the console variables to enable additional DLSS sharpening. Set to 0 to disable (r.NGX.DLSS.Sharpness) */
+	UFUNCTION(BlueprintCallable, Category = "DLSS", meta = (DisplayName = "Set DLSS Sharpness", DeprecatedFunction, DeprecationMessage = "Use NIS sharpening instead"))
+	static DLSSBLUEPRINT_API void SetDLSSSharpness(float Sharpness);
+	
+	/* Read the console variables to infer the current DLSS sharpness (r.NGX.DLSS.Sharpness) */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get DLSS Sharpness", DeprecatedFunction, DeprecationMessage = "Use NIS sharpening instead"))
+	static DLSSBLUEPRINT_API float GetDLSSSharpness();
+
+	/* Find a reasonable default DLSS mode based on current hardware */
+	UFUNCTION(BlueprintPure, Category = "DLSS", meta = (DisplayName = "Get Default DLSS Mode"))
+	static DLSSBLUEPRINT_API UDLSSMode GetDefaultDLSSMode();
+
+private:
+	static UDLSSSupport DLSSSRSupport;
+	static UDLSSSupport DLSSRRSupport;
+
+#if WITH_DLSS
+	static int32 MinDLSSSRDriverVersionMinor;
+	static int32 MinDLSSSRDriverVersionMajor;
+	static int32 MinDLSSRRDriverVersionMinor;
+	static int32 MinDLSSRRDriverVersionMajor;
+	static FDLSSUpscaler* DLSSUpscaler;
+	static bool bDLSSLibraryInitialized;
+
+	static UDLSSMode CurrentDLSSModeDeprecated;
+	static bool bDLAAEnabledDeprecated;
+
+	static bool TryInitDLSSLibrary();
+
+	static int32 PreviousShadowDenoiser;
+	static int32 PreviousLumenSSR;
+	static int32 PreviousLumenTemporal;
+	static bool bDenoisingRequested;
+
+#if !UE_BUILD_SHIPPING
+	struct FDLSSErrorState
+	{
+		bool bIsDLSSModeUnsupported = false;
+		UDLSSMode InvalidDLSSMode = UDLSSMode::Off;
+	};
+
+	static FDLSSErrorState DLSSErrorState;
+
+	static void GetDLSSOnScreenMessages(TMultiMap<FCoreDelegates::EOnScreenMessageSeverity, FText>& OutMessages);
+	static FDelegateHandle DLSSOnScreenMessagesDelegateHandle;
+#endif
+
+#endif
+};
+
+class FDLSSBlueprintModule final : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+
+private:
+};

Plugins/Marketplace/DLSS/Source/DLSSEditor/DLSSEditor.Build.cs

@@ -0,0 +1,36 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+
+using UnrealBuildTool;
+using System.IO;
+
+public class DLSSEditor : ModuleRules
+{
+	public DLSSEditor(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"Engine",
+				"Settings",
+
+				"NGX",
+				"DLSS",
+				"NGXRHI",
+			}
+			);
+	}
+}

Plugins/Marketplace/DLSS/Source/DLSSEditor/Private/DLSSEditor.cpp

@@ -0,0 +1,94 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+#include "DLSSEditor.h"
+
+#include "DLSSUpscaler.h"
+#include "DLSS.h"
+#include "DLSSSettings.h"
+#include "NGXRHI.h"
+
+#include "CoreMinimal.h"
+#include "ISettingsModule.h"
+#include "ISettingsSection.h"
+#include "UObject/Class.h"
+#include "UObject/WeakObjectPtr.h"
+
+
+
+#define LOCTEXT_NAMESPACE "FDLSSEditorModule"
+
+DEFINE_LOG_CATEGORY(LogDLSSEditor);
+
+void FDLSSEditorModule::StartupModule()
+{
+	UE_LOG(LogDLSSEditor, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	
+	check(GIsEditor);
+	
+	// verify that the other DLSS modules are correctly hooked up
+	{
+		IDLSSModuleInterface* DLSSModule = &FModuleManager::LoadModuleChecked<IDLSSModuleInterface>(TEXT("DLSS"));
+		UE_LOG(LogDLSSEditor, Log, TEXT("DLSS module %p, QueryDLSSSupport = %u DLSSUpscaler = %p"), DLSSModule, static_cast<int>(DLSSModule->QueryDLSSSRSupport()), DLSSModule->GetDLSSUpscaler());
+		
+		bIsDLSSAvailable = DLSSModule->QueryDLSSSRSupport() == EDLSSSupport::Supported;
+	}
+
+	// register settings
+	{
+		ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
+		if (SettingsModule != nullptr)
+		{
+			{
+				auto Settings = GetMutableDefault<UDLSSSettings>();
+				if(bIsDLSSAvailable)
+				{
+					IDLSSModuleInterface* DLSSModule = &FModuleManager::LoadModuleChecked<IDLSSModuleInterface>(TEXT("DLSS"));
+					const NGXRHI* NGXRHIExtensions = DLSSModule->GetDLSSUpscaler()->GetNGXRHI();
+					Settings->GenericDLSSBinaryPath = NGXRHIExtensions->GetDLSSGenericBinaryInfo().Get<0>();
+					Settings->bGenericDLSSBinaryExists = NGXRHIExtensions->GetDLSSGenericBinaryInfo().Get<1>();
+
+					Settings->CustomDLSSBinaryPath = NGXRHIExtensions->GetDLSSCustomBinaryInfo().Get<0>();
+					Settings->bCustomDLSSBinaryExists = NGXRHIExtensions->GetDLSSCustomBinaryInfo().Get<1>();
+				}
+
+				ISettingsSectionPtr SettingsSection = SettingsModule->RegisterSettings("Project", "Plugins", "DLSS",
+					LOCTEXT("DLSSSettingsName", "NVIDIA DLSS"),
+					LOCTEXT("DLSSSettingsDescription", "Configure the NVIDIA DLSS plug-in."),
+					Settings
+				);
+			}
+
+			{
+				auto Settings = GetMutableDefault<UDLSSOverrideSettings>();
+
+				ISettingsSectionPtr SettingsSection = SettingsModule->RegisterSettings("Project", "Plugins", "DLSSOverride",
+					LOCTEXT("DLSSOverrideSettingsName", "NVIDIA DLSS Overrides (Local)"),
+					LOCTEXT("DLSSOverrideSettingsDescription", "Configure the local settings for the NVIDIA DLSS plug-in."),
+					Settings
+				);
+			}
+		}
+	}
+
+	UE_LOG(LogDLSSEditor, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+void FDLSSEditorModule::ShutdownModule()
+{
+	UE_LOG(LogDLSSEditor, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	
+	UE_LOG(LogDLSSEditor, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FDLSSEditorModule, DLSSEditor)
+

Plugins/Marketplace/DLSS/Source/DLSSEditor/Public/DLSSEditor.h

@@ -0,0 +1,30 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(LogDLSSEditor, Log, All);
+
+class FDLSSEditorModule final : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() final;
+	virtual void ShutdownModule() final;
+
+private:
+	bool bIsDLSSAvailable = false;
+};
+
+

Plugins/Marketplace/DLSS/Source/DLSSUtility/DLSSUtility.Build.cs

@@ -0,0 +1,51 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+using System.IO;
+
+public class DLSSUtility : ModuleRules
+{
+	public DLSSUtility(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				Path.Combine(GetModuleDirectory("Renderer"), "Private"),
+			}
+			);
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"RenderCore",
+				"Renderer",
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Engine",
+					"RHI",
+					"Projects"
+			}
+			);
+	}
+}

Plugins/Marketplace/DLSS/Source/DLSSUtility/Private/DLSSUtility.cpp

@@ -0,0 +1,33 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "DLSSUtility.h"
+#include "Modules/ModuleManager.h"
+#include "Interfaces/IPluginManager.h"
+#include "ShaderCore.h"
+
+#define LOCTEXT_NAMESPACE "FDLSSUtilityModule"
+
+void FDLSSUtilityModule::StartupModule()
+{
+	FString PluginShaderDir = FPaths::Combine(IPluginManager::Get().FindPlugin(TEXT("DLSS"))->GetBaseDir(), TEXT("Shaders"));
+	AddShaderSourceDirectoryMapping(TEXT("/Plugin/DLSS"), PluginShaderDir);
+
+}
+
+void FDLSSUtilityModule::ShutdownModule()
+{
+	
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FDLSSUtilityModule, DLSSUtility)

Plugins/Marketplace/DLSS/Source/DLSSUtility/Private/GBufferResolvePass.cpp

@@ -0,0 +1,226 @@
+/* 
+* Copyright (c) 2023 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "GBufferResolvePass.h"
+#if __has_include("DataDrivenShaderPlatformInfo.h")
+#include "DataDrivenShaderPlatformInfo.h"
+#endif
+#include "RHIResources.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "SceneTextureParameters.h"
+#include "SystemTextures.h"
+#include "SceneRendering.h"
+
+#if ENGINE_MAJOR_VERSION < 5 || ENGINE_MINOR_VERSION < 3
+#if SUPPORT_GUIDE_GBUFFER
+#error Guidebuffers unsupported on engine versions prior to 5.3
+#endif
+#endif
+
+static TAutoConsoleVariable<bool> CVarNGXDLSSDisableSubsurfaceCheckerboard(
+	TEXT("r.NGX.DLSS.DisableSubsurfaceCheckerboard"),
+	true,
+	TEXT("Skip checkerboard decoding for GBuffer Resolve Pass\n"),
+	ECVF_RenderThreadSafe
+);
+
+class FDiffuseSpecularAlbedoDim : SHADER_PERMUTATION_BOOL("DIFFUSE_SPECULAR_ALBEDO");
+class FForceDisableSubsurfaceCheckerboardDim : SHADER_PERMUTATION_BOOL("FORCE_DISABLE_SUBSURFACE_CHECKERBOARD");
+class FOutputSpecularHitTDim : SHADER_PERMUTATION_BOOL("SPECULAR_HITT");
+class FPassthroughDim : SHADER_PERMUTATION_BOOL("PASSTHROUGH_FEATURE_BUFFERS");
+class FGBufferResolvePS : public FGlobalShader
+{
+public:
+	DECLARE_GLOBAL_SHADER(FGBufferResolvePS);
+	SHADER_USE_PARAMETER_STRUCT(FGBufferResolvePS, FGlobalShader);
+
+	static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
+	{
+		FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
+	}
+
+	static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
+	{
+		FPermutationDomain PermutationVector(Parameters.PermutationId);
+
+		if (PermutationVector.Get<FOutputSpecularHitTDim>() == true)
+		{
+#if !SUPPORT_GUIDE_GBUFFER
+			return false;
+#endif
+		}
+
+		// Only cook for the platforms/RHIs where DLSS is supported, which is DX11,DX12 and Vulkan [on Win64]
+		return 	IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5) &&
+				IsPCPlatform(Parameters.Platform) && (
+					IsVulkanPlatform(Parameters.Platform) ||
+					IsD3DPlatform(Parameters.Platform));
+	}
+
+	using FPermutationDomain = TShaderPermutationDomain<FDiffuseSpecularAlbedoDim, FForceDisableSubsurfaceCheckerboardDim, FOutputSpecularHitTDim, FPassthroughDim>;
+
+	BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
+		SHADER_PARAMETER_STRUCT_INCLUDE(FSceneTextureShaderParameters, SceneTextures)
+		SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
+		SHADER_PARAMETER_TEXTURE(Texture2D, PreIntegratedGF)
+		SHADER_PARAMETER_SAMPLER(SamplerState, PreIntegratedGFSampler)
+		SHADER_PARAMETER_STRUCT(FScreenPassTextureViewportParameters, InputViewPort)
+		SHADER_PARAMETER_STRUCT(FScreenPassTextureViewportParameters, OutputViewPort)
+
+		// Should we explicitly ifdef these out for configs that can't use them
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D<float4>, PassthroughDiffuse)
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D<float4>, PassthroughSpecular)
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D<float4>, PassthroughNormalRoughness)
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D<float>, PassthroughDepth)
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D<float>, ReflectionHitDistance)
+
+		RENDER_TARGET_BINDING_SLOTS()
+	END_SHADER_PARAMETER_STRUCT()
+};
+
+IMPLEMENT_GLOBAL_SHADER(FGBufferResolvePS, "/Plugin/DLSS/Private/GBufferResolve.usf", "GBufferResolvePixelShader", SF_Pixel);
+FGBufferResolveOutputs AddGBufferResolvePass(FRDGBuilder& GraphBuilder,
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	const FSceneView& View,
+	const ITemporalUpscaler::FInputs& PassInputs,
+#else
+	const FViewInfo& View,
+#endif
+	FIntRect InputViewRect,
+	const bool bComputeDiffuseSpecularAlbedo
+)
+{
+	FGBufferResolveOutputs Outputs;
+	FGBufferResolvePS::FParameters* PassParameters = GraphBuilder.AllocParameters<FGBufferResolvePS::FParameters>();
+
+	// whether the engine has produced a set of precomposited reflection data
+	bool bPrecomposite = false;
+	bool bApplyHitT = false;
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	FSceneTextureShaderParameters SceneTextures = CreateSceneTextureShaderParameters(GraphBuilder, View, ESceneTextureSetupMode::All
+	);
+#else
+	FSceneTextureShaderParameters SceneTextures = CreateSceneTextureShaderParameters(GraphBuilder, View.GetSceneTexturesChecked(), View.GetFeatureLevel(), ESceneTextureSetupMode::All);
+#endif
+	PassParameters->SceneTextures = SceneTextures;
+
+	PassParameters->View = View.ViewUniformBuffer;
+	PassParameters->PreIntegratedGF = GSystemTextures.PreintegratedGF->GetRHI();
+	PassParameters->PreIntegratedGFSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
+
+	const FIntPoint OutputExtent = InputViewRect.Size();
+	if (bComputeDiffuseSpecularAlbedo)
+	{
+		FRDGTextureDesc AlbedoDesc(FRDGTextureDesc::Create2D(
+			OutputExtent,
+			PF_FloatR11G11B10, // TODO PF_B8G8R8A8 enough?
+			FClearValueBinding::None,
+			TexCreate_RenderTargetable | TexCreate_ShaderResource
+		));
+		Outputs.DiffuseAlbedo = GraphBuilder.CreateTexture(AlbedoDesc, TEXT("DLSSDiffuseAlbedo"));
+		Outputs.SpecularAlbedo = GraphBuilder.CreateTexture(AlbedoDesc, TEXT("DLSSSpecularAlbedo"));
+
+		PassParameters->RenderTargets[0] = FRenderTargetBinding(Outputs.DiffuseAlbedo, ERenderTargetLoadAction::ENoAction);
+		PassParameters->RenderTargets[1] = FRenderTargetBinding(Outputs.SpecularAlbedo, ERenderTargetLoadAction::ENoAction);
+
+		FRDGTextureDesc NormalDesc(FRDGTextureDesc::Create2D(
+			OutputExtent,
+			PF_FloatRGBA, // TODO PF_B8G8R8A8 enough?
+			FClearValueBinding::None,
+			TexCreate_RenderTargetable | TexCreate_ShaderResource
+		));
+		Outputs.Normals = GraphBuilder.CreateTexture(NormalDesc, TEXT("DLSSNormal"));
+
+		PassParameters->RenderTargets[2] = FRenderTargetBinding(Outputs.Normals, ERenderTargetLoadAction::ENoAction);
+
+
+		FRDGTextureDesc RoughnessDesc(FRDGTextureDesc::Create2D(
+			OutputExtent,
+			PF_R32_FLOAT, // TODO PF_B8G8R8A8 enough?
+			FClearValueBinding::None,
+			TexCreate_RenderTargetable | TexCreate_ShaderResource
+		));
+		Outputs.Roughness = GraphBuilder.CreateTexture(RoughnessDesc, TEXT("DLSSRoughness"));
+
+		PassParameters->RenderTargets[3] = FRenderTargetBinding(Outputs.Roughness, ERenderTargetLoadAction::ENoAction);
+
+
+		FRDGTextureDesc DepthDesc(FRDGTextureDesc::Create2D(
+			OutputExtent,
+			PF_R32_FLOAT, // TODO PF_B8G8R8A8 enough?
+			FClearValueBinding::None,
+			TexCreate_RenderTargetable | TexCreate_ShaderResource
+		));
+		Outputs.LinearDepth = GraphBuilder.CreateTexture(DepthDesc, TEXT("DLSSDepth"));
+
+		PassParameters->RenderTargets[4] = FRenderTargetBinding(Outputs.LinearDepth, ERenderTargetLoadAction::ENoAction);
+
+#if SUPPORT_GUIDE_GBUFFER
+
+		if (bComputeDiffuseSpecularAlbedo && PassInputs.GuideBuffers.ReflectionHitDistance.IsValid())
+		{
+			FRDGTextureDesc ReflectionHitDistanceTDesc(FRDGTextureDesc::Create2D(
+				OutputExtent,
+				PF_R32_FLOAT,
+				FClearValueBinding::None,
+				TexCreate_RenderTargetable | TexCreate_ShaderResource
+			));
+			Outputs.ReflectionHitDistance = GraphBuilder.CreateTexture(ReflectionHitDistanceTDesc, TEXT("DLSSSpecularHitT"));
+
+			PassParameters->RenderTargets[5] = FRenderTargetBinding(Outputs.ReflectionHitDistance, ERenderTargetLoadAction::ENoAction);
+
+			PassParameters->ReflectionHitDistance = PassInputs.GuideBuffers.ReflectionHitDistance.Texture;
+
+			bApplyHitT = true;
+		}
+
+		// procomposited guide buffers from the engine
+		bPrecomposite =
+			PassInputs.GuideBuffers.DiffuseGuideBuffer.IsValid() &&
+			PassInputs.GuideBuffers.SpecularGuideBuffer.IsValid() &&
+			PassInputs.GuideBuffers.NormalRoughnessGuideBuffer.IsValid() &&
+			PassInputs.GuideBuffers.DepthGuideBuffer.IsValid();
+
+		PassParameters->PassthroughDiffuse = PassInputs.GuideBuffers.DiffuseGuideBuffer.Texture;
+		PassParameters->PassthroughSpecular = PassInputs.GuideBuffers.SpecularGuideBuffer.Texture;
+		PassParameters->PassthroughNormalRoughness = PassInputs.GuideBuffers.NormalRoughnessGuideBuffer.Texture;
+		PassParameters->PassthroughDepth = PassInputs.GuideBuffers.DepthGuideBuffer.Texture;
+#endif
+	}
+
+	FGBufferResolvePS::FPermutationDomain PermutationVector;
+	PermutationVector.Set<FDiffuseSpecularAlbedoDim>(bComputeDiffuseSpecularAlbedo);
+	PermutationVector.Set<FOutputSpecularHitTDim>(bApplyHitT);
+	PermutationVector.Set<FForceDisableSubsurfaceCheckerboardDim>(CVarNGXDLSSDisableSubsurfaceCheckerboard.GetValueOnRenderThread());
+	PermutationVector.Set<FPassthroughDim>(bPrecomposite);
+
+	const FGlobalShaderMap* ShaderMap = GetGlobalShaderMap(View.GetFeatureLevel());
+	TShaderMapRef<FGBufferResolvePS> PixelShader(ShaderMap, PermutationVector);
+	FScreenPassTextureViewport InputViewport(InputViewRect);
+	// shift output buffers to top left corner
+	FScreenPassTextureViewport OutputViewport(OutputExtent);
+	PassParameters->InputViewPort = GetScreenPassTextureViewportParameters(InputViewport);
+	PassParameters->OutputViewPort = GetScreenPassTextureViewportParameters(OutputViewport);
+
+	AddDrawScreenPass(
+		GraphBuilder,
+		RDG_EVENT_NAME("GBufferResolve%s",
+			bComputeDiffuseSpecularAlbedo ? TEXT(" DiffuseSpecularAlbedo") : TEXT("")
+		),
+		View,
+		OutputViewport,
+		InputViewport,
+		PixelShader,
+		PassParameters);
+	
+	return Outputs;
+}

Plugins/Marketplace/DLSS/Source/DLSSUtility/Private/VelocityCombinePass.cpp

@@ -0,0 +1,168 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "VelocityCombinePass.h"
+
+#include "RenderGraphUtils.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "ScreenPass.h"
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 2
+#include "DataDrivenShaderPlatformInfo.h"
+#endif
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION < 3
+#include "ScenePrivate.h"
+#endif
+
+const int32 kVelocityCombineComputeTileSizeX = FComputeShaderUtils::kGolden2DGroupSize;
+const int32 kVelocityCombineComputeTileSizeY = FComputeShaderUtils::kGolden2DGroupSize;
+
+
+class FDilateMotionVectorsDim : SHADER_PERMUTATION_BOOL("DILATE_MOTION_VECTORS");
+class FSupportAlternateMotionVectorDim : SHADER_PERMUTATION_BOOL("SUPPORT_ALTERNATE_MOTION_VECTOR");
+
+class FVelocityCombineCS : public FGlobalShader
+{
+public:
+	static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
+	{
+		// Only cook for the platforms/RHIs where DLSS is supported, which is DX11,DX12 and Vulkan [on Win64]
+		return 	IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5) &&
+				IsPCPlatform(Parameters.Platform) && (
+					IsVulkanPlatform(Parameters.Platform) ||
+					IsD3DPlatform(Parameters.Platform));
+	}
+
+	static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
+	{
+		FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
+		OutEnvironment.SetDefine(TEXT("THREADGROUP_SIZEX"), kVelocityCombineComputeTileSizeX);
+		OutEnvironment.SetDefine(TEXT("THREADGROUP_SIZEY"), kVelocityCombineComputeTileSizeY);
+	}
+	using FPermutationDomain = TShaderPermutationDomain<FDilateMotionVectorsDim, FSupportAlternateMotionVectorDim>;
+
+	DECLARE_GLOBAL_SHADER(FVelocityCombineCS);
+	SHADER_USE_PARAMETER_STRUCT(FVelocityCombineCS, FGlobalShader);
+
+	BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
+		// Input images
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D, VelocityTexture)
+		SHADER_PARAMETER_SAMPLER(SamplerState, VelocityTextureSampler)
+		SHADER_PARAMETER_STRUCT(FScreenPassTextureViewportParameters, Velocity)
+
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D, DepthTexture)
+		SHADER_PARAMETER_SAMPLER(SamplerState, DepthTextureSampler)
+
+		SHADER_PARAMETER(FVector2f, TemporalJitterPixels)
+
+		SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
+		
+		// Output images
+		SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D, OutVelocityCombinedTexture)
+		SHADER_PARAMETER_STRUCT(FScreenPassTextureViewportParameters, CombinedVelocity)
+
+		// motion vectors to consider instead of the standard ones from the engine
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D<float2>, AlternateMotionVectorsTexture)
+		
+	END_SHADER_PARAMETER_STRUCT()
+};
+
+IMPLEMENT_GLOBAL_SHADER(FVelocityCombineCS, "/Plugin/DLSS/Private/VelocityCombine.usf", "VelocityCombineMain", SF_Compute);
+
+FRDGTextureRef AddVelocityCombinePass(
+	FRDGBuilder& GraphBuilder,
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	const FSceneView& View,
+#else
+	const FViewInfo& View,
+#endif
+	FRDGTextureRef InSceneDepthTexture,
+	FRDGTextureRef InVelocityTexture,
+	FRDGTextureRef AlternateMotionVectorTexture,
+	FIntRect InputViewRect,
+	FIntRect DLSSOutputViewRect,
+	FVector2f TemporalJitterPixels,
+	bool bDilateMotionVectors
+)
+{
+	const FIntRect OutputViewRect = FIntRect( FIntPoint::ZeroValue, bDilateMotionVectors ? DLSSOutputViewRect.Size() : InputViewRect.Size());
+
+	FRDGTextureDesc CombinedVelocityDesc = FRDGTextureDesc::Create2D(
+		OutputViewRect.Size(),
+		PF_G16R16F,
+		FClearValueBinding::Black,
+		TexCreate_ShaderResource | TexCreate_UAV);
+	const TCHAR* OutputName = TEXT("DLSSCombinedVelocity");
+	FRDGTextureRef CombinedVelocityTexture = GraphBuilder.CreateTexture(
+		CombinedVelocityDesc,
+		OutputName);
+
+	FVelocityCombineCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FVelocityCombineCS::FParameters>();
+
+	const bool bHasAlternateMotionVectors = AlternateMotionVectorTexture != nullptr;
+
+	// input velocity
+	{
+		PassParameters->VelocityTexture = InVelocityTexture;
+		PassParameters->VelocityTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
+
+		// we use InSceneDepthTexture here and not InVelocityTexture since the latter can be a 1x1 black texture
+		check(InVelocityTexture->Desc.Extent == FIntPoint(1, 1) || InVelocityTexture->Desc.Extent == InSceneDepthTexture->Desc.Extent);
+		FScreenPassTextureViewport velocityViewport(InSceneDepthTexture, InputViewRect);
+		FScreenPassTextureViewportParameters velocityViewportParameters = GetScreenPassTextureViewportParameters(velocityViewport);
+		PassParameters->Velocity = velocityViewportParameters;
+	}
+	// input depth
+	{
+		PassParameters->DepthTexture = InSceneDepthTexture;
+		PassParameters->DepthTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
+	}
+
+	// replacement motion vectors for items like reflections that DLSS might prefer to track	
+	{
+		PassParameters->AlternateMotionVectorsTexture = AlternateMotionVectorTexture;
+	}
+
+	// output combined velocity
+	{
+		PassParameters->OutVelocityCombinedTexture = GraphBuilder.CreateUAV(CombinedVelocityTexture);
+
+		FScreenPassTextureViewport CombinedVelocityViewport(CombinedVelocityTexture, OutputViewRect);
+		FScreenPassTextureViewportParameters CombinedVelocityViewportParameters = GetScreenPassTextureViewportParameters(CombinedVelocityViewport);
+		PassParameters->CombinedVelocity = CombinedVelocityViewportParameters;
+	}
+
+	// various state
+	{
+		PassParameters->TemporalJitterPixels = TemporalJitterPixels;
+		PassParameters->View = View.ViewUniformBuffer;
+	}
+
+	FVelocityCombineCS::FPermutationDomain PermutationVector;
+	PermutationVector.Set<FDilateMotionVectorsDim>(bDilateMotionVectors);
+	PermutationVector.Set<FSupportAlternateMotionVectorDim>(bHasAlternateMotionVectors);
+
+	const FGlobalShaderMap* ShaderMap = GetGlobalShaderMap(View.GetFeatureLevel());
+	TShaderMapRef<FVelocityCombineCS> ComputeShader(ShaderMap, PermutationVector);
+
+	FComputeShaderUtils::AddPass(
+		GraphBuilder,
+		RDG_EVENT_NAME("Velocity Combine%s (%dx%d -> %dx%d)", 
+			bDilateMotionVectors ? TEXT(" Dilate") : TEXT(""),
+			InputViewRect.Width(), InputViewRect.Height(),
+			OutputViewRect.Width(), OutputViewRect.Height()
+		),
+		ComputeShader,
+		PassParameters,
+		FComputeShaderUtils::GetGroupCount(OutputViewRect.Size(), FComputeShaderUtils::kGolden2DGroupSize));
+		
+	return CombinedVelocityTexture;
+}

Plugins/Marketplace/DLSS/Source/DLSSUtility/Public/DLSSUtility.h

@@ -0,0 +1,26 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+
+class FDLSSUtilityModule final : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+
+private:
+};

Plugins/Marketplace/DLSS/Source/DLSSUtility/Public/GBufferResolvePass.h

@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2023 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "RendererInterface.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "ScreenPass.h"
+#include "SceneTexturesConfig.h"
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+#include "TemporalUpscaler.h"
+using ITemporalUpscaler = UE::Renderer::Private::ITemporalUpscaler;
+#endif
+
+#ifndef SUPPORT_GUIDE_GBUFFER
+#define SUPPORT_GUIDE_GBUFFER 0
+#endif
+
+struct FGBufferResolveOutputs
+{
+	FRDGTextureRef DiffuseAlbedo = nullptr;
+	FRDGTextureRef SpecularAlbedo = nullptr;
+	
+	FRDGTextureRef Normals = nullptr;
+	FRDGTextureRef Roughness = nullptr;
+	
+	FRDGTextureRef LinearDepth = nullptr;
+
+#if SUPPORT_GUIDE_GBUFFER
+	FRDGTextureRef ReflectionHitDistance = nullptr;
+#endif
+};
+
+extern DLSSUTILITY_API FGBufferResolveOutputs AddGBufferResolvePass(
+	FRDGBuilder& GraphBuilder,
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	const FSceneView& View,
+	const ITemporalUpscaler::FInputs& PassInputs,
+#else
+	const FViewInfo& View,
+#endif
+	FIntRect InputViewRect,
+	const bool bComputeDiffuseSpecularAlbedo
+);

Plugins/Marketplace/DLSS/Source/DLSSUtility/Public/VelocityCombinePass.h

@@ -0,0 +1,34 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "RendererInterface.h"
+#include "Runtime/Launch/Resources/Version.h"
+#include "SceneTexturesConfig.h"
+
+
+extern DLSSUTILITY_API FRDGTextureRef AddVelocityCombinePass(
+	FRDGBuilder& GraphBuilder,
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	const FSceneView& View,
+#else
+	const FViewInfo& View,
+#endif
+	FRDGTextureRef InSceneDepthTexture,
+	FRDGTextureRef InVelocityTexture,
+	FRDGTextureRef AlternateMotionVectorTexture,
+	FIntRect InputViewRect,
+	FIntRect DLSSOutputViewRect,
+	FVector2f TemporalJitterPixels,
+	bool bDilateMotionVectors
+);

Plugins/Marketplace/DLSS/Source/NGXD3D11RHI/NGXD3D11RHI.Build.cs

@@ -0,0 +1,56 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+
+public class NGXD3D11RHI : ModuleRules
+{
+	public NGXD3D11RHI(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Core",
+					"Engine",
+					"RenderCore",
+					"RHI",
+					"D3D11RHI",
+
+					"NGX",
+					"NGXRHI",
+			}
+			);
+		
+		// those come from the D3D11RHI
+		AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
+	}
+}

Plugins/Marketplace/DLSS/Source/NGXD3D11RHI/Private/NGXD3D11RHI.cpp

@@ -0,0 +1,385 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "NGXD3D11RHI.h"
+
+#include "nvsdk_ngx.h"
+#include "nvsdk_ngx_helpers.h"
+#include "nvsdk_ngx_helpers_dlssd.h"
+
+#include "ID3D11DynamicRHI.h"
+#include "GenericPlatform/GenericPlatformFile.h"
+
+DEFINE_LOG_CATEGORY_STATIC(LogDLSSNGXD3D11RHI, Log, All);
+
+#define LOCTEXT_NAMESPACE "FNGXD3D11RHIModule"
+
+class FD3D11NGXFeatureHandle final : public NGXDLSSFeature
+{
+	
+public:
+
+	using NGXDLSSFeature::NGXDLSSFeature;
+
+	virtual ~FD3D11NGXFeatureHandle()
+	{
+		check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+		check(NGXRHI::NGXInitialized());
+		NVSDK_NGX_Result ResultReleaseFeature = NVSDK_NGX_D3D11_ReleaseFeature(Feature);
+		checkf(NVSDK_NGX_SUCCEED(ResultReleaseFeature), TEXT("NVSDK_NGX_D3D11_ReleaseFeature failed! (%u %s), %s"), ResultReleaseFeature, GetNGXResultAsString(ResultReleaseFeature), *Desc.GetDebugDescription());
+
+		if (Parameter != nullptr)
+		{
+			NVSDK_NGX_Result ResultDestroyParameter = NVSDK_NGX_D3D11_DestroyParameters(Parameter);
+			checkf(NVSDK_NGX_SUCCEED(ResultDestroyParameter), TEXT("NVSDK_NGX_D3D11_DestroyParameters failed! (%u %s), %s"), ResultDestroyParameter, GetNGXResultAsString(ResultDestroyParameter), *Desc.GetDebugDescription());
+		}
+	}
+};
+
+class FNGXD3D11RHI final : public NGXRHI
+{
+public:
+	FNGXD3D11RHI(const FNGXRHICreateArguments& Arguments);
+	
+	virtual void ExecuteDLSS(FRHICommandList& CmdList, const FRHIDLSSArguments& InArguments, FDLSSStateRef InDLSSState) final;
+	virtual ~FNGXD3D11RHI();
+	virtual bool IsRRSupportedByRHI() const override { return false; }
+private:
+
+	ID3D11DynamicRHI* D3D11RHI = nullptr;
+	ID3D11Device* Direct3DDevice = nullptr;
+	ID3D11DeviceContext* Direct3DDeviceIMContext = nullptr;
+
+	NVSDK_NGX_Result Init_NGX_D3D11(const FNGXRHICreateArguments& InArguments, const wchar_t* InApplicationDataPath, ID3D11Device* InHandle, const NVSDK_NGX_FeatureCommonInfo* InFeatureInfo);
+	static bool IsIncompatibleAPICaptureToolActive(ID3D11Device* InDirect3DDevice);
+
+};
+
+bool FNGXD3D11RHI::IsIncompatibleAPICaptureToolActive(ID3D11Device* InDirect3DDevice)
+{
+	// RenderDoc
+	{
+		IID RenderDocID;
+		if (SUCCEEDED(IIDFromString(L"{A7AA6116-9C8D-4BBA-9083-B4D816B71B78}", &RenderDocID)))
+		{
+			TRefCountPtr<IUnknown> RenderDoc;
+			if (SUCCEEDED(InDirect3DDevice->QueryInterface(RenderDocID, (void**)RenderDoc.GetInitReference())))
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+NVSDK_NGX_Result FNGXD3D11RHI::Init_NGX_D3D11(const FNGXRHICreateArguments& InArguments, const wchar_t* InApplicationDataPath, ID3D11Device* InHandle, const NVSDK_NGX_FeatureCommonInfo* InFeatureInfo)
+{
+	NVSDK_NGX_Result Result = NVSDK_NGX_Result_Fail;
+	int32 APIVersion = NVSDK_NGX_VERSION_API_MACRO;
+	do 
+	{
+		if (InArguments.InitializeNGXWithNGXApplicationID())
+		{
+			Result = NVSDK_NGX_D3D11_Init(InArguments.NGXAppId, InApplicationDataPath, InHandle, InFeatureInfo, static_cast<NVSDK_NGX_Version>(APIVersion));
+			UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("NVSDK_NGX_D3D11_Init(AppID= %u, APIVersion = 0x%x) -> (%u %s)"), InArguments.NGXAppId, APIVersion, Result, GetNGXResultAsString(Result));
+		}
+		else
+		{
+			Result = NVSDK_NGX_D3D11_Init_with_ProjectID(TCHAR_TO_UTF8(*InArguments.UnrealProjectID), NVSDK_NGX_ENGINE_TYPE_UNREAL, TCHAR_TO_UTF8(*InArguments.UnrealEngineVersion), InApplicationDataPath, InHandle, InFeatureInfo, static_cast<NVSDK_NGX_Version>(APIVersion));
+			UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("NVSDK_NGX_D3D11_Init_with_ProjectID(ProjectID = %s, EngineVersion=%s, APIVersion = 0x%x) -> (%u %s)"), *InArguments.UnrealProjectID, *InArguments.UnrealEngineVersion, APIVersion, Result, GetNGXResultAsString(Result));
+		}
+
+		if (NVSDK_NGX_FAILED(Result) && IsSafeToShutdownNGX())
+		{
+			NVSDK_NGX_D3D11_Shutdown1(InHandle);
+		}
+		
+		--APIVersion;
+	} while (NVSDK_NGX_FAILED(Result) && APIVersion >= NVSDK_NGX_VERSION_API_MACRO_BASE_LINE);
+
+	if (!NVSDK_NGX_FAILED(Result) && (APIVersion + 1 < NVSDK_NGX_VERSION_API_MACRO_WITH_LOGGING))
+	{
+		UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("Warning: NVSDK_NGX_D3D11_Init succeeded, but the driver installed on this system is too old the support the NGX logging API. The console variables r.NGX.LogLevel and r.NGX.EnableOtherLoggingSinks will have no effect and NGX logs will only show up in their own log files, and not in UE's log files."));
+	}
+
+	return Result;
+}
+
+FNGXD3D11RHI::FNGXD3D11RHI(const FNGXRHICreateArguments& Arguments)
+	: NGXRHI(Arguments)
+	, D3D11RHI(CastDynamicRHI<ID3D11DynamicRHI>(Arguments.DynamicRHI))
+	, Direct3DDevice(D3D11RHI->RHIGetDevice())
+	, Direct3DDeviceIMContext(D3D11RHI->RHIGetDeviceContext())
+{
+	ensure(D3D11RHI);
+	ensure(Direct3DDevice);
+
+	bIsIncompatibleAPICaptureToolActive = IsIncompatibleAPICaptureToolActive(Direct3DDevice);
+	
+	const FString NGXLogDir = GetNGXLogDirectory();
+	IPlatformFile::GetPlatformPhysical().CreateDirectoryTree(*NGXLogDir);
+
+	NVSDK_NGX_Result ResultInit = Init_NGX_D3D11(Arguments, *NGXLogDir, Direct3DDevice, CommonFeatureInfo());
+	UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("NVSDK_NGX_D3D11_Init (Log %s) -> (%u %s)"), *NGXLogDir, ResultInit, GetNGXResultAsString(ResultInit));
+	
+	// store for the higher level code interpret
+	NGXQueryFeature.NGXInitResult = ResultInit;
+
+	if (NVSDK_NGX_Result_FAIL_OutOfDate == ResultInit)
+	{
+		NGXQueryFeature.NGXDriverRequirements.DriverUpdateRequired = true;
+	}
+	else if (NVSDK_NGX_SUCCEED(ResultInit))
+	{
+		bNGXInitialized = true;
+
+		NVSDK_NGX_Result ResultGetParameters = NVSDK_NGX_D3D11_GetCapabilityParameters(&NGXQueryFeature.CapabilityParameters);
+
+		UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("NVSDK_NGX_D3D11_GetCapabilityParameters -> (%u %s)"), ResultGetParameters, GetNGXResultAsString(ResultGetParameters));
+
+		if (NVSDK_NGX_Result_FAIL_OutOfDate == ResultGetParameters)
+		{
+			NGXQueryFeature.NGXDriverRequirements.DriverUpdateRequired = true;
+		}
+
+		if (NVSDK_NGX_SUCCEED(ResultGetParameters))
+		{
+			NGXQueryFeature.QueryDLSSSupport();
+		}
+	}
+}
+
+FNGXD3D11RHI::~FNGXD3D11RHI()
+{
+	UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	if(bNGXInitialized)
+	{
+		// Destroy the parameters and features before we call NVSDK_NGX_D3D11_Shutdown1
+		ReleaseAllocatedFeatures();
+
+		NVSDK_NGX_Result Result;
+		if (NGXQueryFeature.CapabilityParameters != nullptr)
+		{
+			Result = NVSDK_NGX_D3D11_DestroyParameters(NGXQueryFeature.CapabilityParameters);
+			UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("NVSDK_NGX_D3D11_DestroyParameters -> (%u %s)"), Result, GetNGXResultAsString(Result));
+		}
+		if (IsSafeToShutdownNGX())
+		{
+			Result = NVSDK_NGX_D3D11_Shutdown1(Direct3DDevice);
+			UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("NVSDK_NGX_D3D11_Shutdown1 -> (%u %s)"), Result, GetNGXResultAsString(Result));
+		}
+		bNGXInitialized = false;
+	}
+	UE_LOG(LogDLSSNGXD3D11RHI, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+template <typename T>
+static T GetCommonEvalParams(ID3D11DynamicRHI* D3D11RHI, const FRHIDLSSArguments& InArguments)
+{
+	T EvalParams;
+	FMemory::Memzero(EvalParams);
+
+	EvalParams.InOutputSubrectBase.X = InArguments.DestRect.Min.X;
+	EvalParams.InOutputSubrectBase.Y = InArguments.DestRect.Min.Y;
+
+	EvalParams.InRenderSubrectDimensions.Width = InArguments.SrcRect.Width();
+	EvalParams.InRenderSubrectDimensions.Height = InArguments.SrcRect.Height();
+
+	EvalParams.InColorSubrectBase.X = InArguments.SrcRect.Min.X;
+	EvalParams.InColorSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+	EvalParams.pInDepth = D3D11RHI->RHIGetResource(InArguments.InputDepth);
+	EvalParams.InDepthSubrectBase.X = InArguments.SrcRect.Min.X;
+	EvalParams.InDepthSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+	EvalParams.pInMotionVectors = D3D11RHI->RHIGetResource(InArguments.InputMotionVectors);
+	// The VelocityCombine pass puts the motion vectors into the top left corner
+	EvalParams.InMVSubrectBase.X = 0;
+	EvalParams.InMVSubrectBase.Y = 0;
+
+	EvalParams.pInExposureTexture = InArguments.bUseAutoExposure ? nullptr : D3D11RHI->RHIGetResource(InArguments.InputExposure);
+	EvalParams.InPreExposure = InArguments.PreExposure;
+
+	EvalParams.InJitterOffsetX = InArguments.JitterOffset.X;
+	EvalParams.InJitterOffsetY = InArguments.JitterOffset.Y;
+
+	EvalParams.InMVScaleX = InArguments.MotionVectorScale.X;
+	EvalParams.InMVScaleY = InArguments.MotionVectorScale.Y;
+	EvalParams.InReset = InArguments.bReset;
+
+	EvalParams.InFrameTimeDeltaInMsec = InArguments.DeltaTimeMS;
+
+	return EvalParams;
+}
+
+void FNGXD3D11RHI::ExecuteDLSS(FRHICommandList& CmdList, const FRHIDLSSArguments& InArguments, FDLSSStateRef InDLSSState)
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	check(IsDLSSAvailable());
+	if (!IsDLSSAvailable()) 
+		return;
+	InArguments.Validate();
+
+	if (InDLSSState->RequiresFeatureRecreation(InArguments))
+	{
+		check(!InDLSSState->DLSSFeature || InDLSSState->HasValidFeature());
+		InDLSSState->DLSSFeature = nullptr;
+	}
+
+	if (InArguments.bReset)
+	{
+		check(!InDLSSState->DLSSFeature);
+		InDLSSState->DLSSFeature = FindFreeFeature(InArguments);
+	}
+
+	if (!InDLSSState->DLSSFeature)
+	{
+		NVSDK_NGX_Parameter* NewNGXParameterHandle = nullptr;
+
+		NVSDK_NGX_Result Result = NVSDK_NGX_D3D11_AllocateParameters(&NewNGXParameterHandle);
+		checkf(NVSDK_NGX_SUCCEED(Result), TEXT("NVSDK_NGX_D3D11_AllocateParameters failed! (%u %s)"), Result, GetNGXResultAsString(Result));
+
+		ApplyCommonNGXParameterSettings(NewNGXParameterHandle, InArguments);
+
+		if (InArguments.DenoiserMode == ENGXDLSSDenoiserMode::DLSSRR)
+		{
+			// DLSS-RR feature creation
+			NVSDK_NGX_DLSSD_Create_Params DlssRRCreateParams = InArguments.GetNGXDLSSRRCreateParams();
+			NVSDK_NGX_Handle* NewNGXFeatureHandle = nullptr;
+			NVSDK_NGX_Result ResultCreate = NGX_D3D11_CREATE_DLSSD_EXT(
+				Direct3DDeviceIMContext,
+				&NewNGXFeatureHandle,
+				NewNGXParameterHandle,
+				&DlssRRCreateParams);
+			if (NVSDK_NGX_SUCCEED(ResultCreate))
+			{
+				InDLSSState->DLSSFeature = MakeShared<FD3D11NGXFeatureHandle>(NewNGXFeatureHandle, NewNGXParameterHandle, InArguments.GetFeatureDesc(), FrameCounter);
+				InDLSSState->DLSSFeature->bHasDLSSRR = true;
+			}
+			else
+			{
+				UE_LOG(LogDLSSNGXD3D11RHI, Error,
+					TEXT("NGX_D3D11_CREATE_DLSSD_EXT failed, falling back to DLSS-SR! (%u %s), %s"),
+					ResultCreate,
+					GetNGXResultAsString(ResultCreate),
+					*InArguments.GetFeatureDesc().GetDebugDescription());
+				InDLSSState->DLSSFeature.Reset();
+			}
+		}
+		if (!InDLSSState->DLSSFeature.IsValid())
+		{
+			// DLSS-SR feature creation
+			NVSDK_NGX_DLSS_Create_Params DlssCreateParams = InArguments.GetNGXDLSSCreateParams();
+			NVSDK_NGX_Handle* NewNGXFeatureHandle = nullptr;
+			NVSDK_NGX_Result ResultCreate = NGX_D3D11_CREATE_DLSS_EXT(
+				Direct3DDeviceIMContext,
+				&NewNGXFeatureHandle,
+				NewNGXParameterHandle,
+				&DlssCreateParams);
+			checkf(NVSDK_NGX_SUCCEED(ResultCreate), TEXT("NGX_D3D11_CREATE_DLSS_EXT failed! (%u %s), %s"),
+				ResultCreate,
+				GetNGXResultAsString(ResultCreate),
+				*InArguments.GetFeatureDesc().GetDebugDescription());
+			InDLSSState->DLSSFeature = MakeShared<FD3D11NGXFeatureHandle>(NewNGXFeatureHandle, NewNGXParameterHandle, InArguments.GetFeatureDesc(), FrameCounter);
+		}
+
+		RegisterFeature(InDLSSState->DLSSFeature);
+	}
+
+	check(InDLSSState->HasValidFeature());
+
+	// execute
+
+	D3D11RHI->RHIRegisterWork(1);
+
+	if (InDLSSState->DLSSFeature->bHasDLSSRR)
+	{
+		NVSDK_NGX_D3D11_DLSSD_Eval_Params DlssRREvalParams = GetCommonEvalParams<NVSDK_NGX_D3D11_DLSSD_Eval_Params>(D3D11RHI, InArguments);
+
+		DlssRREvalParams.pInOutput = D3D11RHI->RHIGetResource(InArguments.OutputColor);
+		DlssRREvalParams.pInColor = D3D11RHI->RHIGetResource(InArguments.InputColor);
+
+		// The GBufferResolve pass puts the albedos into the top left corner
+		DlssRREvalParams.pInDiffuseAlbedo = D3D11RHI->RHIGetResource(InArguments.InputDiffuseAlbedo);
+		DlssRREvalParams.InDiffuseAlbedoSubrectBase.X = 0;
+		DlssRREvalParams.InDiffuseAlbedoSubrectBase.Y = 0;
+
+		DlssRREvalParams.pInSpecularAlbedo = D3D11RHI->RHIGetResource(InArguments.InputSpecularAlbedo);
+		DlssRREvalParams.InSpecularAlbedoSubrectBase.X = 0;
+		DlssRREvalParams.InSpecularAlbedoSubrectBase.Y = 0;
+
+		DlssRREvalParams.pInNormals = D3D11RHI->RHIGetResource(InArguments.InputNormals);
+		DlssRREvalParams.pInRoughness = D3D11RHI->RHIGetResource(InArguments.InputRoughness);
+
+#if SUPPORT_GUIDE_GBUFFER
+		if (InArguments.InputReflectionHitDistance)
+		{
+			DlssRREvalParams.pInSpecularHitDistance = D3D11RHI->RHIGetResource(InArguments.InputReflectionHitDistance);
+			DlssRREvalParams.InSpecularHitDistanceSubrectBase.X = 0;
+			DlssRREvalParams.InSpecularHitDistanceSubrectBase.Y = 0;
+
+			// Yes, the interface takes a non-const ptr as an argument
+			DlssRREvalParams.pInWorldToViewMatrix = const_cast<float*>(InArguments.ViewMatrix);
+			DlssRREvalParams.pInViewToClipMatrix = const_cast<float*>(InArguments.ProjectionMatrix);
+		}
+#endif
+
+		NVSDK_NGX_Result ResultEvaluate = NGX_D3D11_EVALUATE_DLSSD_EXT(
+			Direct3DDeviceIMContext,
+			InDLSSState->DLSSFeature->Feature,
+			InDLSSState->DLSSFeature->Parameter,
+			&DlssRREvalParams
+		);
+		checkf(NVSDK_NGX_SUCCEED(ResultEvaluate), TEXT("NGX_D3D11_EVALUATE_DLSSD_EXT failed! (%u %s), %s"), ResultEvaluate, GetNGXResultAsString(ResultEvaluate), *InDLSSState->DLSSFeature->Desc.GetDebugDescription());
+	}
+	else
+	{
+		NVSDK_NGX_D3D11_DLSS_Eval_Params DlssEvalParams = GetCommonEvalParams<NVSDK_NGX_D3D11_DLSS_Eval_Params>(D3D11RHI, InArguments);
+
+		DlssEvalParams.Feature.pInOutput = D3D11RHI->RHIGetResource(InArguments.OutputColor);
+		DlssEvalParams.Feature.pInColor = D3D11RHI->RHIGetResource(InArguments.InputColor);
+		DlssEvalParams.Feature.InSharpness = InArguments.Sharpness;
+
+		NVSDK_NGX_Result ResultEvaluate = NGX_D3D11_EVALUATE_DLSS_EXT(
+			Direct3DDeviceIMContext,
+			InDLSSState->DLSSFeature->Feature,
+			InDLSSState->DLSSFeature->Parameter,
+			&DlssEvalParams
+		);
+		checkf(NVSDK_NGX_SUCCEED(ResultEvaluate), TEXT("NGX_D3D11_EVALUATE_DLSS_EXT failed! (%u %s), %s"), ResultEvaluate, GetNGXResultAsString(ResultEvaluate), *InDLSSState->DLSSFeature->Desc.GetDebugDescription());
+	}
+
+	InDLSSState->DLSSFeature->Tick(FrameCounter);
+}
+
+/** IModuleInterface implementation */
+
+void FNGXD3D11RHIModule::StartupModule()
+{
+	// NGXRHI module should be loaded to ensure logging state is initialized
+	FModuleManager::LoadModuleChecked<INGXRHIModule>(TEXT("NGXRHI"));
+}
+
+void FNGXD3D11RHIModule::ShutdownModule()
+{
+}
+
+TUniquePtr<NGXRHI> FNGXD3D11RHIModule::CreateNGXRHI(const FNGXRHICreateArguments& Arguments)
+{
+	TUniquePtr<NGXRHI> Result(new FNGXD3D11RHI(Arguments));
+	return Result;
+}
+
+IMPLEMENT_MODULE(FNGXD3D11RHIModule, NGXD3D11RHI)
+
+#undef LOCTEXT_NAMESPACE
+
+

Plugins/Marketplace/DLSS/Source/NGXD3D11RHI/Public/NGXD3D11RHI.h

@@ -0,0 +1,27 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+#include "Modules/ModuleManager.h"
+
+#include "NGXRHI.h"
+
+class FNGXD3D11RHIModule final : public INGXRHIModule
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule();
+	virtual void ShutdownModule();
+
+	/** INGXRHIModule implementation */
+	virtual TUniquePtr<NGXRHI> CreateNGXRHI(const FNGXRHICreateArguments& Arguments);
+};

Plugins/Marketplace/DLSS/Source/NGXD3D12RHI/NGXD3D12RHI.Build.cs

@@ -0,0 +1,72 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+using System.IO;
+public class NGXD3D12RHI : ModuleRules
+{
+	public NGXD3D12RHI(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+
+		PrivateIncludePaths.AddRange(
+		new string[] {
+		}
+		);
+
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Core",
+					"Engine",
+					"RenderCore",
+					"RHI",
+					"D3D12RHI",
+				
+					"NGX",
+					"NGXRHI",
+			}
+			);
+
+		if (ReadOnlyBuildVersion.Current.MajorVersion == 5 && ReadOnlyBuildVersion.Current.MinorVersion >= 1)
+		{
+			PrivateDefinitions.Add("ENGINE_PROVIDES_ID3D12DYNAMICRHI=1");
+
+			if (ReadOnlyBuildVersion.Current.MajorVersion == 5 && ReadOnlyBuildVersion.Current.MinorVersion >= 5)
+			{
+				PrivateDefinitions.Add("ENGINE_ID3D12DYNAMICRHI_NEEDS_CMDLIST=1");
+			}
+			else
+			{
+				PrivateDefinitions.Add("ENGINE_ID3D12DYNAMICRHI_NEEDS_CMDLIST=0");
+			}
+		}
+		else
+		{
+			PrivateDefinitions.Add("ENGINE_PROVIDES_ID3D12DYNAMICRHI=0");
+			PrivateIncludePaths.Add(Path.Combine(EngineDirectory, "Source/Runtime/D3D12RHI/Private"));
+		}
+		// those come from the D3D12RHI
+		AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
+	}
+}

Plugins/Marketplace/DLSS/Source/NGXD3D12RHI/Private/NGXD3D12RHI.cpp

@@ -0,0 +1,430 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "NGXD3D12RHI.h"
+
+#include "nvsdk_ngx.h"
+#include "nvsdk_ngx_helpers.h"
+#include "nvsdk_ngx_helpers_dlssd.h"
+
+#include "ID3D12DynamicRHI.h"
+#include "GenericPlatform/GenericPlatformFile.h"
+
+
+
+DEFINE_LOG_CATEGORY_STATIC(LogDLSSNGXD3D12RHI, Log, All);
+
+#define LOCTEXT_NAMESPACE "FNGXD3D12RHIModule"
+
+#if ENGINE_PROVIDES_ID3D12DYNAMICRHI && ENGINE_ID3D12DYNAMICRHI_NEEDS_CMDLIST
+#define RHICMDLIST_ARG_PASSTHROUGH CmdList,
+#else
+#define RHICMDLIST_ARG_PASSTHROUGH 
+#endif
+
+
+class FD3D12NGXDLSSFeature final : public NGXDLSSFeature
+{
+
+public:
+	using NGXDLSSFeature::NGXDLSSFeature;
+
+	virtual ~FD3D12NGXDLSSFeature()
+	{
+		check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+		check(NGXRHI::NGXInitialized());
+		NVSDK_NGX_Result ResultReleaseFeature = NVSDK_NGX_D3D12_ReleaseFeature(Feature);
+		checkf(NVSDK_NGX_SUCCEED(ResultReleaseFeature), TEXT("NVSDK_NGX_D3D12_ReleaseFeature failed! (%u %s), %s"), ResultReleaseFeature, GetNGXResultAsString(ResultReleaseFeature), *Desc.GetDebugDescription());
+
+		if (Parameter != nullptr)
+		{
+			NVSDK_NGX_Result ResultDestroyParameter = NVSDK_NGX_D3D12_DestroyParameters(Parameter);
+			checkf(NVSDK_NGX_SUCCEED(ResultDestroyParameter), TEXT("NVSDK_NGX_D3D12_DestroyParameters failed! (%u %s), %s"), ResultDestroyParameter, GetNGXResultAsString(ResultDestroyParameter), *Desc.GetDebugDescription());
+		}
+	}
+};
+
+class FNGXD3D12RHI final : public NGXRHI
+{
+
+public:
+	FNGXD3D12RHI(const FNGXRHICreateArguments& Arguments);
+	virtual void ExecuteDLSS(FRHICommandList& CmdList, const FRHIDLSSArguments& InArguments, FDLSSStateRef InDLSSState) final;
+	virtual ~FNGXD3D12RHI();
+	virtual bool IsRRSupportedByRHI() const override { return true; }
+private:
+	NVSDK_NGX_Result Init_NGX_D3D12(const FNGXRHICreateArguments& InArguments, const wchar_t* InApplicationDataPath, ID3D12Device* InHandle, const NVSDK_NGX_FeatureCommonInfo* InFeatureInfo);
+	static bool IsIncompatibleAPICaptureToolActive(ID3D12Device* InDirect3DDevice);
+
+	ID3D12DynamicRHI* D3D12RHI = nullptr;
+
+};
+
+bool FNGXD3D12RHI::IsIncompatibleAPICaptureToolActive(ID3D12Device* InDirect3DDevice)
+{
+	// RenderDoc
+	{
+		IID RenderDocID;
+		if (SUCCEEDED(IIDFromString(L"{A7AA6116-9C8D-4BBA-9083-B4D816B71B78}", &RenderDocID)))
+		{
+			TRefCountPtr<IUnknown> RenderDoc;
+			if (SUCCEEDED(InDirect3DDevice->QueryInterface(RenderDocID, (void**)RenderDoc.GetInitReference())))
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+NVSDK_NGX_Result FNGXD3D12RHI::Init_NGX_D3D12(const FNGXRHICreateArguments& InArguments, const wchar_t* InApplicationDataPath, ID3D12Device* InHandle, const NVSDK_NGX_FeatureCommonInfo* InFeatureInfo)
+{
+	NVSDK_NGX_Result Result = NVSDK_NGX_Result_Fail;
+	int32 APIVersion = NVSDK_NGX_VERSION_API_MACRO;
+	do 
+	{
+		if (InArguments.InitializeNGXWithNGXApplicationID())
+		{
+			Result = NVSDK_NGX_D3D12_Init(InArguments.NGXAppId, InApplicationDataPath, InHandle, InFeatureInfo, static_cast<NVSDK_NGX_Version>(APIVersion));
+			UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("NVSDK_NGX_D3D12_Init(AppID= %u, APIVersion = 0x%x, Device=%p) -> (%u %s)"), InArguments.NGXAppId, APIVersion, InHandle, Result, GetNGXResultAsString(Result));
+		}
+		else
+		{
+			Result = NVSDK_NGX_D3D12_Init_with_ProjectID(TCHAR_TO_UTF8(*InArguments.UnrealProjectID), NVSDK_NGX_ENGINE_TYPE_UNREAL, TCHAR_TO_UTF8(*InArguments.UnrealEngineVersion), InApplicationDataPath, InHandle, InFeatureInfo, static_cast<NVSDK_NGX_Version>(APIVersion));
+			UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("NVSDK_NGX_D3D12_Init_with_ProjectID(ProjectID = %s, EngineVersion=%s, APIVersion = 0x%x, Device=%p) -> (%u %s)"), *InArguments.UnrealProjectID, *InArguments.UnrealEngineVersion, APIVersion, InHandle,  Result, GetNGXResultAsString(Result));
+		}
+
+		if (NVSDK_NGX_FAILED(Result) && IsSafeToShutdownNGX())
+		{
+			NVSDK_NGX_D3D12_Shutdown1(InHandle);
+		}
+		
+		--APIVersion;
+	} while (NVSDK_NGX_FAILED(Result) && APIVersion >= NVSDK_NGX_VERSION_API_MACRO_BASE_LINE);
+
+	if (NVSDK_NGX_SUCCEED(Result) && (APIVersion + 1 < NVSDK_NGX_VERSION_API_MACRO_WITH_LOGGING))
+	{
+		UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("Warning: NVSDK_NGX_D3D12_Init succeeded, but the driver installed on this system is too old the support the NGX logging API. The console variables r.NGX.LogLevel and r.NGX.EnableOtherLoggingSinks will have no effect and NGX logs will only show up in their own log files, and not in UE's log files."));
+	}
+
+	return Result;
+}
+
+
+
+FNGXD3D12RHI::FNGXD3D12RHI(const FNGXRHICreateArguments& Arguments)
+	: NGXRHI(Arguments)
+	, D3D12RHI(CastDynamicRHI<ID3D12DynamicRHI>(Arguments.DynamicRHI))
+
+{
+	// TODO: adapter index
+	ID3D12Device* Direct3DDevice = D3D12RHI->RHIGetDevice(0);
+
+	ensure(D3D12RHI);
+	ensure(Direct3DDevice);
+	bIsIncompatibleAPICaptureToolActive = IsIncompatibleAPICaptureToolActive(Direct3DDevice);
+
+	const FString NGXLogDir = GetNGXLogDirectory();
+	IPlatformFile::GetPlatformPhysical().CreateDirectoryTree(*NGXLogDir);
+
+	NVSDK_NGX_Result ResultInit = Init_NGX_D3D12(Arguments, *NGXLogDir, Direct3DDevice, CommonFeatureInfo());
+	UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("NVSDK_NGX_D3D12_Init (Log %s) -> (%u %s)"), *NGXLogDir, ResultInit, GetNGXResultAsString(ResultInit));
+	
+	// store for the higher level code interpret
+	NGXQueryFeature.NGXInitResult = ResultInit;
+
+	if (NVSDK_NGX_Result_FAIL_OutOfDate == ResultInit)
+	{
+		NGXQueryFeature.NGXDriverRequirements.DriverUpdateRequired = true;
+	}
+	else if (NVSDK_NGX_SUCCEED(ResultInit))
+	{
+		bNGXInitialized = true;
+
+		NVSDK_NGX_Result ResultGetParameters = NVSDK_NGX_D3D12_GetCapabilityParameters(&NGXQueryFeature.CapabilityParameters);
+
+		UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("NVSDK_NGX_D3D12_GetCapabilityParameters -> (%u %s)"), ResultGetParameters, GetNGXResultAsString(ResultGetParameters));
+
+		if (NVSDK_NGX_Result_FAIL_OutOfDate == ResultGetParameters)
+		{
+			NGXQueryFeature.NGXDriverRequirements.DriverUpdateRequired = true;
+		}
+
+		if (NVSDK_NGX_SUCCEED(ResultGetParameters))
+		{
+			NGXQueryFeature.QueryDLSSSupport();
+		}
+	}
+}
+
+FNGXD3D12RHI::~FNGXD3D12RHI()
+{
+	UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	if (bNGXInitialized)
+	{
+		// Destroy the parameters and features before we call NVSDK_NGX_D3D12_Shutdown1
+		ReleaseAllocatedFeatures();
+		
+		NVSDK_NGX_Result Result;
+		if (NGXQueryFeature.CapabilityParameters != nullptr)
+		{
+			Result = NVSDK_NGX_D3D12_DestroyParameters(NGXQueryFeature.CapabilityParameters);
+			UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("NVSDK_NGX_D3D12_DestroyParameters -> (%u %s)"), Result, GetNGXResultAsString(Result));
+		}
+		if (IsSafeToShutdownNGX())
+		{
+			// TODO: adapter index
+			ID3D12Device* Direct3DDevice = D3D12RHI->RHIGetDevice(0);
+			Result = NVSDK_NGX_D3D12_Shutdown1(Direct3DDevice);
+			UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("NVSDK_NGX_D3D12_Shutdown1 -> (%u %s)"), Result, GetNGXResultAsString(Result));
+		}
+		bNGXInitialized = false;
+	}
+	UE_LOG(LogDLSSNGXD3D12RHI, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+template <typename T>
+static T GetCommonEvalParams(ID3D12DynamicRHI* D3D12RHI, const FRHIDLSSArguments& InArguments)
+{
+	T EvalParams;
+	FMemory::Memzero(EvalParams);
+
+	EvalParams.InOutputSubrectBase.X = InArguments.DestRect.Min.X;
+	EvalParams.InOutputSubrectBase.Y = InArguments.DestRect.Min.Y;
+
+	EvalParams.InRenderSubrectDimensions.Width = InArguments.SrcRect.Width();
+	EvalParams.InRenderSubrectDimensions.Height = InArguments.SrcRect.Height();
+
+	EvalParams.InColorSubrectBase.X = InArguments.SrcRect.Min.X;
+	EvalParams.InColorSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+	EvalParams.pInDepth = D3D12RHI->RHIGetResource(InArguments.InputDepth);
+	EvalParams.InDepthSubrectBase.X = InArguments.SrcRect.Min.X;
+	EvalParams.InDepthSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+	EvalParams.pInMotionVectors = D3D12RHI->RHIGetResource(InArguments.InputMotionVectors);
+	// The VelocityCombine pass puts the motion vectors into the top left corner
+	EvalParams.InMVSubrectBase.X = 0;
+	EvalParams.InMVSubrectBase.Y = 0;
+
+	EvalParams.pInExposureTexture = InArguments.bUseAutoExposure ? nullptr : D3D12RHI->RHIGetResource(InArguments.InputExposure);
+	EvalParams.InPreExposure = InArguments.PreExposure;
+
+	EvalParams.InJitterOffsetX = InArguments.JitterOffset.X;
+	EvalParams.InJitterOffsetY = InArguments.JitterOffset.Y;
+
+	EvalParams.InMVScaleX = InArguments.MotionVectorScale.X;
+	EvalParams.InMVScaleY = InArguments.MotionVectorScale.Y;
+	EvalParams.InReset = InArguments.bReset;
+
+	EvalParams.InFrameTimeDeltaInMsec = InArguments.DeltaTimeMS;
+
+	return EvalParams;
+}
+
+void FNGXD3D12RHI::ExecuteDLSS(FRHICommandList& CmdList, const FRHIDLSSArguments& InArguments, FDLSSStateRef InDLSSState)
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	check(IsDLSSAvailable());
+	if (!IsDLSSAvailable()) return;
+
+	InArguments.Validate();
+
+	const uint32 DeviceIndex = D3D12RHI->RHIGetResourceDeviceIndex(InArguments.InputColor);
+	ID3D12GraphicsCommandList* D3DGraphicsCommandList = D3D12RHI->RHIGetGraphicsCommandList(RHICMDLIST_ARG_PASSTHROUGH DeviceIndex);
+
+	if (InDLSSState->RequiresFeatureRecreation(InArguments))
+	{
+		check(!InDLSSState->DLSSFeature || InDLSSState->HasValidFeature());
+		InDLSSState->DLSSFeature = nullptr;
+	}
+
+	if (InArguments.bReset)
+	{
+		check(!InDLSSState->DLSSFeature);
+		InDLSSState->DLSSFeature = FindFreeFeature(InArguments);
+	}
+
+	if (!InDLSSState->DLSSFeature)
+	{
+		NVSDK_NGX_Parameter* NewNGXParameterHandle = nullptr;
+		NVSDK_NGX_Result Result = NVSDK_NGX_D3D12_AllocateParameters(&NewNGXParameterHandle);
+		checkf(NVSDK_NGX_SUCCEED(Result), TEXT("NVSDK_NGX_D3D12_AllocateParameters failed! (%u %s)"), Result, GetNGXResultAsString(Result));
+
+		ApplyCommonNGXParameterSettings(NewNGXParameterHandle, InArguments);
+
+		NVSDK_NGX_Handle* NewNGXFeatureHandle = nullptr;
+
+		const uint32 CreationNodeMask = 1 << InArguments.GPUNode;
+		const uint32 VisibilityNodeMask = InArguments.GPUVisibility;
+
+		if (InArguments.DenoiserMode == ENGXDLSSDenoiserMode::DLSSRR)
+		{
+			// DLSS-RR feature creation
+			NVSDK_NGX_DLSSD_Create_Params DlssRRCreateParams = InArguments.GetNGXDLSSRRCreateParams();
+			NVSDK_NGX_Result ResultCreate = NGX_D3D12_CREATE_DLSSD_EXT(
+				D3DGraphicsCommandList,
+				CreationNodeMask,
+				VisibilityNodeMask,
+				&NewNGXFeatureHandle,
+				NewNGXParameterHandle,
+				&DlssRRCreateParams
+			);
+			if (NVSDK_NGX_SUCCEED(ResultCreate))
+			{
+				InDLSSState->DLSSFeature = MakeShared<FD3D12NGXDLSSFeature>(NewNGXFeatureHandle, NewNGXParameterHandle, InArguments.GetFeatureDesc(), FrameCounter);
+				InDLSSState->DLSSFeature->bHasDLSSRR = true;
+			}
+			else
+			{
+				UE_LOG(LogDLSSNGXD3D12RHI, Error,
+					TEXT("NGX_D3D12_CREATE_DLSSD_EXT (CreationNodeMask=0x%x VisibilityNodeMask=0x%x) failed, falling back to DLSS-SR! (%u %s), %s"),
+					CreationNodeMask,
+					VisibilityNodeMask,
+					ResultCreate,
+					GetNGXResultAsString(ResultCreate),
+					*InArguments.GetFeatureDesc().GetDebugDescription());
+				InDLSSState->DLSSFeature.Reset();
+			}
+		}
+		if (!InDLSSState->DLSSFeature.IsValid())
+		{
+			// DLSS-SR feature creation
+			NVSDK_NGX_DLSS_Create_Params DlssCreateParams = InArguments.GetNGXDLSSCreateParams();
+			NVSDK_NGX_Result ResultCreate = NGX_D3D12_CREATE_DLSS_EXT(
+				D3DGraphicsCommandList,
+				CreationNodeMask,
+				VisibilityNodeMask,
+				&NewNGXFeatureHandle,
+				NewNGXParameterHandle,
+				&DlssCreateParams
+			);
+			checkf(NVSDK_NGX_SUCCEED(ResultCreate), TEXT("NGX_D3D12_CREATE_DLSS_EXT (CreationNodeMask=0x%x VisibilityNodeMask=0x%x) failed! (%u %s), %s"), CreationNodeMask, VisibilityNodeMask, ResultCreate, GetNGXResultAsString(ResultCreate), *InArguments.GetFeatureDesc().GetDebugDescription());
+			InDLSSState->DLSSFeature = MakeShared<FD3D12NGXDLSSFeature>(NewNGXFeatureHandle, NewNGXParameterHandle, InArguments.GetFeatureDesc(), FrameCounter);
+		}
+
+		RegisterFeature(InDLSSState->DLSSFeature);
+	}
+
+	check(InDLSSState->HasValidFeature());
+
+	// execute
+	//TODO: replaced with what in 5.1? will something be missing from gpu profiling? see commit 305e264e
+#if 0
+	if (Device->GetCommandContext().IsDefaultContext())
+	{
+		Device->RegisterGPUWork(1);
+	}
+#endif
+
+	if (!InDLSSState->DLSSFeature->bHasDLSSRR)
+	{
+		NVSDK_NGX_D3D12_DLSS_Eval_Params DlssEvalParams = GetCommonEvalParams<NVSDK_NGX_D3D12_DLSS_Eval_Params>(D3D12RHI, InArguments);
+
+		//TODO: does RHIGetResource do the right thing with multiple GPUs?
+		DlssEvalParams.Feature.pInOutput = D3D12RHI->RHIGetResource(InArguments.OutputColor);
+		DlssEvalParams.Feature.pInColor = D3D12RHI->RHIGetResource(InArguments.InputColor);
+		DlssEvalParams.Feature.InSharpness = InArguments.Sharpness;
+
+		
+		D3D12_RESOURCE_BARRIER BarrierDesc = {};
+		BarrierDesc.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
+		BarrierDesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
+		BarrierDesc.Transition.pResource = DlssEvalParams.Feature.pInOutput;
+		BarrierDesc.Transition.Subresource = 0;
+		BarrierDesc.Transition.StateBefore = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+		BarrierDesc.Transition.StateAfter = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+		D3DGraphicsCommandList->ResourceBarrier(1, &BarrierDesc);
+
+		NVSDK_NGX_Result ResultEvaluate = NGX_D3D12_EVALUATE_DLSS_EXT(
+			D3DGraphicsCommandList,
+			InDLSSState->DLSSFeature->Feature,
+			InDLSSState->DLSSFeature->Parameter,
+			&DlssEvalParams
+		);
+		checkf(NVSDK_NGX_SUCCEED(ResultEvaluate), TEXT("NGX_D3D12_EVALUATE_DLSS_EXT failed! (%u %s), %s"), ResultEvaluate, GetNGXResultAsString(ResultEvaluate), *InDLSSState->DLSSFeature->Desc.GetDebugDescription());
+
+		
+		BarrierDesc.Transition.StateBefore = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+		BarrierDesc.Transition.StateAfter = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+		D3DGraphicsCommandList->ResourceBarrier(1, &BarrierDesc);
+		
+	}
+	else
+	{
+		NVSDK_NGX_D3D12_DLSSD_Eval_Params DlssRREvalParams = GetCommonEvalParams<NVSDK_NGX_D3D12_DLSSD_Eval_Params>(D3D12RHI, InArguments);
+		DlssRREvalParams.pInOutput = D3D12RHI->RHIGetResource(InArguments.OutputColor);
+		DlssRREvalParams.pInColor = D3D12RHI->RHIGetResource(InArguments.InputColor);
+
+		// The GBufferResolve pass puts the albedos into the top left corner
+		DlssRREvalParams.pInDiffuseAlbedo = D3D12RHI->RHIGetResource(InArguments.InputDiffuseAlbedo);
+		DlssRREvalParams.InDiffuseAlbedoSubrectBase.X = 0;
+		DlssRREvalParams.InDiffuseAlbedoSubrectBase.Y = 0;
+
+		DlssRREvalParams.pInSpecularAlbedo = D3D12RHI->RHIGetResource(InArguments.InputSpecularAlbedo);
+		DlssRREvalParams.InSpecularAlbedoSubrectBase.X = 0;
+		DlssRREvalParams.InSpecularAlbedoSubrectBase.Y = 0;
+
+		DlssRREvalParams.pInNormals = D3D12RHI->RHIGetResource(InArguments.InputNormals);
+		DlssRREvalParams.pInRoughness = D3D12RHI->RHIGetResource(InArguments.InputRoughness);
+
+#if SUPPORT_GUIDE_GBUFFER
+		if (InArguments.InputReflectionHitDistance)
+		{
+			DlssRREvalParams.pInSpecularHitDistance = D3D12RHI->RHIGetResource(InArguments.InputReflectionHitDistance);
+			DlssRREvalParams.InSpecularHitDistanceSubrectBase.X = 0;
+			DlssRREvalParams.InSpecularHitDistanceSubrectBase.Y = 0;
+
+			// Yes, the interface takes a non-const ptr as an argument
+			DlssRREvalParams.pInWorldToViewMatrix = const_cast<float*>(InArguments.ViewMatrix);
+			DlssRREvalParams.pInViewToClipMatrix = const_cast<float*>(InArguments.ProjectionMatrix);
+		}
+#endif
+
+		NVSDK_NGX_Result ResultEvaluate = NGX_D3D12_EVALUATE_DLSSD_EXT(
+			D3DGraphicsCommandList,
+			InDLSSState->DLSSFeature->Feature,
+			InDLSSState->DLSSFeature->Parameter,
+			&DlssRREvalParams
+		);
+		checkf(NVSDK_NGX_SUCCEED(ResultEvaluate), TEXT("NGX_D3D12_EVALUATE_DLSSD_EXT failed! (%u %s), %s"), ResultEvaluate, GetNGXResultAsString(ResultEvaluate), *InDLSSState->DLSSFeature->Desc.GetDebugDescription());
+	}
+
+	InDLSSState->DLSSFeature->Tick(FrameCounter);
+
+	D3D12RHI->RHIFinishExternalComputeWork(RHICMDLIST_ARG_PASSTHROUGH DeviceIndex, D3DGraphicsCommandList);
+}
+
+/** IModuleInterface implementation */
+
+void FNGXD3D12RHIModule::StartupModule()
+{
+	// NGXRHI module should be loaded to ensure logging state is initialized
+	FModuleManager::LoadModuleChecked<INGXRHIModule>(TEXT("NGXRHI"));
+}
+
+void FNGXD3D12RHIModule::ShutdownModule()
+{
+}
+
+TUniquePtr<NGXRHI> FNGXD3D12RHIModule::CreateNGXRHI(const FNGXRHICreateArguments& Arguments)
+{
+	TUniquePtr<NGXRHI> Result(new FNGXD3D12RHI(Arguments));
+	return Result;
+}
+
+IMPLEMENT_MODULE(FNGXD3D12RHIModule, NGXD3D12RHI)
+
+#undef LOCTEXT_NAMESPACE
+
+
+
+

Plugins/Marketplace/DLSS/Source/NGXD3D12RHI/Public/NGXD3D12RHI.h

@@ -0,0 +1,28 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+#include "NGXRHI.h"
+
+class FNGXD3D12RHIModule final : public INGXRHIModule
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule();
+	virtual void ShutdownModule();
+
+	/** INGXRHIModule implementation */
+
+	virtual TUniquePtr<NGXRHI> CreateNGXRHI(const FNGXRHICreateArguments& Arguments);
+};

Plugins/Marketplace/DLSS/Source/NGXRHI/NGXRHI.Build.cs

@@ -0,0 +1,60 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+
+using UnrealBuildTool;
+using System.IO;
+public class NGXRHI : ModuleRules
+{
+	public NGXRHI(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+
+					"Core",
+					"Engine",
+					"Projects",
+					"RenderCore",
+					"RHI",
+
+					"NGX",
+			}
+			);
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+			}
+			);
+	}
+}

Plugins/Marketplace/DLSS/Source/NGXRHI/Private/NGXRHI.cpp

@@ -0,0 +1,672 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "NGXRHI.h"
+
+#include "Misc/Paths.h"
+#include "GenericPlatform/GenericPlatformFile.h"
+#include "Interfaces/IPluginManager.h"
+
+#include "nvsdk_ngx.h"
+#include "nvsdk_ngx_params.h"
+#include "nvsdk_ngx_helpers.h"
+
+// NGX software stack
+DEFINE_LOG_CATEGORY_STATIC(LogDLSSNGX, Log, All);
+// The UE module
+DEFINE_LOG_CATEGORY_STATIC(LogDLSSNGXRHI, Log, All);
+
+
+
+DECLARE_STATS_GROUP(TEXT("DLSS"), STATGROUP_DLSS, STATCAT_Advanced);
+DECLARE_MEMORY_STAT_POOL(TEXT("DLSS: Video memory"), STAT_DLSSInternalGPUMemory, STATGROUP_DLSS, FPlatformMemory::MCR_GPU);
+DECLARE_DWORD_COUNTER_STAT(TEXT("DLSS: Num DLSS features"), STAT_DLSSNumFeatures, STATGROUP_DLSS);
+
+#define LOCTEXT_NAMESPACE "NGXRHI"
+
+static TAutoConsoleVariable<int32> CVarNGXLogLevel(
+	TEXT("r.NGX.LogLevel"), 1,
+	TEXT("Determines the minimal amount of logging the NGX implementation pipes into LogDLSSNGX. Can be overridden by the -NGXLogLevel= command line option\n")
+	TEXT("Please refer to the DLSS plugin documentation on other ways to change the logging level.\n")
+	TEXT("0: off \n")
+	TEXT("1: on (default)\n")
+	TEXT("2: verbose "),
+	ECVF_ReadOnly);
+
+static TAutoConsoleVariable<int32> CVarNGXEnableOtherLoggingSinks(
+	TEXT("r.NGX.EnableOtherLoggingSinks"), 0,
+	TEXT("Determines whether the NGX implementation will write logs to files. Can also be set on the command line via -NGXLogFileEnable and -NGXLogFileDisable\n")
+	TEXT("0: off (default)\n")
+	TEXT("1: on \n"),
+	ECVF_ReadOnly);
+
+static TAutoConsoleVariable<int32> CVarNGXFramesUntilFeatureDestruction(
+	TEXT("r.NGX.FramesUntilFeatureDestruction"), 3,
+	TEXT("Number of frames until an unused NGX feature gets destroyed. (default=3)"),
+	ECVF_RenderThreadSafe);
+
+static TAutoConsoleVariable<int32> CVarNGXRenameLogSeverities(
+	TEXT("r.NGX.RenameNGXLogSeverities"), 1,
+	TEXT("Renames 'error' and 'warning' in messages returned by the NGX log callback to 'e_rror' and 'w_arning' before passing them to the UE log system\n")
+	TEXT("0: off \n")
+	TEXT("1: on, for select messages during initalization (default)\n")
+	TEXT("2: on, for all messages\n"),
+	ECVF_Default);
+
+void FRHIDLSSArguments::Validate() const
+{
+	check(InputColor);
+	check(InputDepth);
+	check(InputMotionVectors);
+	check(InputExposure);
+	check(OutputColor);
+}
+
+NGXDLSSFeature::~NGXDLSSFeature()
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Destroying NGX DLSS Feature %s "), *Desc.GetDebugDescription());
+}
+
+void NVSDK_CONV NGXLogSink(const char* InNGXMessage, NVSDK_NGX_Logging_Level InLoggingLevel, NVSDK_NGX_Feature InSourceComponent)
+{
+	FString Message(FString(UTF8_TO_TCHAR(InNGXMessage)).TrimEnd());
+	const TCHAR* NGXComponent = TEXT("Unknown");
+	
+	switch (InSourceComponent)
+	{
+		case NVSDK_NGX_Feature_SuperSampling: NGXComponent = TEXT("DLSS");	break;
+		case NVSDK_NGX_Feature_Reserved_SDK : NGXComponent = TEXT("SDK");	break;
+		case NVSDK_NGX_Feature_Reserved_Core: NGXComponent = TEXT("Core");	break;
+	}
+
+	const bool bIsVerboseStartupMessage =
+		(Message.Contains(TEXT(" doesn't exist in any of the search paths")) && !Message.Contains(TEXT("nvngx_dlss.dll"))) || // we want to know if the DLSS binary is missing
+		Message.Contains(TEXT("warning: UWP compliant mode enabled"));
+
+	
+
+	if ((CVarNGXRenameLogSeverities.GetValueOnAnyThread() == 2) || ((CVarNGXRenameLogSeverities.GetValueOnAnyThread() == 1) && bIsVerboseStartupMessage))
+	{
+		Message = Message.Replace(TEXT("error:"), TEXT("e_rror:"));
+		Message = Message.Replace(TEXT("Warning:"), TEXT("w_arning:"));
+		UE_LOG(LogDLSSNGX, Verbose, TEXT("[%s]: %s"), NGXComponent, *Message);
+	}
+	else
+	{
+		UE_LOG(LogDLSSNGX, Log, TEXT("[%s]: %s"), NGXComponent, *Message);
+	}
+
+}
+
+
+bool NGXRHI::bNGXInitialized = false;
+
+// the derived RHIs will set this to true during their initialization
+bool NGXRHI::bIsIncompatibleAPICaptureToolActive = false;
+
+static void RemoveDuplicateSlashesFromPath(FString& Path)
+{
+	if (Path.StartsWith(FString("//")))
+	{
+		// preserve the initial double slash to support network paths
+		FString NewString = FString("/");
+		NewString += FPaths::RemoveDuplicateSlashes(Path.RightChop(1));
+		Path = NewString;
+	}
+	else
+	{
+		FPaths::RemoveDuplicateSlashes(Path);
+	}
+}
+
+NGXRHI::NGXRHI(const FNGXRHICreateArguments& Arguments)
+	: DynamicRHI(Arguments.DynamicRHI)
+{
+	FString PluginNGXProductionBinariesDir  = FPaths::Combine(Arguments.PluginBaseDir, TEXT("Binaries/ThirdParty/Win64/"));
+	FString PluginNGXDevelopmentBinariesDir = FPaths::Combine(Arguments.PluginBaseDir, TEXT("Binaries/ThirdParty/Win64/Development/"));
+	FString PluginNGXBinariesDir = PluginNGXProductionBinariesDir;
+
+	// These paths can be different depending on the project type (source, no source) and how the project is packaged, thus we have both
+	FString ProjectNGXBinariesDir = FPaths::Combine(FPaths::ProjectDir(), TEXT("Binaries/ThirdParty/NVIDIA/NGX/Win64/"));
+	FString LaunchNGXBinariesDir  = FPaths::Combine(FPaths::LaunchDir(), TEXT("Binaries/ThirdParty/NVIDIA/NGX/Win64/"));
+
+	switch (Arguments.NGXBinariesSearchOrder)
+	{
+		default:
+		case ENGXBinariesSearchOrder::CustomThenGeneric:
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("Searching for custom and generic DLSS binaries"));
+			NGXDLLSearchPaths.Append({ ProjectNGXBinariesDir, LaunchNGXBinariesDir, PluginNGXProductionBinariesDir });
+			break;
+		}
+ 		case  ENGXBinariesSearchOrder::ForceGeneric:
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("Searching only for generic binaries from the plugin folder"));
+			NGXDLLSearchPaths.Append({ PluginNGXProductionBinariesDir });
+			break;
+		}
+		case ENGXBinariesSearchOrder::ForceCustom:
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("Searching only for custom DLSS binaries from the DLSS plugin"));
+			NGXDLLSearchPaths.Append({ ProjectNGXBinariesDir, LaunchNGXBinariesDir });
+			break;
+		}
+		case ENGXBinariesSearchOrder::ForceDevelopmentGeneric:
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("Searching only for generic development DLSS binaries from the DLSS plugin. This binary is only packaged for non-shipping build configurations"));
+			NGXDLLSearchPaths.Append({ PluginNGXDevelopmentBinariesDir });
+			PluginNGXBinariesDir = PluginNGXDevelopmentBinariesDir;
+			break;
+		}
+	}
+
+	for (int32 i = 0; i < NGXDLLSearchPaths.Num(); ++i)
+	{
+		NGXDLLSearchPaths[i] = FPaths::ConvertRelativePathToFull(NGXDLLSearchPaths[i]);
+		RemoveDuplicateSlashesFromPath(NGXDLLSearchPaths[i]);
+		FPaths::MakePlatformFilename(NGXDLLSearchPaths[i]);
+
+		// After this we should not touch NGXDLLSearchPaths since that provides the backing store for NGXDLLSearchPathRawStrings	
+		NGXDLLSearchPathRawStrings.Add(*NGXDLLSearchPaths[i]);
+		const bool bHasDLSSBinary = IPlatformFile::GetPlatformPhysical().FileExists(*FPaths::Combine(NGXDLLSearchPaths[i], NGX_DLSS_BINARY_NAME));
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS binary %s %s in search path %s"), NGX_DLSS_BINARY_NAME, bHasDLSSBinary ? TEXT("found") : TEXT("not found"), *NGXDLLSearchPaths[i]);
+	}
+
+	// we do this separately here so we can show relative paths in the UI later
+	DLSSGenericBinaryInfo.Get<0>() = FPaths::Combine(PluginNGXBinariesDir, NGX_DLSS_BINARY_NAME);
+	DLSSGenericBinaryInfo.Get<1>() = IPlatformFile::GetPlatformPhysical().FileExists(*DLSSGenericBinaryInfo.Get<0>());
+
+	DLSSCustomBinaryInfo.Get<0>() = FPaths::Combine(ProjectNGXBinariesDir, NGX_DLSS_BINARY_NAME);
+	DLSSCustomBinaryInfo.Get<1>() = IPlatformFile::GetPlatformPhysical().FileExists(*DLSSCustomBinaryInfo.Get<0>());
+
+	FeatureInfo.PathListInfo.Path = const_cast<wchar_t**>(NGXDLLSearchPathRawStrings.GetData());
+	FeatureInfo.PathListInfo.Length = NGXDLLSearchPathRawStrings.Num();
+
+	// logging
+	{
+		FeatureInfo.LoggingInfo.DisableOtherLoggingSinks = 1 != CVarNGXEnableOtherLoggingSinks.GetValueOnAnyThread();
+		FeatureInfo.LoggingInfo.LoggingCallback = &NGXLogSink;
+
+		switch (CVarNGXLogLevel.GetValueOnAnyThread())
+		{
+			case 0:
+				FeatureInfo.LoggingInfo.MinimumLoggingLevel = NVSDK_NGX_LOGGING_LEVEL_OFF;
+				break;
+			// should match the CVarNGXLogLevel default value
+			default:
+			case 1:
+				FeatureInfo.LoggingInfo.MinimumLoggingLevel = NVSDK_NGX_LOGGING_LEVEL_ON;
+				break;
+			case 2:
+				FeatureInfo.LoggingInfo.MinimumLoggingLevel = NVSDK_NGX_LOGGING_LEVEL_VERBOSE;
+				break;
+		}
+	}
+
+	// optional OTA update of DLSS model
+	if (Arguments.bAllowOTAUpdate)
+	{
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("DLSS model OTA update enabled"));
+		if (Arguments.InitializeNGXWithNGXApplicationID())
+		{
+			NVSDK_NGX_Application_Identifier NGXAppIdentifier;
+			NGXAppIdentifier.IdentifierType = NVSDK_NGX_Application_Identifier_Type::NVSDK_NGX_Application_Identifier_Type_Application_Id;
+			NGXAppIdentifier.v.ApplicationId = Arguments.NGXAppId;
+			NVSDK_NGX_UpdateFeature(&NGXAppIdentifier, NVSDK_NGX_Feature::NVSDK_NGX_Feature_SuperSampling);
+		}
+		else
+		{
+			FTCHARToUTF8 ProjectIdUTF8(*Arguments.UnrealProjectID);
+			FTCHARToUTF8 EngineVersionUTF8(*Arguments.UnrealEngineVersion);
+			NVSDK_NGX_Application_Identifier NGXAppIdentifier;
+			NGXAppIdentifier.IdentifierType = NVSDK_NGX_Application_Identifier_Type::NVSDK_NGX_Application_Identifier_Type_Project_Id;
+			NGXAppIdentifier.v.ProjectDesc.ProjectId = ProjectIdUTF8.Get();
+			NGXAppIdentifier.v.ProjectDesc.EngineType = NVSDK_NGX_EngineType::NVSDK_NGX_ENGINE_TYPE_UNREAL;
+			NGXAppIdentifier.v.ProjectDesc.EngineVersion = EngineVersionUTF8.Get();
+			NVSDK_NGX_UpdateFeature(&NGXAppIdentifier, NVSDK_NGX_Feature::NVSDK_NGX_Feature_SuperSampling);
+		}
+	}
+	else
+	{
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("DLSS model OTA update disabled"));
+	}
+}
+
+TTuple<FString, bool> NGXRHI::GetDLSSGenericBinaryInfo() const
+{
+	return DLSSGenericBinaryInfo;
+}
+
+TTuple<FString, bool> NGXRHI::GetDLSSCustomBinaryInfo() const
+{
+	return DLSSCustomBinaryInfo;
+}
+
+NGXRHI::~NGXRHI()
+{
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+
+void NGXRHI::FDLSSQueryFeature::QueryDLSSSupport()
+{
+	int32 bNeedsUpdatedDriverSR = 1;
+	int32 MinDriverVersionMajorSR = 0;
+	int32 MinDriverVersionMinorSR = 0;
+
+	int32 bNeedsUpdatedDriverDenoise = 1;
+	int32 MinDriverVersionMajorDenoise = 0;
+	int32 MinDriverVersionMinorDenoise = 0;
+
+	// Centralize this here instead during NGXRHI init. This should not happen but if we don't have a a valid CapabilityParameters, then we also don't have DLSS.
+	if (!CapabilityParameters)
+	{
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS cannot be loaded possibly due to issues initializing NGX."));
+		NGXInitResult = NVSDK_NGX_Result_Fail;
+		bIsDlssSRAvailable = false;
+		bIsDlssRRAvailable = false;
+		return;
+	}
+
+	check(CapabilityParameters);
+
+	NVSDK_NGX_Result ResultUpdatedDriver = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSampling_NeedsUpdatedDriver, &bNeedsUpdatedDriverSR);
+	NVSDK_NGX_Result ResultMinDriverVersionMajor = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSampling_MinDriverVersionMajor, &MinDriverVersionMajorSR);
+	NVSDK_NGX_Result ResultMinDriverVersionMinor = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSampling_MinDriverVersionMinor, &MinDriverVersionMinorSR);
+
+	NVSDK_NGX_Result ResultUpdatedDriverDenoise = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSamplingDenoising_NeedsUpdatedDriver, &bNeedsUpdatedDriverDenoise);
+	NVSDK_NGX_Result ResultMinDriverVersionMajorDenoise = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSamplingDenoising_MinDriverVersionMajor, &MinDriverVersionMajorDenoise);
+	NVSDK_NGX_Result ResultMinDriverVersionMinorDenoise = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSamplingDenoising_MinDriverVersionMinor, &MinDriverVersionMinorDenoise);
+
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSampling_NeedsUpdatedDriver -> (%u %s), bNeedsUpdatedDriver = %d"), ResultUpdatedDriver, GetNGXResultAsString(ResultUpdatedDriver), bNeedsUpdatedDriverSR);
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSampling_MinDriverVersionMajor -> (%u %s), MinDriverVersionMajor = %d"), ResultMinDriverVersionMajor, GetNGXResultAsString(ResultMinDriverVersionMajor), MinDriverVersionMajorSR);
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSampling_MinDriverVersionMinor -> (%u %s), MinDriverVersionMinor = %d"), ResultMinDriverVersionMinor, GetNGXResultAsString(ResultMinDriverVersionMinor), MinDriverVersionMinorSR);
+
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSamplingDenoising_NeedsUpdatedDriver -> (%u %s), bNeedsUpdatedDriver = %d"), ResultUpdatedDriverDenoise, GetNGXResultAsString(ResultUpdatedDriverDenoise), bNeedsUpdatedDriverDenoise);
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSamplingDenoising_MinDriverVersionMajor -> (%u %s), MinDriverVersionMajor = %d"), ResultMinDriverVersionMajorDenoise, GetNGXResultAsString(ResultMinDriverVersionMajorDenoise), MinDriverVersionMajorDenoise);
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSamplingDenoising_MinDriverVersionMinor -> (%u %s), MinDriverVersionMinor = %d"), ResultMinDriverVersionMinorDenoise, GetNGXResultAsString(ResultMinDriverVersionMinorDenoise), MinDriverVersionMinorDenoise);
+
+	if (NVSDK_NGX_SUCCEED(ResultUpdatedDriver))
+	{
+		NGXDLSSSRDriverRequirements.DriverUpdateRequired = bNeedsUpdatedDriverSR != 0;
+		
+		// ignore 0.0 and fall back to the what's baked into FNGXDriverRequirements;
+		if (NVSDK_NGX_SUCCEED(ResultMinDriverVersionMajor) && NVSDK_NGX_SUCCEED(ResultMinDriverVersionMinor) && MinDriverVersionMajorSR != 0)
+		{
+			NGXDLSSSRDriverRequirements.MinDriverVersionMajor = MinDriverVersionMajorSR;
+			NGXDLSSSRDriverRequirements.MinDriverVersionMinor = MinDriverVersionMinorSR;
+		}
+
+		if (bNeedsUpdatedDriverSR)
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS cannot be loaded due to an outdated driver. Minimum Driver Version required : %u.%u"), MinDriverVersionMajorSR, MinDriverVersionMinorSR);
+		}
+		else
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS is supported by the currently installed driver. Minimum driver version was reported as: %u.%u"), MinDriverVersionMajorSR, MinDriverVersionMinorSR);
+		}
+	}
+	else
+	{
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS Minimum driver version was not reported"));
+	}
+	// make up a default answer for DLSS-RR in case NGX doesn't provide one
+	NGXDLSSRRDriverRequirements.DriverUpdateRequired = true;
+	NGXDLSSRRDriverRequirements.MinDriverVersionMajor = 537;
+	NGXDLSSRRDriverRequirements.MinDriverVersionMinor = 2;
+	if (NVSDK_NGX_SUCCEED(ResultUpdatedDriverDenoise))
+	{
+		NGXDLSSRRDriverRequirements.DriverUpdateRequired = bNeedsUpdatedDriverDenoise != 0;
+
+		// ignore 0.0 and fall back to the what's baked into FNGXDriverRequirements;
+		if (NVSDK_NGX_SUCCEED(ResultMinDriverVersionMajorDenoise) && NVSDK_NGX_SUCCEED(ResultMinDriverVersionMinorDenoise) && MinDriverVersionMajorDenoise != 0)
+		{
+			NGXDLSSRRDriverRequirements.MinDriverVersionMajor = MinDriverVersionMajorDenoise;
+			NGXDLSSRRDriverRequirements.MinDriverVersionMinor = MinDriverVersionMinorDenoise;
+		}
+
+		if (bNeedsUpdatedDriverDenoise)
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS-RR cannot be loaded due to an outdated driver. Minimum Driver Version required : %u.%u"), MinDriverVersionMajorDenoise, MinDriverVersionMinorDenoise);
+		}
+		else
+		{
+			UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS-RR is supported by the currently installed driver. Minimum driver version was reported as: %u.%u"), MinDriverVersionMajorDenoise, MinDriverVersionMinorDenoise);
+		}
+	}
+	else
+	{
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("NVIDIA NGX DLSS-RR Minimum driver version was not reported, driver likely does not support DLSS-RR"));
+	}
+
+	// determine if DLSS-SR is available
+	int DlssSRAvailable = 0;
+	NVSDK_NGX_Result ResultAvailable = CapabilityParameters->Get(NVSDK_NGX_EParameter_SuperSampling_Available, &DlssSRAvailable);
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_EParameter_SuperSampling_Available -> (%u %s), DlssAvailable = %d"), ResultAvailable, GetNGXResultAsString(ResultAvailable), DlssSRAvailable);
+	if (NVSDK_NGX_SUCCEED(ResultAvailable) && DlssSRAvailable)
+	{
+		bIsDlssSRAvailable = true;
+
+		// store for the higher level code to interpret
+		NGXDLSSSRInitResult = ResultAvailable;
+	}
+
+	// determine if DLSS-RR is available
+	int DlssRRAvailable = 0;
+	ResultAvailable = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSamplingDenoising_Available, &DlssRRAvailable);
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSamplingDenoising_Available -> (%u %s), DlssRRAvailable = %d"), ResultAvailable, GetNGXResultAsString(ResultAvailable), DlssRRAvailable);
+	if (NVSDK_NGX_SUCCEED(ResultAvailable) && DlssRRAvailable)
+	{
+		// DLSS-RR requires DLSS-SR
+		bIsDlssRRAvailable = bIsDlssSRAvailable;
+
+		// store for the higher level code to interpret
+		NGXDLSSRRInitResult = ResultAvailable;
+	}
+
+
+	if (!bIsDlssSRAvailable)
+	{
+		// and try to find out more details on why it might have failed
+		NVSDK_NGX_Result DlssFeatureInitResult = NVSDK_NGX_Result_Fail;
+		NVSDK_NGX_Result ResultDlssFeatureInitResult = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSampling_FeatureInitResult, (int*)&DlssFeatureInitResult);
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSampling_FeatureInitResult -> (%u %s), NVSDK_NGX_Parameter_SuperSampling_FeatureInitResult = (%u %s)"), ResultDlssFeatureInitResult, GetNGXResultAsString(ResultDlssFeatureInitResult), DlssFeatureInitResult, GetNGXResultAsString(DlssFeatureInitResult));
+
+		// store for the higher level code to interpret
+		NGXDLSSSRInitResult = NVSDK_NGX_SUCCEED(ResultDlssFeatureInitResult) ? DlssFeatureInitResult : NVSDK_NGX_Result_Fail;
+	}
+	if (!bIsDlssRRAvailable)
+	{
+		NVSDK_NGX_Result DlssRRFeatureInitResult = NVSDK_NGX_Result_Fail;
+		NVSDK_NGX_Result ResultDlssRRFeatureInitResult = CapabilityParameters->Get(NVSDK_NGX_Parameter_SuperSamplingDenoising_FeatureInitResult, (int*)&DlssRRFeatureInitResult);
+		UE_LOG(LogDLSSNGXRHI, Log, TEXT("Get NVSDK_NGX_Parameter_SuperSamplingDenoising_FeatureInitResult -> (%u %s), NVSDK_NGX_Parameter_SuperSamplingDenoising_FeatureInitResult = (%u %s)"), ResultDlssRRFeatureInitResult, GetNGXResultAsString(ResultDlssRRFeatureInitResult), DlssRRFeatureInitResult, GetNGXResultAsString(DlssRRFeatureInitResult));
+
+		// store for the higher level code to interpret
+		NGXDLSSRRInitResult = NVSDK_NGX_SUCCEED(ResultDlssRRFeatureInitResult) ? DlssRRFeatureInitResult : NVSDK_NGX_Result_Fail;
+	}
+}
+
+FDLSSOptimalSettings NGXRHI::FDLSSQueryFeature::GetDLSSOptimalSettings(const FDLSSResolutionParameters& InResolution) const
+{
+	check(CapabilityParameters);
+
+	FDLSSOptimalSettings OptimalSettings;
+
+	const NVSDK_NGX_Result ResultGetOptimalSettings = NGX_DLSS_GET_OPTIMAL_SETTINGS(
+		CapabilityParameters,
+		InResolution.Width,
+		InResolution.Height,
+		InResolution.PerfQuality,
+		reinterpret_cast<unsigned int*>(&OptimalSettings.RenderSize.X),
+		reinterpret_cast<unsigned int*>(&OptimalSettings.RenderSize.Y),
+		reinterpret_cast<unsigned int*>(&OptimalSettings.RenderSizeMax.X),
+		reinterpret_cast<unsigned int*>(&OptimalSettings.RenderSizeMax.Y),
+		reinterpret_cast<unsigned int*>(&OptimalSettings.RenderSizeMin.X),
+		reinterpret_cast<unsigned int*>(&OptimalSettings.RenderSizeMin.Y),
+		&OptimalSettings.Sharpness
+		);
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("NGX_DLSS_GET_OPTIMAL_SETTINGS -> (%u %s)"), ResultGetOptimalSettings, GetNGXResultAsString(ResultGetOptimalSettings));
+	checkf(NVSDK_NGX_SUCCEED(ResultGetOptimalSettings), TEXT("failed to query supported DLSS modes"));
+
+	OptimalSettings.bIsSupported = (OptimalSettings.RenderSize.X > 0) && (OptimalSettings.RenderSize.Y > 0);
+	auto ComputeResolutionFraction = [&InResolution](int32 RenderSizeX, int32 RenderSizeY)
+	{
+		float XScale = float(RenderSizeX) / float(InResolution.Width);
+		float YScale = float(RenderSizeY) / float(InResolution.Height);
+		return FMath::Min(XScale, YScale);
+	};
+
+
+	OptimalSettings.MinResolutionFraction = ComputeResolutionFraction(OptimalSettings.RenderSizeMin.X, OptimalSettings.RenderSizeMin.Y);
+	OptimalSettings.MaxResolutionFraction = ComputeResolutionFraction(OptimalSettings.RenderSizeMax.X, OptimalSettings.RenderSizeMax.Y);
+	
+	// restrict to range since floating point numbers are gonna floating point
+	OptimalSettings.OptimalResolutionFraction = FMath::Clamp<float>(ComputeResolutionFraction(OptimalSettings.RenderSize.X, OptimalSettings.RenderSize.Y), OptimalSettings.MinResolutionFraction, OptimalSettings.MaxResolutionFraction);
+
+
+	return OptimalSettings;
+}
+
+FString NGXRHI::GetNGXLogDirectory()
+{
+	// encode the time and instance id to handle cases like PIE standalone game where multiple processe are running at the same time.
+	FString AbsoluteProjectLogDir = FPaths::ConvertRelativePathToFull(FPaths::ProjectLogDir());
+	FString NGXLogDir = FPaths::Combine(AbsoluteProjectLogDir, TEXT("NGX"), FString::Printf(TEXT("NGX_%s_%s"), *FDateTime::Now().ToString(), *FApp::GetInstanceId().ToString()));
+	return NGXLogDir;
+}
+
+bool NGXRHI::IsSafeToShutdownNGX() const
+{
+	// Streamline plugin also uses NGX so it's not safe for us to call NGX shutdown functions from this plugin when Streamline is enabled
+	TSharedPtr<IPlugin> StreamlinePlugin = IPluginManager::Get().FindPlugin(TEXT("Streamline"));
+	return !StreamlinePlugin.IsValid() || !StreamlinePlugin->IsEnabled();
+}
+
+uint32 FRHIDLSSArguments::GetNGXCommonDLSSFeatureFlags() const
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	uint32 DLSSFeatureFlags = NVSDK_NGX_DLSS_Feature_Flags_None;
+	DLSSFeatureFlags |= NVSDK_NGX_DLSS_Feature_Flags_IsHDR;
+	if (DenoiserMode == ENGXDLSSDenoiserMode::Off)
+		DLSSFeatureFlags |= bool(ERHIZBuffer::IsInverted) ? NVSDK_NGX_DLSS_Feature_Flags_DepthInverted : 0;
+	DLSSFeatureFlags |= !bHighResolutionMotionVectors ? NVSDK_NGX_DLSS_Feature_Flags_MVLowRes : 0;
+	DLSSFeatureFlags |= Sharpness != 0.0f ? NVSDK_NGX_DLSS_Feature_Flags_DoSharpening : 0;
+	DLSSFeatureFlags |= bUseAutoExposure ? NVSDK_NGX_DLSS_Feature_Flags_AutoExposure : 0;
+	DLSSFeatureFlags |= bEnableAlphaUpscaling ? NVSDK_NGX_DLSS_Feature_Flags_AlphaUpscaling : 0;
+	return DLSSFeatureFlags;
+}
+
+NVSDK_NGX_DLSS_Create_Params FRHIDLSSArguments::GetNGXDLSSCreateParams() const
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	NVSDK_NGX_DLSS_Create_Params Result;
+	FMemory::Memzero(Result);
+	Result.Feature.InWidth = SrcRect.Width();
+	Result.Feature.InHeight = SrcRect.Height();
+	Result.Feature.InTargetWidth = DestRect.Width();
+	Result.Feature.InTargetHeight = DestRect.Height();
+	Result.Feature.InPerfQualityValue = static_cast<NVSDK_NGX_PerfQuality_Value>(PerfQuality);
+	check((Result.Feature.InPerfQualityValue >= NVSDK_NGX_PerfQuality_Value_MaxPerf) && (Result.Feature.InPerfQualityValue <= NVSDK_NGX_PerfQuality_Value_DLAA));
+
+	Result.InFeatureCreateFlags = GetNGXCommonDLSSFeatureFlags();
+	Result.InEnableOutputSubrects = OutputColor->GetTexture2D()->GetSizeXY() != DestRect.Size();
+	return Result;
+}
+
+NVSDK_NGX_DLSSD_Create_Params FRHIDLSSArguments::GetNGXDLSSRRCreateParams() const
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	NVSDK_NGX_DLSSD_Create_Params Result;
+	FMemory::Memzero(Result);
+	Result.InWidth = SrcRect.Width();
+	Result.InHeight = SrcRect.Height();
+	Result.InTargetWidth = DestRect.Width();
+	Result.InTargetHeight = DestRect.Height();
+	Result.InPerfQualityValue = static_cast<NVSDK_NGX_PerfQuality_Value>(PerfQuality);
+	check((Result.InPerfQualityValue >= NVSDK_NGX_PerfQuality_Value_MaxPerf) && (Result.InPerfQualityValue <= NVSDK_NGX_PerfQuality_Value_DLAA));
+	Result.InFeatureCreateFlags = GetNGXCommonDLSSFeatureFlags();
+	Result.InEnableOutputSubrects = OutputColor->GetTexture2D()->GetSizeXY() != DestRect.Size();
+	// Note: we clamp here the higher level enum (which has support for experimental) to on/off which is what NGX supports at this point in time
+	Result.InDenoiseMode = NVSDK_NGX_DLSS_Denoise_Mode_DLUnified;
+
+	return Result;
+}
+
+// this is used by the RHIs to see whether they need to recreate the NGX feature
+bool FDLSSState::RequiresFeatureRecreation(const FRHIDLSSArguments& InArguments)
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	float NewUpscaleRatio = static_cast<float>(InArguments.SrcRect.Width()) / static_cast<float>(InArguments.DestRect.Width());
+	if (!DLSSFeature || DLSSFeature->Desc != InArguments.GetFeatureDesc())
+	{
+		return true;
+	}
+
+	
+	return false;
+}
+
+void NGXRHI::RegisterFeature(TSharedPtr<NGXDLSSFeature> InFeature)
+{ 
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("Creating   NGX DLSS Feature  %s "), *InFeature->Desc.GetDebugDescription());
+	AllocatedDLSSFeatures.Add(InFeature);
+}
+
+TSharedPtr<NGXDLSSFeature> NGXRHI::FindFreeFeature(const FRHIDLSSArguments& InArguments)
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	TSharedPtr<NGXDLSSFeature> OutFeature;
+	for (int FeatureIndex = 0; FeatureIndex < AllocatedDLSSFeatures.Num(); ++FeatureIndex)
+	{
+		// another view already uses this (1 reference from AllocatedDLSSFeatures, another refernces held by FDLSState
+		if (AllocatedDLSSFeatures[FeatureIndex].GetSharedReferenceCount() > 1)
+		{
+			continue;
+		}
+
+		if (AllocatedDLSSFeatures[FeatureIndex]->Desc == InArguments.GetFeatureDesc())
+		{
+			OutFeature = AllocatedDLSSFeatures[FeatureIndex];
+			OutFeature->LastUsedFrame = FrameCounter;
+			break;
+
+		}
+	}
+	return OutFeature;
+}
+
+void NGXRHI::ReleaseAllocatedFeatures()
+{
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	
+	// There should be no FDLSSState::DLSSFeature anymore when we shut down
+	for (int FeatureIndex = 0; FeatureIndex < AllocatedDLSSFeatures.Num(); ++FeatureIndex)
+	{
+		checkf(AllocatedDLSSFeatures[FeatureIndex].GetSharedReferenceCount() == 1,TEXT("There should be no FDLSSState::DLSSFeature references elsewhere."));
+	}
+
+	AllocatedDLSSFeatures.Empty();
+	SET_DWORD_STAT(STAT_DLSSNumFeatures, AllocatedDLSSFeatures.Num());
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+void NGXRHI::ApplyCommonNGXParameterSettings(NVSDK_NGX_Parameter* InOutParameter, const FRHIDLSSArguments& InArguments)
+{
+	NVSDK_NGX_Parameter_SetI(InOutParameter, NVSDK_NGX_Parameter_FreeMemOnReleaseFeature, InArguments.bReleaseMemoryOnDelete ? 1 : 0);
+
+	// model selection
+	NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_DLAA, static_cast<uint32>(InArguments.DLSSPreset));
+	NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraQuality, static_cast<uint32>(InArguments.DLSSPreset));
+	NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Quality, static_cast<uint32>(InArguments.DLSSPreset));
+	NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Balanced, static_cast<uint32>(InArguments.DLSSPreset));
+	NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Performance, static_cast<uint32>(InArguments.DLSSPreset));
+	NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraPerformance, static_cast<uint32>(InArguments.DLSSPreset));
+
+	// if none of these static assertions fail, we can reuse the DLSS-SR preset values as the DLSS-RR preset values
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_Default == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_Default);
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_A == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_A);
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_B == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_B);
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_C == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_C);
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_D == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_D);
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_E == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_E);
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_F == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_F);
+	static_assert(NVSDK_NGX_RayReconstruction_Hint_Render_Preset::NVSDK_NGX_RayReconstruction_Hint_Render_Preset_G == NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_G);
+	if (NGXQueryFeature.bIsDlssRRAvailable)
+	{
+		NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_DLAA, static_cast<uint32>(InArguments.DLSSPreset));
+		NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_UltraQuality, static_cast<uint32>(InArguments.DLSSPreset));
+		NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_Quality, static_cast<uint32>(InArguments.DLSSPreset));
+		NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_Balanced, static_cast<uint32>(InArguments.DLSSPreset));
+		NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_Performance, static_cast<uint32>(InArguments.DLSSPreset));
+		NVSDK_NGX_Parameter_SetUI(InOutParameter, NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_UltraPerformance, static_cast<uint32>(InArguments.DLSSPreset));
+	}
+}
+
+void NGXRHI::TickPoolElements()
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	const uint32 kFramesUntilRelease = CVarNGXFramesUntilFeatureDestruction.GetValueOnAnyThread();
+
+	int32 FeatureIndex = 0;
+
+	while (FeatureIndex < AllocatedDLSSFeatures.Num())
+	{
+		TSharedPtr<NGXDLSSFeature>& Feature = AllocatedDLSSFeatures[FeatureIndex];
+
+		const bool bIsUnused = Feature.GetSharedReferenceCount() == 1;
+		const bool bNotRequestedRecently = (FrameCounter - Feature->LastUsedFrame) > kFramesUntilRelease;
+
+		if (bIsUnused && bNotRequestedRecently)
+		{
+			Swap(Feature, AllocatedDLSSFeatures.Last());
+			AllocatedDLSSFeatures.Pop();
+		}
+		else
+		{
+			++FeatureIndex;
+		}
+	}
+
+	SET_DWORD_STAT(STAT_DLSSNumFeatures, AllocatedDLSSFeatures.Num());
+	
+	if(NGXQueryFeature.CapabilityParameters)
+	{
+		unsigned long long VRAM = 0;
+
+		NVSDK_NGX_Result ResultGetStats = NGX_DLSS_GET_STATS(NGXQueryFeature.CapabilityParameters, &VRAM);
+
+		checkf(NVSDK_NGX_SUCCEED(ResultGetStats), TEXT("Failed to retrieve DLSS memory statistics via NGX_DLSS_GET_STATS -> (%u %s)"), ResultGetStats, GetNGXResultAsString(ResultGetStats));
+		if (NVSDK_NGX_SUCCEED(ResultGetStats))
+		{
+			SET_DWORD_STAT(STAT_DLSSInternalGPUMemory, VRAM);
+		}
+	}
+
+	++FrameCounter;
+}
+
+IMPLEMENT_MODULE(FNGXRHIModule, NGXRHI)
+
+#undef LOCTEXT_NAMESPACE
+
+/** IModuleInterface implementation */
+
+void FNGXRHIModule::StartupModule()
+{
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+
+	int32 NGXLogLevel = CVarNGXLogLevel.GetValueOnAnyThread();
+	if (FParse::Value(FCommandLine::Get(), TEXT("ngxloglevel="), NGXLogLevel))
+	{
+		CVarNGXLogLevel->Set(NGXLogLevel, ECVF_SetByCommandline);
+	}
+
+	if (FParse::Param(FCommandLine::Get(), TEXT("ngxlogfileenable")))
+	{
+		CVarNGXEnableOtherLoggingSinks->Set(1, ECVF_SetByCommandline);
+	}
+	else if (FParse::Param(FCommandLine::Get(), TEXT("ngxlogfiledisable")))
+	{
+		CVarNGXEnableOtherLoggingSinks->Set(0, ECVF_SetByCommandline);
+	}
+
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+void FNGXRHIModule::ShutdownModule()
+{
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	UE_LOG(LogDLSSNGXRHI, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+

Plugins/Marketplace/DLSS/Source/NGXRHI/Public/NGXRHI.h

@@ -0,0 +1,491 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+#include "CoreMinimal.h"
+#include "RendererInterface.h"
+
+#include "nvsdk_ngx_params.h"
+#include "nvsdk_ngx_helpers_dlssd.h"
+#include "SceneTexturesConfig.h"
+
+
+// That is set to 1 in NVRTX branches
+#ifndef SUPPORT_GUIDE_GBUFFER
+#define SUPPORT_GUIDE_GBUFFER 0
+#endif
+
+#define NVSDK_NGX_VERSION_API_MACRO_BASE_LINE (0x0000013)
+#define NVSDK_NGX_VERSION_API_MACRO_WITH_LOGGING (0x0000014)
+
+struct FDLSSState;
+
+enum class ENGXDLSSDenoiserMode
+{
+	Off = NVSDK_NGX_DLSS_Denoise_Mode_Off,
+	DLSSRR = NVSDK_NGX_DLSS_Denoise_Mode_DLUnified,
+	MaxValue = DLSSRR
+};
+
+struct FDLSSFeatureDesc
+{
+	bool operator != (const FDLSSFeatureDesc& Other) const
+	{
+		return DestRect.Size() != Other.DestRect.Size()
+			|| DLSSPreset != Other.DLSSPreset
+			|| PerfQuality != Other.PerfQuality
+			|| bHighResolutionMotionVectors != Other.bHighResolutionMotionVectors
+			|| bNonZeroSharpness != Other.bNonZeroSharpness
+			|| bUseAutoExposure != Other.bUseAutoExposure
+			|| bEnableAlphaUpscaling != Other.bEnableAlphaUpscaling
+			|| bReleaseMemoryOnDelete != Other.bReleaseMemoryOnDelete
+			|| GPUNode != Other.GPUNode
+			|| GPUVisibility != Other.GPUVisibility
+			|| DenoiserMode != Other.DenoiserMode;
+	}
+
+	bool operator == (const FDLSSFeatureDesc& Other) const
+	{
+		return !operator !=(Other);
+	}
+
+	FIntRect SrcRect = FIntRect(FIntPoint::NoneValue, FIntPoint::NoneValue);
+	FIntRect DestRect = FIntRect(FIntPoint::NoneValue, FIntPoint::NoneValue);
+	int32 DLSSPreset = -1;
+	int32 PerfQuality = -1;
+	bool bHighResolutionMotionVectors = false;
+	bool bNonZeroSharpness = false;
+	bool bUseAutoExposure = false;
+	bool bEnableAlphaUpscaling = false;
+	bool bReleaseMemoryOnDelete = false;
+	uint32 GPUNode = 0;
+	uint32 GPUVisibility = 0;
+	ENGXDLSSDenoiserMode DenoiserMode = ENGXDLSSDenoiserMode::Off;
+	FString GetDebugDescription() const
+	{
+		auto NGXDLSSPresetString = [] (int NGXPerfQuality)
+		{
+			switch (NGXPerfQuality)
+			{
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_Default:return TEXT("Default");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_A:return TEXT("Preset A");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_B:return TEXT("Preset B");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_C:return TEXT("Preset C");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_D:return TEXT("Preset D");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_E:return TEXT("Preset E");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_F:return TEXT("Preset F");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_G:return TEXT("Preset G");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_H_Reserved:return TEXT("Preset H");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_I_Reserved:return TEXT("Preset I");
+				case NVSDK_NGX_DLSS_Hint_Render_Preset_J:return TEXT("Preset J");
+				default:return TEXT("Invalid NVSDK_NGX_DLSS_Hint_Render_Preset");
+			}
+		};
+		auto NGXPerfQualityString = [] (int NGXPerfQuality)
+		{
+			switch (NGXPerfQuality)
+			{
+				case NVSDK_NGX_PerfQuality_Value_MaxPerf:return TEXT("MaxPerf");
+				case NVSDK_NGX_PerfQuality_Value_Balanced:return TEXT("Balanced");
+				case NVSDK_NGX_PerfQuality_Value_MaxQuality:return TEXT("MaxQuality");
+				case NVSDK_NGX_PerfQuality_Value_UltraPerformance:return TEXT("UltraPerformance");
+				case NVSDK_NGX_PerfQuality_Value_UltraQuality:return TEXT("UltraQuality");
+				case NVSDK_NGX_PerfQuality_Value_DLAA:return TEXT("DLAA");
+				default:return TEXT("Invalid NVSDK_NGX_PerfQuality_Value");
+			}
+		};
+		auto NGXDenoiserModeString = [](ENGXDLSSDenoiserMode NGXDenoiserMode)
+		{
+			switch (NGXDenoiserMode)
+			{
+			case ENGXDLSSDenoiserMode::Off: return TEXT("Off");
+			case ENGXDLSSDenoiserMode::DLSSRR: return TEXT("DLSSRR");
+			default:return TEXT("Invalid ENGXDLSSDenoiserMode");
+			}
+		};
+
+		return FString::Printf(TEXT("SrcRect=[%dx%d->%dx%d], DestRect=[%dx%d->%dx%d], ScaleX=%f, ScaleY=%f, NGXDLSSPreset=%s(%d), NGXPerfQuality=%s(%d), bHighResolutionMotionVectors=%d, bNonZeroSharpness=%d, bUseAutoExposure=%d, bEnableAlphaUpscaling=%d, bReleaseMemoryOnDelete=%d, GPUNode=%u, GPUVisibility=0x%x, DenoiseMode=%s"),
+			SrcRect.Min.X, SrcRect.Min.Y, SrcRect.Max.X, SrcRect.Max.Y,
+			DestRect.Min.X, DestRect.Min.Y, DestRect.Max.X, DestRect.Max.Y,
+			float(SrcRect.Width()) / float(DestRect.Width()),
+			float(SrcRect.Height()) / float(DestRect.Height()),
+			NGXDLSSPresetString(DLSSPreset), DLSSPreset,
+			NGXPerfQualityString(PerfQuality), PerfQuality,
+			bHighResolutionMotionVectors,
+			bNonZeroSharpness,
+			bUseAutoExposure,
+			bEnableAlphaUpscaling,
+			bReleaseMemoryOnDelete,
+			GPUNode,
+			GPUVisibility,
+			NGXDenoiserModeString(DenoiserMode));
+
+	}
+};
+
+struct NGXRHI_API FRHIDLSSArguments
+{
+	FRHITexture* InputColor = nullptr;
+	FRHITexture* InputDepth = nullptr;
+	FRHITexture* InputMotionVectors = nullptr;
+	FRHITexture* InputExposure = nullptr;
+	
+	FRHITexture* InputDiffuseAlbedo = nullptr;
+	FRHITexture* InputSpecularAlbedo = nullptr;
+
+	FRHITexture* InputNormals = nullptr;
+	FRHITexture* InputRoughness = nullptr;
+
+#if SUPPORT_GUIDE_GBUFFER
+	FRHITexture* InputReflectionHitDistance = nullptr;
+#endif
+
+	FRHITexture* OutputColor = nullptr;
+
+	FIntRect SrcRect = FIntRect(FIntPoint::ZeroValue, FIntPoint::ZeroValue);
+	FIntRect DestRect = FIntRect(FIntPoint::ZeroValue, FIntPoint::ZeroValue);
+	FVector2f JitterOffset = FVector2f::ZeroVector;
+	FVector2f MotionVectorScale = FVector2f::UnitVector;
+
+	FMatrix InvViewProjectionMatrix;
+	FMatrix ClipToPrevClipMatrix;
+#if SUPPORT_GUIDE_GBUFFER
+	float ViewMatrix[16];
+	float ProjectionMatrix[16];
+#endif
+	bool bHighResolutionMotionVectors = false;
+
+	float Sharpness = 0.0f;
+	bool bReset = false;
+
+	int32 DLSSPreset = NVSDK_NGX_DLSS_Hint_Render_Preset::NVSDK_NGX_DLSS_Hint_Render_Preset_Default;
+	int32 PerfQuality = 0;
+	float DeltaTimeMS = 0.0f;
+
+	float PreExposure = 1.0f;
+	bool bUseAutoExposure = false;
+
+	bool bEnableAlphaUpscaling = false;
+	
+	bool bReleaseMemoryOnDelete = false;
+	uint32 GPUNode = 0;
+	uint32 GPUVisibility = 0;
+
+	ENGXDLSSDenoiserMode DenoiserMode = ENGXDLSSDenoiserMode::Off;
+
+	void Validate() const;
+	
+	inline FDLSSFeatureDesc GetFeatureDesc() const
+	{
+		return FDLSSFeatureDesc 
+		{ 
+			SrcRect, DestRect, DLSSPreset, PerfQuality,
+			bHighResolutionMotionVectors, Sharpness != 0.0f, bUseAutoExposure, bEnableAlphaUpscaling,
+			bReleaseMemoryOnDelete, GPUNode, GPUVisibility, DenoiserMode
+		};
+	}
+
+	uint32 GetNGXCommonDLSSFeatureFlags() const;
+	NVSDK_NGX_DLSS_Create_Params  GetNGXDLSSCreateParams() const;
+	NVSDK_NGX_DLSSD_Create_Params GetNGXDLSSRRCreateParams() const;
+};
+
+struct FNGXDriverRequirements
+{
+	bool  DriverUpdateRequired = false;
+	int32 MinDriverVersionMajor = 470;
+	int32 MinDriverVersionMinor = 0;
+};
+
+// the API specic RHI extensions derive from this to handle the lifetime
+class NGXRHI_API NGXDLSSFeature
+{
+public:
+	virtual ~NGXDLSSFeature() = 0;
+
+	FDLSSFeatureDesc Desc;
+	NVSDK_NGX_Handle* Feature = nullptr;
+	NVSDK_NGX_Parameter* Parameter = nullptr;
+	uint32 LastUsedFrame = 0;
+	bool bHasDLSSRR = false;
+
+	void Tick(uint32 InFrameNumber)
+	{
+		check(Feature);
+		check(Parameter);
+		LastUsedFrame = InFrameNumber;
+	}
+
+	NGXDLSSFeature(NVSDK_NGX_Handle* InFeature, NVSDK_NGX_Parameter* InParameter, const FDLSSFeatureDesc& InFeatureDesc, uint32 InLastUsedEvaluation)
+		: Desc(InFeatureDesc)
+		, Feature(InFeature)
+		, Parameter(InParameter)
+		, LastUsedFrame(InLastUsedEvaluation)
+	{
+		check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+		check(Feature);
+		check(Parameter);
+	}
+	bool IsValid() const
+	{
+		return Feature && Parameter;
+	}
+};
+
+struct NGXRHI_API FDLSSState
+{
+	// this is used by the RHIs to see whether they need to recreate the NGX feature
+
+	bool RequiresFeatureRecreation(const FRHIDLSSArguments& InArguments);
+	
+	bool HasValidFeature() const
+	{
+		return DLSSFeature && DLSSFeature->IsValid();
+	}
+
+	// this is stored via pointer to allow the NGXRHIs use the API specific functions to create & release
+	TSharedPtr<NGXDLSSFeature> DLSSFeature;
+};
+
+using FDLSSStateRef = TSharedPtr<FDLSSState, ESPMode::ThreadSafe>;
+
+enum class ENGXBinariesSearchOrder
+{
+	MinValue = 0,
+	CustomThenGeneric = 0,
+	ForceGeneric = 1,
+	ForceCustom = 2,
+	ForceDevelopmentGeneric = 3,
+	MaxValue = ForceDevelopmentGeneric
+};
+
+enum class ENGXProjectIdentifier
+{
+	MinValue = 0,
+	NGXApplicationIDThenUEProjectID = 0,
+	ForceUEProjectID = 1,
+	ForceNGXApplicationID = 2,
+	MaxValue = ForceNGXApplicationID
+};
+
+struct FNGXRHICreateArguments
+{
+	FString PluginBaseDir;
+	FDynamicRHI* DynamicRHI = nullptr;
+	ENGXBinariesSearchOrder NGXBinariesSearchOrder = ENGXBinariesSearchOrder::CustomThenGeneric;
+
+	ENGXProjectIdentifier ProjectIdentifier = ENGXProjectIdentifier::NGXApplicationIDThenUEProjectID;
+	uint32 NGXAppId = 0;
+	FString UnrealEngineVersion;
+	FString UnrealProjectID;
+	bool bAllowOTAUpdate = true;
+
+	// centralize that logic here for the derived NGXRHIs
+	bool InitializeNGXWithNGXApplicationID() const
+	{
+		if ((ProjectIdentifier == ENGXProjectIdentifier::NGXApplicationIDThenUEProjectID) && (NGXAppId != 0))
+		{
+			return true;
+		}
+		else if (ProjectIdentifier == ENGXProjectIdentifier::ForceNGXApplicationID)
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+};
+
+struct FDLSSOptimalSettings
+{
+	FIntPoint RenderSize;
+
+	FIntPoint RenderSizeMin;
+	FIntPoint RenderSizeMax;
+	float Sharpness;
+
+	bool bIsSupported;
+	float OptimalResolutionFraction;
+
+	float MinResolutionFraction;
+	float MaxResolutionFraction;
+
+	bool  IsFixedResolution() const
+	{
+		return MinResolutionFraction == MaxResolutionFraction;
+	}
+};
+
+class NGXRHI_API NGXRHI
+{
+	struct NGXRHI_API FDLSSQueryFeature
+	{
+		struct FDLSSResolutionParameters
+		{
+			uint32 Width = 0;
+			uint32 Height = 0;
+			NVSDK_NGX_PerfQuality_Value PerfQuality = NVSDK_NGX_PerfQuality_Value_MaxPerf;
+
+
+			FDLSSResolutionParameters(uint32 InWidth, uint32 InHeight, NVSDK_NGX_PerfQuality_Value InPerfQuality)
+				: Width(InWidth)
+				, Height(InHeight)
+				, PerfQuality(InPerfQuality)
+			{}
+		};
+
+		void QueryDLSSSupport();
+		FDLSSOptimalSettings GetDLSSOptimalSettings(const FDLSSResolutionParameters& InResolution) const;
+
+		// the lifetime of this is managed directly by the encompassing derived RHI
+		NVSDK_NGX_Parameter* CapabilityParameters = nullptr;
+
+		bool bIsDlssSRAvailable = false;
+		bool bIsDlssRRAvailable = false;
+		FNGXDriverRequirements NGXDriverRequirements;
+		FNGXDriverRequirements NGXDLSSSRDriverRequirements;
+		FNGXDriverRequirements NGXDLSSRRDriverRequirements;
+
+		NVSDK_NGX_Result NGXInitResult = NVSDK_NGX_Result_Fail;
+		NVSDK_NGX_Result NGXDLSSSRInitResult = NVSDK_NGX_Result_Fail;
+		NVSDK_NGX_Result NGXDLSSRRInitResult = NVSDK_NGX_Result_Fail;
+	};
+
+	
+public:
+	
+
+	virtual ~NGXRHI();
+
+	virtual void ExecuteDLSS(FRHICommandList& CmdList, const FRHIDLSSArguments& InArguments, FDLSSStateRef InDLSSState) = 0;
+
+	virtual bool IsRRSupportedByRHI() const = 0;
+
+	bool IsDLSSAvailable() const
+	{
+		return NGXQueryFeature.bIsDlssSRAvailable;
+	}
+
+	bool IsDLSSRRAvailable() const
+	{
+		return NGXQueryFeature.bIsDlssRRAvailable;
+	}
+
+	NVSDK_NGX_Result GetNGXInitResult() const
+	{
+		return NGXQueryFeature.NGXInitResult;
+	}
+
+	const FNGXDriverRequirements& GetNGXDriverRequirements() const
+	{
+		return NGXQueryFeature.NGXDriverRequirements;
+	}
+
+	const FNGXDriverRequirements& GetDLSSSRDriverRequirements() const
+	{
+		return NGXQueryFeature.NGXDLSSSRDriverRequirements;
+	}
+
+	const FNGXDriverRequirements& GetDLSSRRDriverRequirements() const
+	{
+		return NGXQueryFeature.NGXDLSSRRDriverRequirements;
+	}
+
+	FDLSSOptimalSettings GetDLSSOptimalSettings(const FDLSSQueryFeature::FDLSSResolutionParameters& InResolution) const
+	{
+		return NGXQueryFeature.GetDLSSOptimalSettings(InResolution);
+	}
+
+	FDLSSOptimalSettings GetDLSSOptimalSettings(NVSDK_NGX_PerfQuality_Value QualityLevel) const
+	{
+		return NGXQueryFeature.GetDLSSOptimalSettings(FDLSSQueryFeature::FDLSSResolutionParameters(1000, 1000, QualityLevel));
+	}
+
+	float GetDLSSResolutionFraction(NVSDK_NGX_PerfQuality_Value QualityLevel) const
+	{ 
+		return GetDLSSOptimalSettings(QualityLevel).OptimalResolutionFraction;
+	}
+
+	TPair<FString, bool> GetDLSSGenericBinaryInfo() const;
+	TPair<FString, bool> GetDLSSCustomBinaryInfo() const;
+
+	void TickPoolElements();
+
+	static bool NGXInitialized()
+	{
+		return bNGXInitialized;
+	}
+
+	static bool IsIncompatibleAPICaptureToolActive()
+	{
+		return bIsIncompatibleAPICaptureToolActive;
+	}
+
+
+protected:
+
+	NGXRHI(const FNGXRHICreateArguments& Arguments);
+
+	const NVSDK_NGX_FeatureCommonInfo* CommonFeatureInfo() const
+	{
+		return &FeatureInfo;
+	}
+
+	void RegisterFeature(TSharedPtr<NGXDLSSFeature> InFeature);
+	TSharedPtr<NGXDLSSFeature> FindFreeFeature(const FRHIDLSSArguments& InArguments);
+
+	void ReleaseAllocatedFeatures();
+	void ApplyCommonNGXParameterSettings(NVSDK_NGX_Parameter* Parameter, const FRHIDLSSArguments& InArguments);
+	static FString GetNGXLogDirectory();
+
+	bool IsSafeToShutdownNGX() const;
+
+	FDynamicRHI* DynamicRHI = nullptr;
+	
+	FDLSSQueryFeature NGXQueryFeature;
+	
+	uint32 FrameCounter = 1;
+
+	static bool bNGXInitialized;
+	static bool bIsIncompatibleAPICaptureToolActive;
+private:
+	TArray< TSharedPtr<NGXDLSSFeature>> AllocatedDLSSFeatures;
+
+	TTuple<FString, bool> DLSSGenericBinaryInfo;
+	TTuple<FString, bool> DLSSCustomBinaryInfo;
+	
+	TArray<FString> NGXDLLSearchPaths;
+	TArray<const wchar_t*> NGXDLLSearchPathRawStrings;
+
+	NVSDK_NGX_FeatureCommonInfo FeatureInfo = {{0}};
+};
+
+
+// Implemented by the API specific modules
+class INGXRHIModule : public IModuleInterface
+{
+public:
+	virtual TUniquePtr<NGXRHI> CreateNGXRHI(const FNGXRHICreateArguments& Arguments) = 0;
+};
+
+class FNGXRHIModule final : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule();
+	virtual void ShutdownModule();
+};

Plugins/Marketplace/DLSS/Source/NGXVulkanRHI/NGXVulkanRHI.Build.cs

@@ -0,0 +1,57 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+
+public class NGXVulkanRHI : ModuleRules
+{
+	public NGXVulkanRHI(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Core",
+					"Engine",
+					"RenderCore",
+					"RHI",
+					"VulkanRHI",
+					
+					"NGX",
+					"NGXRHI",
+			}
+			);
+
+		// those come from the VulkanRHI
+		AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
+
+	}
+}

Plugins/Marketplace/DLSS/Source/NGXVulkanRHI/Private/NGXVulkanRHI.cpp

@@ -0,0 +1,467 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "NGXVulkanRHI.h"
+
+#include "IVulkanDynamicRHI.h"
+
+#include "nvsdk_ngx_vk.h"
+#include "nvsdk_ngx_helpers_vk.h"
+#include "nvsdk_ngx_helpers_dlssd_vk.h"
+
+#include "GenericPlatform/GenericPlatformFile.h"
+
+DEFINE_LOG_CATEGORY_STATIC(LogDLSSNGXVulkanRHI, Log, All);
+
+#define LOCTEXT_NAMESPACE "FNGXVulkanRHIModule"
+
+class FVulkanNGXDLSSFeature final : public NGXDLSSFeature
+{
+
+public:
+	using NGXDLSSFeature::NGXDLSSFeature;
+
+	virtual ~FVulkanNGXDLSSFeature()
+	{
+		check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+		check(NGXRHI::NGXInitialized());
+		NVSDK_NGX_Result ResultReleaseFeature = NVSDK_NGX_VULKAN_ReleaseFeature(Feature);
+		checkf(NVSDK_NGX_SUCCEED(ResultReleaseFeature), TEXT("NVSDK_NGX_VULKAN_ReleaseFeature failed! (%u %s), %s"), ResultReleaseFeature, GetNGXResultAsString(ResultReleaseFeature), *Desc.GetDebugDescription());
+
+		if (Parameter != nullptr)
+		{
+			NVSDK_NGX_Result ResultDestroyParameter = NVSDK_NGX_VULKAN_DestroyParameters(Parameter);
+			checkf(NVSDK_NGX_SUCCEED(ResultDestroyParameter), TEXT("NVSDK_NGX_VULKAN_DestroyParameters failed! (%u %s), %s"), ResultDestroyParameter, GetNGXResultAsString(ResultDestroyParameter), *Desc.GetDebugDescription());
+		}
+	}
+};
+
+
+class FNGXVulkanRHI final : public NGXRHI
+{
+
+public:
+	FNGXVulkanRHI(const FNGXRHICreateArguments& Arguments);
+	virtual void ExecuteDLSS(FRHICommandList& CmdList, const FRHIDLSSArguments& InArguments, FDLSSStateRef InDLSSState) final;
+	virtual ~FNGXVulkanRHI();
+	virtual bool IsRRSupportedByRHI() const override { return false; }
+private:
+
+	IVulkanDynamicRHI* VulkanRHI = nullptr;
+
+	NVSDK_NGX_Result Init_NGX_VK(const FNGXRHICreateArguments& InArguments, const wchar_t* InApplicationDataPath, VkInstance InInstance, VkPhysicalDevice InPD, VkDevice InDevice, const NVSDK_NGX_FeatureCommonInfo* InFeatureInfo);
+	static bool IsIncompatibleAPICaptureToolActive();
+};
+
+
+bool FNGXVulkanRHI::IsIncompatibleAPICaptureToolActive()
+{
+	// TODO figure out whether the renderdoc layer is active, either here or in the PreInit module
+	return false;
+}
+
+NVSDK_NGX_Result FNGXVulkanRHI::Init_NGX_VK(const FNGXRHICreateArguments& InArguments, const wchar_t* InApplicationDataPath, VkInstance InInstance, VkPhysicalDevice InPD, VkDevice InDevice, const NVSDK_NGX_FeatureCommonInfo* InFeatureInfo)
+{
+	NVSDK_NGX_Result Result = NVSDK_NGX_Result_Fail;
+	int32 APIVersion = NVSDK_NGX_VERSION_API_MACRO;
+	do 
+	{
+		if (InArguments.InitializeNGXWithNGXApplicationID())
+		{
+			Result = NVSDK_NGX_VULKAN_Init(InArguments.NGXAppId, InApplicationDataPath, InInstance, InPD, InDevice, nullptr, nullptr, InFeatureInfo, static_cast<NVSDK_NGX_Version>(APIVersion));
+			UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("NVSDK_NGX_VULKAN_Init(AppID= %u, APIVersion = 0x%x) -> (%u %s)"), InArguments.NGXAppId, APIVersion, Result, GetNGXResultAsString(Result));
+		}
+		else
+		{
+			Result = NVSDK_NGX_VULKAN_Init_with_ProjectID(TCHAR_TO_UTF8(*InArguments.UnrealProjectID), NVSDK_NGX_ENGINE_TYPE_UNREAL, TCHAR_TO_UTF8(*InArguments.UnrealEngineVersion), InApplicationDataPath, InInstance, InPD, InDevice, nullptr, nullptr, InFeatureInfo, static_cast<NVSDK_NGX_Version>(APIVersion));
+			UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("NVSDK_NGX_VULKAN_Init(ProjectID = %s, EngineVersion=%s, APIVersion = 0x%x) -> (%u %s)"), *InArguments.UnrealProjectID, *InArguments.UnrealEngineVersion, APIVersion, Result, GetNGXResultAsString(Result));
+		}
+
+		if (NVSDK_NGX_FAILED(Result) && IsSafeToShutdownNGX())
+		{
+			NVSDK_NGX_VULKAN_Shutdown1(InDevice);
+		}
+
+		--APIVersion;
+	} while (NVSDK_NGX_FAILED(Result) && APIVersion >= NVSDK_NGX_VERSION_API_MACRO_BASE_LINE);
+
+	if (NVSDK_NGX_SUCCEED(Result) && (APIVersion + 1 < NVSDK_NGX_VERSION_API_MACRO_WITH_LOGGING))
+	{
+		UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("Warning: NVSDK_NGX_VULKAN_Init succeeded, but the driver installed on this system is too old the support the NGX logging API. The console variables r.NGX.LogLevel and r.NGX.EnableOtherLoggingSinks will have no effect and NGX logs will only show up in their own log files, and not in UE's log files."));
+	}
+
+	return Result;
+}
+
+
+FNGXVulkanRHI::FNGXVulkanRHI(const FNGXRHICreateArguments& Arguments)
+	: NGXRHI(Arguments)
+	, VulkanRHI(CastDynamicRHI<IVulkanDynamicRHI>(Arguments.DynamicRHI))
+{
+	check(VulkanRHI);
+
+	const FString NGXLogDir = GetNGXLogDirectory();
+	IPlatformFile::GetPlatformPhysical().CreateDirectoryTree(*NGXLogDir);
+
+	bIsIncompatibleAPICaptureToolActive = IsIncompatibleAPICaptureToolActive();
+
+	VkInstance VulkanInstance = VulkanRHI->RHIGetVkInstance();
+	VkPhysicalDevice VulkanPhysicalDevice = VulkanRHI->RHIGetVkPhysicalDevice();
+	VkDevice VulkanLogicalDevice = VulkanRHI->RHIGetVkDevice();
+
+	NVSDK_NGX_Result ResultInit = Init_NGX_VK(Arguments, *NGXLogDir, VulkanInstance, VulkanPhysicalDevice, VulkanLogicalDevice, CommonFeatureInfo());
+	UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("NVSDK_NGX_VULKAN_Init (Log %s) -> (%u %s)"), *NGXLogDir, ResultInit, GetNGXResultAsString(ResultInit));
+
+	// store for the higher level code interpret
+	NGXQueryFeature.NGXInitResult = ResultInit;
+
+	if (NVSDK_NGX_Result_FAIL_OutOfDate == ResultInit)
+	{
+		NGXQueryFeature.NGXDriverRequirements.DriverUpdateRequired = true;
+	}
+	else if (NVSDK_NGX_SUCCEED(ResultInit))
+	{
+		bNGXInitialized = true;
+
+		NVSDK_NGX_Result ResultGetParameters = NVSDK_NGX_VULKAN_GetCapabilityParameters(&NGXQueryFeature.CapabilityParameters);
+		UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("NVSDK_NGX_VULKAN_GetCapabilityParameters -> (%u %s)"), ResultGetParameters, GetNGXResultAsString(ResultGetParameters));
+
+		if (NVSDK_NGX_Result_FAIL_OutOfDate == ResultGetParameters)
+		{
+			NGXQueryFeature.NGXDriverRequirements.DriverUpdateRequired = true;
+		}
+
+		if (NVSDK_NGX_SUCCEED(ResultGetParameters))
+		{
+			NGXQueryFeature.QueryDLSSSupport();
+		}
+	}
+}
+
+FNGXVulkanRHI::~FNGXVulkanRHI()
+{
+	UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	if (bNGXInitialized)
+	{
+		// Destroy the parameters and features before we call NVSDK_NGX_VULKAN_Shutdown1
+		ReleaseAllocatedFeatures();
+
+		NVSDK_NGX_Result Result;
+		if (NGXQueryFeature.CapabilityParameters != nullptr)
+		{
+			Result = NVSDK_NGX_VULKAN_DestroyParameters(NGXQueryFeature.CapabilityParameters);
+			UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("NVSDK_NGX_VULKAN_DestroyParameters -> (%u %s)"), Result, GetNGXResultAsString(Result));
+		}
+		if (IsSafeToShutdownNGX())
+		{
+			VkDevice VulkanLogicalDevice = VulkanRHI->RHIGetVkDevice();
+			Result = NVSDK_NGX_VULKAN_Shutdown1(VulkanLogicalDevice);
+			UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("NVSDK_NGX_VULKAN_Shutdown1 -> (%u %s)"), Result, GetNGXResultAsString(Result));
+		}
+		bNGXInitialized = false;
+	}
+	UE_LOG(LogDLSSNGXVulkanRHI, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+void FNGXVulkanRHI::ExecuteDLSS(FRHICommandList& CmdList, const FRHIDLSSArguments& InArguments, FDLSSStateRef InDLSSState)
+{
+	check(!IsRunningRHIInSeparateThread() || IsInRHIThread());
+	check(IsDLSSAvailable());
+	if (!IsDLSSAvailable()) return;
+
+	InArguments.Validate();
+
+	VkCommandBuffer VulkanCommandBuffer = VulkanRHI->RHIGetActiveVkCommandBuffer();
+	
+	if (InDLSSState->RequiresFeatureRecreation(InArguments))
+	{
+		check(!InDLSSState->DLSSFeature || InDLSSState->HasValidFeature());
+		InDLSSState->DLSSFeature = nullptr;
+	}
+
+	if (InArguments.bReset)
+	{
+		check(!InDLSSState->DLSSFeature);
+		InDLSSState->DLSSFeature = FindFreeFeature(InArguments);
+	}
+
+	if (!InDLSSState->DLSSFeature)
+	{
+		VkDevice VulkanLogicalDevice = VulkanRHI->RHIGetVkDevice();
+		NVSDK_NGX_Parameter* NewNGXParameterHandle = nullptr;
+		NVSDK_NGX_Result Result = NVSDK_NGX_VULKAN_AllocateParameters(&NewNGXParameterHandle);
+		checkf(NVSDK_NGX_SUCCEED(Result), TEXT("NVSDK_NGX_VULKAN_AllocateParameters failed! (%u %s)"), Result, GetNGXResultAsString(Result));
+		
+		ApplyCommonNGXParameterSettings(NewNGXParameterHandle, InArguments);
+
+		if (InArguments.DenoiserMode == ENGXDLSSDenoiserMode::DLSSRR)
+		{
+			// DLSS-SR feature creation
+			NVSDK_NGX_DLSSD_Create_Params DlssRRCreateParams = InArguments.GetNGXDLSSRRCreateParams();
+			NVSDK_NGX_Handle* NewNGXFeatureHandle = nullptr;
+
+			const uint32 CreationNodeMask = 1 << InArguments.GPUNode;
+			const uint32 VisibilityNodeMask = InArguments.GPUVisibility;
+
+			NVSDK_NGX_Result ResultCreate = NGX_VULKAN_CREATE_DLSSD_EXT1(
+				VulkanLogicalDevice,
+				VulkanCommandBuffer,
+				CreationNodeMask,
+				VisibilityNodeMask,
+				&NewNGXFeatureHandle,
+				NewNGXParameterHandle,
+				&DlssRRCreateParams);
+
+			if (NVSDK_NGX_SUCCEED(ResultCreate))
+			{
+				InDLSSState->DLSSFeature = MakeShared<FVulkanNGXDLSSFeature>(NewNGXFeatureHandle, NewNGXParameterHandle, InArguments.GetFeatureDesc(), FrameCounter);
+				InDLSSState->DLSSFeature->bHasDLSSRR = true;
+			}
+			else
+			{
+				UE_LOG(LogDLSSNGXVulkanRHI, Error,
+					TEXT("NGX_VULKAN_CREATE_DLSSD_EXT1 failed, falling back to DLSS-SR! (CreationNodeMask=0x%x VisibilityNodeMask=0x%x) (%u %s), %s"),
+					CreationNodeMask,
+					VisibilityNodeMask,
+					ResultCreate,
+					GetNGXResultAsString(ResultCreate),
+					*InArguments.GetFeatureDesc().GetDebugDescription());
+				InDLSSState->DLSSFeature.Reset();
+			}
+		}
+		if (!InDLSSState->DLSSFeature.IsValid())
+		{
+			// DLSS-SR feature creation
+			NVSDK_NGX_DLSS_Create_Params DlssCreateParams = InArguments.GetNGXDLSSCreateParams();
+			NVSDK_NGX_Handle* NewNGXFeatureHandle = nullptr;
+
+			const uint32 CreationNodeMask = 1 << InArguments.GPUNode;
+			const uint32 VisibilityNodeMask = InArguments.GPUVisibility;
+
+			NVSDK_NGX_Result ResultCreate = NGX_VULKAN_CREATE_DLSS_EXT(
+				VulkanCommandBuffer,
+				CreationNodeMask,
+				VisibilityNodeMask,
+				&NewNGXFeatureHandle,
+				NewNGXParameterHandle,
+				&DlssCreateParams);
+
+			checkf(NVSDK_NGX_SUCCEED(ResultCreate), TEXT("NGX_VULKAN_CREATE_DLSS failed! (CreationNodeMask=0x%x VisibilityNodeMask=0x%x) (%u %s), %s"), CreationNodeMask, VisibilityNodeMask, ResultCreate, GetNGXResultAsString(ResultCreate), *InArguments.GetFeatureDesc().GetDebugDescription());
+			InDLSSState->DLSSFeature = MakeShared<FVulkanNGXDLSSFeature>(NewNGXFeatureHandle, NewNGXParameterHandle, InArguments.GetFeatureDesc(), FrameCounter);
+		}
+
+		RegisterFeature(InDLSSState->DLSSFeature);
+	}
+
+	check(InDLSSState->HasValidFeature());
+
+	// execute
+	auto NGXVulkanResourceFromRHITexture = [VulkanRHI=VulkanRHI](FRHITexture* InRHITexture)
+	{
+		check(InRHITexture);
+		if (FRHITextureReference* TexRef = InRHITexture->GetTextureReference())
+		{
+			InRHITexture = TexRef->GetReferencedTexture();
+			check(InRHITexture);
+		}
+
+		const FVulkanRHIImageViewInfo ImageViewInfo = VulkanRHI->RHIGetImageViewInfo(InRHITexture);
+
+		NVSDK_NGX_Resource_VK NGXTexture;
+		FMemory::Memzero(NGXTexture);
+
+		NGXTexture.Type = NVSDK_NGX_RESOURCE_VK_TYPE_VK_IMAGEVIEW;
+
+		// Check for VK_IMAGE_USAGE_STORAGE_BIT. Those are not directly stored but FVulkanSurface::GenerateImageCreateInfo sets the VK flag based on those UEFlags
+		NGXTexture.ReadWrite = EnumHasAnyFlags(ImageViewInfo.UEFlags, TexCreate_Presentable | TexCreate_UAV);
+
+		NGXTexture.Resource.ImageViewInfo.ImageView = ImageViewInfo.ImageView;
+		NGXTexture.Resource.ImageViewInfo.Image = ImageViewInfo.Image;
+		NGXTexture.Resource.ImageViewInfo.Format = ImageViewInfo.Format;
+
+		NGXTexture.Resource.ImageViewInfo.Width = ImageViewInfo.Width;
+		NGXTexture.Resource.ImageViewInfo.Height = ImageViewInfo.Height;
+		check(ImageViewInfo.Depth == 1);
+
+		NGXTexture.Resource.ImageViewInfo.SubresourceRange = ImageViewInfo.SubresourceRange;
+
+		// DLSS_TODO Figure out where to get those from if the textures are arrayed or mipped.
+		check(NGXTexture.Resource.ImageViewInfo.SubresourceRange.layerCount == 1);
+		check(NGXTexture.Resource.ImageViewInfo.SubresourceRange.levelCount == 1);
+
+		return NGXTexture;
+	};
+
+	if (InDLSSState->DLSSFeature->bHasDLSSRR)
+	{
+		NVSDK_NGX_VK_DLSSD_Eval_Params DlssRREvalParams;
+		FMemory::Memzero(DlssRREvalParams);
+		NVSDK_NGX_Resource_VK InOutput = NGXVulkanResourceFromRHITexture(InArguments.OutputColor);
+		DlssRREvalParams.pInOutput = &InOutput;
+		check(InArguments.OutputColor->GetFlags() & (TexCreate_UAV | TexCreate_Presentable));
+		check(InOutput.ReadWrite == true);
+		DlssRREvalParams.InOutputSubrectBase.X = InArguments.DestRect.Min.X;
+		DlssRREvalParams.InOutputSubrectBase.Y = InArguments.DestRect.Min.Y;
+
+		DlssRREvalParams.InRenderSubrectDimensions.Width = InArguments.SrcRect.Width();
+		DlssRREvalParams.InRenderSubrectDimensions.Height = InArguments.SrcRect.Height();
+
+		NVSDK_NGX_Resource_VK InColor = NGXVulkanResourceFromRHITexture(InArguments.InputColor);
+		DlssRREvalParams.pInColor = &InColor;
+		DlssRREvalParams.InColorSubrectBase.X = InArguments.SrcRect.Min.X;
+		DlssRREvalParams.InColorSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+		NVSDK_NGX_Resource_VK InDepth = NGXVulkanResourceFromRHITexture(InArguments.InputDepth);
+		DlssRREvalParams.pInDepth = &InDepth;
+		DlssRREvalParams.InDepthSubrectBase.X = InArguments.SrcRect.Min.X;
+		DlssRREvalParams.InDepthSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+		NVSDK_NGX_Resource_VK InMotionVectors = NGXVulkanResourceFromRHITexture(InArguments.InputMotionVectors);
+		DlssRREvalParams.pInMotionVectors = &InMotionVectors;
+		// The VelocityCombine pass puts the motion vectors into the top left corner
+		DlssRREvalParams.InMVSubrectBase.X = 0;
+		DlssRREvalParams.InMVSubrectBase.Y = 0;
+
+		NVSDK_NGX_Resource_VK InExposureTexture = NGXVulkanResourceFromRHITexture(InArguments.InputExposure);
+		DlssRREvalParams.pInExposureTexture = InArguments.bUseAutoExposure ? nullptr : &InExposureTexture;
+		DlssRREvalParams.InPreExposure = InArguments.PreExposure;
+
+		DlssRREvalParams.InJitterOffsetX = InArguments.JitterOffset.X;
+		DlssRREvalParams.InJitterOffsetY = InArguments.JitterOffset.Y;
+
+		DlssRREvalParams.InMVScaleX = InArguments.MotionVectorScale.X;
+		DlssRREvalParams.InMVScaleY = InArguments.MotionVectorScale.Y;
+		DlssRREvalParams.InReset = InArguments.bReset;
+
+		DlssRREvalParams.InFrameTimeDeltaInMsec = InArguments.DeltaTimeMS;
+
+		// The GBufferResolve pass puts the albedos into the top left corner
+		NVSDK_NGX_Resource_VK InDiffuseAlbedoTexture = NGXVulkanResourceFromRHITexture(InArguments.InputDiffuseAlbedo);
+		DlssRREvalParams.pInDiffuseAlbedo = &InDiffuseAlbedoTexture;
+		DlssRREvalParams.InDiffuseAlbedoSubrectBase.X = 0;
+		DlssRREvalParams.InDiffuseAlbedoSubrectBase.Y = 0;
+
+		NVSDK_NGX_Resource_VK InSpecularAlbedoTexture = NGXVulkanResourceFromRHITexture(InArguments.InputSpecularAlbedo);
+		DlssRREvalParams.pInSpecularAlbedo = &InSpecularAlbedoTexture;
+		DlssRREvalParams.InSpecularAlbedoSubrectBase.X = 0;
+		DlssRREvalParams.InSpecularAlbedoSubrectBase.Y = 0;
+
+		NVSDK_NGX_Resource_VK InNormalTexture = NGXVulkanResourceFromRHITexture(InArguments.InputNormals);
+		DlssRREvalParams.pInNormals = &InNormalTexture;
+		NVSDK_NGX_Resource_VK InRoughnessTexture = NGXVulkanResourceFromRHITexture(InArguments.InputRoughness);
+		DlssRREvalParams.pInRoughness = &InRoughnessTexture;
+
+#if SUPPORT_GUIDE_GBUFFER
+		if (InArguments.InputReflectionHitDistance)
+		{
+			NVSDK_NGX_Resource_VK InReflectionDistanceTexture = NGXVulkanResourceFromRHITexture(InArguments.InputReflectionHitDistance);
+			DlssRREvalParams.pInSpecularHitDistance = &InReflectionDistanceTexture;
+			DlssRREvalParams.InSpecularHitDistanceSubrectBase.X = 0;
+			DlssRREvalParams.InSpecularHitDistanceSubrectBase.Y = 0;
+
+			// Yes, the interface takes a non-const ptr as an argument
+			DlssRREvalParams.pInWorldToViewMatrix = const_cast<float*>(InArguments.ViewMatrix);
+			DlssRREvalParams.pInViewToClipMatrix = const_cast<float*>(InArguments.ProjectionMatrix);
+		}
+#endif
+
+		NVSDK_NGX_Result ResultEvaluate = NGX_VULKAN_EVALUATE_DLSSD_EXT(
+			VulkanCommandBuffer,
+			InDLSSState->DLSSFeature->Feature,
+			InDLSSState->DLSSFeature->Parameter,
+			&DlssRREvalParams
+		);
+
+		checkf(NVSDK_NGX_SUCCEED(ResultEvaluate), TEXT("NGX_Vulkan_EVALUATE_DLSSD_EXT failed! (%u %s), %s"), ResultEvaluate, GetNGXResultAsString(ResultEvaluate), *InDLSSState->DLSSFeature->Desc.GetDebugDescription());
+	}
+	else
+	{
+		NVSDK_NGX_VK_DLSS_Eval_Params DlssEvalParams;
+		FMemory::Memzero(DlssEvalParams);
+		NVSDK_NGX_Resource_VK InOutput = NGXVulkanResourceFromRHITexture(InArguments.OutputColor);
+		DlssEvalParams.Feature.pInOutput = &InOutput;
+		check(InArguments.OutputColor->GetFlags() & (TexCreate_UAV | TexCreate_Presentable));
+		check(InOutput.ReadWrite == true);
+		DlssEvalParams.InOutputSubrectBase.X = InArguments.DestRect.Min.X;
+		DlssEvalParams.InOutputSubrectBase.Y = InArguments.DestRect.Min.Y;
+
+		DlssEvalParams.InRenderSubrectDimensions.Width = InArguments.SrcRect.Width();
+		DlssEvalParams.InRenderSubrectDimensions.Height = InArguments.SrcRect.Height();
+
+		NVSDK_NGX_Resource_VK InColor = NGXVulkanResourceFromRHITexture(InArguments.InputColor);
+		DlssEvalParams.Feature.pInColor = &InColor;
+		DlssEvalParams.InColorSubrectBase.X = InArguments.SrcRect.Min.X;
+		DlssEvalParams.InColorSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+		NVSDK_NGX_Resource_VK InDepth = NGXVulkanResourceFromRHITexture(InArguments.InputDepth);
+		DlssEvalParams.pInDepth = &InDepth;
+		DlssEvalParams.InDepthSubrectBase.X = InArguments.SrcRect.Min.X;
+		DlssEvalParams.InDepthSubrectBase.Y = InArguments.SrcRect.Min.Y;
+
+		NVSDK_NGX_Resource_VK InMotionVectors = NGXVulkanResourceFromRHITexture(InArguments.InputMotionVectors);
+		DlssEvalParams.pInMotionVectors = &InMotionVectors;
+		// The VelocityCombine pass puts the motion vectors into the top left corner
+		DlssEvalParams.InMVSubrectBase.X = 0;
+		DlssEvalParams.InMVSubrectBase.Y = 0;
+
+		NVSDK_NGX_Resource_VK InExposureTexture = NGXVulkanResourceFromRHITexture(InArguments.InputExposure);
+		DlssEvalParams.pInExposureTexture = InArguments.bUseAutoExposure ? nullptr : &InExposureTexture;
+		DlssEvalParams.InPreExposure = InArguments.PreExposure;
+
+		DlssEvalParams.Feature.InSharpness = InArguments.Sharpness;
+		DlssEvalParams.InJitterOffsetX = InArguments.JitterOffset.X;
+		DlssEvalParams.InJitterOffsetY = InArguments.JitterOffset.Y;
+
+		DlssEvalParams.InMVScaleX = InArguments.MotionVectorScale.X;
+		DlssEvalParams.InMVScaleY = InArguments.MotionVectorScale.Y;
+		DlssEvalParams.InReset = InArguments.bReset;
+
+		DlssEvalParams.InFrameTimeDeltaInMsec = InArguments.DeltaTimeMS;
+
+		NVSDK_NGX_Result ResultEvaluate = NGX_VULKAN_EVALUATE_DLSS_EXT(
+			VulkanCommandBuffer,
+			InDLSSState->DLSSFeature->Feature,
+			InDLSSState->DLSSFeature->Parameter,
+			&DlssEvalParams
+		);
+
+		checkf(NVSDK_NGX_SUCCEED(ResultEvaluate), TEXT("NGX_Vulkan_EVALUATE_DLSS_EXT failed! (%u %s), %s"), ResultEvaluate, GetNGXResultAsString(ResultEvaluate), *InDLSSState->DLSSFeature->Desc.GetDebugDescription());
+	}
+	InDLSSState->DLSSFeature->Tick(FrameCounter);
+
+	VulkanRHI->RHIRegisterWork(1);
+	VulkanRHI->RHIFinishExternalComputeWork(VulkanCommandBuffer);
+}
+
+
+/** IModuleInterface implementation */
+
+void FNGXVulkanRHIModule::StartupModule()
+{
+	// NGXRHI module should be loaded to ensure logging state is initialized
+	FModuleManager::LoadModuleChecked<INGXRHIModule>(TEXT("NGXRHI"));
+}
+
+void FNGXVulkanRHIModule::ShutdownModule()
+{
+}
+
+TUniquePtr<NGXRHI> FNGXVulkanRHIModule::CreateNGXRHI(const FNGXRHICreateArguments& Arguments)
+{
+	TUniquePtr<NGXRHI> Result(new FNGXVulkanRHI(Arguments));
+	return Result;
+}
+
+IMPLEMENT_MODULE(FNGXVulkanRHIModule, NGXVulkanRHI)
+
+#undef LOCTEXT_NAMESPACE
+
+

Plugins/Marketplace/DLSS/Source/NGXVulkanRHI/Public/NGXVulkanRHI.h

@@ -0,0 +1,27 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+#include "Modules/ModuleManager.h"
+
+#include "NGXRHI.h"
+
+class FNGXVulkanRHIModule final : public INGXRHIModule
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule();
+	virtual void ShutdownModule();
+
+	/** INGXRHIModule implementation */
+	virtual TUniquePtr<NGXRHI> CreateNGXRHI(const FNGXRHICreateArguments& Arguments);
+};

Plugins/Marketplace/DLSS/Source/NGXVulkanRHIPreInit/NGXVulkanRHIPreInit.Build.cs

@@ -0,0 +1,56 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+
+public class NGXVulkanRHIPreInit : ModuleRules
+{
+	public NGXVulkanRHIPreInit(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PublicIncludePaths.AddRange(
+			new string[] {
+				// ... add public include paths required here ...
+			}
+			);
+
+
+		PrivateIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+
+
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Core",
+					"Engine",
+					"RenderCore",
+					"RHI",
+
+					"VulkanRHI",
+					"NGX",
+			}
+			);
+
+		// those come from the VulkanRHI
+		AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
+	}
+}

Plugins/Marketplace/DLSS/Source/NGXVulkanRHIPreInit/Private/NGXVulkanRHIPreInit.cpp

@@ -0,0 +1,89 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "NGXVulkanRHIPreInit.h"
+
+#include "IVulkanDynamicRHI.h"
+
+#include "Misc/App.h"
+#include "DynamicRHI.h"
+
+#include "nvsdk_ngx_vk.h"
+
+DEFINE_LOG_CATEGORY_STATIC(LogDLSSNGXVulkanRHIPreInit, Log, All);
+
+#define LOCTEXT_NAMESPACE "FNGXVulkanRHIPreInitModule"
+
+
+void FNGXVulkanRHIPreInitModule::StartupModule()
+{
+	UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	if(FApp::CanEverRender())
+	{
+		const TCHAR* VulkanRHIModuleName = TEXT("VulkanRHI");
+
+		// don't cleanup since the same module gets loaded shortly thereafter anyways
+		const TCHAR* DynamicRHIModuleName = GetSelectedDynamicRHIModuleName(false);
+		UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("GetSelectedDynamicRHIModuleName = %s"), DynamicRHIModuleName);
+
+		if(FString(VulkanRHIModuleName) == FString(DynamicRHIModuleName))
+		{
+			IDynamicRHIModule* VulkanRHIModule = FModuleManager::GetModulePtr<IDynamicRHIModule>(VulkanRHIModuleName);
+
+			if(VulkanRHIModule && VulkanRHIModule->IsSupported())
+			{
+				unsigned int NumInstanceExtensions = 0 ;
+				const char** InstanceExtensions = nullptr;
+				unsigned int NumDeviceExtensions = 0;
+				const char** DeviceExtensions = nullptr;
+
+				// TODO: NVSDK_NGX_VULKAN_RequiredExtensions deprecated, change to use NVSDK_NGX_VULKAN_GetFeatureInstanceExtensionRequirements instead
+				// We'll need information that's currently stored in UDLSSSettings from the DLSS module which isn't loaded yet
+				const NVSDK_NGX_Result ResultRequiredExtensions = NVSDK_NGX_VULKAN_RequiredExtensions(&NumInstanceExtensions, &InstanceExtensions, &NumDeviceExtensions, &DeviceExtensions);
+				UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("NVSDK_NGX_VULKAN_RequiredExtensions -> (%u %s)"), ResultRequiredExtensions, GetNGXResultAsString(ResultRequiredExtensions));
+
+				const TArrayView<const ANSICHAR* const> RHIBridgeInstanceExtensions(InstanceExtensions, NumInstanceExtensions);
+				IVulkanDynamicRHI::AddEnabledInstanceExtensionsAndLayers(RHIBridgeInstanceExtensions, TArrayView<const ANSICHAR* const>());
+
+				const TArrayView<const ANSICHAR* const> RHIBridgeDeviceExtensions(DeviceExtensions, NumDeviceExtensions);
+				IVulkanDynamicRHI::AddEnabledDeviceExtensionsAndLayers(RHIBridgeDeviceExtensions, TArrayView<const ANSICHAR* const>());
+
+				UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("Preregistered the required NGX DLSS Vulkan device extensions (%u) and instance extensions (%u) via the VulkanRHIBridge"), NumDeviceExtensions, NumInstanceExtensions);
+			}
+			else
+			{
+				UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("Failed to load the VulkanRHI module and/or Vulkan is not supported; skipping of pregistering the required NGX DLSS Vulkan device and instance extensions via the VulkanRHIBridge"));
+			}
+		}
+		else
+		{
+			UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("VulkanRHI is not the active DynamicRHI; skipping of pregistering the required NGX DLSS Vulkan device and instance extensions via the VulkanRHIBridge"));
+		}
+	}
+	else
+	{
+		UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("This UE instance does not render; skipping of pregistering the required NGX DLSS Vulkan device and instance extensions via the VulkanRHIBridge"));
+	}
+	UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+
+}
+
+void FNGXVulkanRHIPreInitModule::ShutdownModule()
+{
+	UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+	UE_LOG(LogDLSSNGXVulkanRHIPreInit, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+IMPLEMENT_MODULE(FNGXVulkanRHIPreInitModule, NGXVulkanRHIPreInit)
+
+#undef LOCTEXT_NAMESPACE
+
+

Plugins/Marketplace/DLSS/Source/NGXVulkanRHIPreInit/Public/NGXVulkanRHIPreInit.h

@@ -0,0 +1,22 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+#include "Modules/ModuleManager.h"
+
+class FNGXVulkanRHIPreInitModule final : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule();
+	virtual void ShutdownModule();
+};

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx.h

@@ -0,0 +1,501 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2018-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+/*
+*  HOW TO USE:
+*
+*  IMPORTANT: FOR DLSS/DLISP PLEASE SEE THE PROGRAMMING GUIDE
+* 
+*  IMPORTANT: Methods in this library are NOT thread safe. It is up to the
+*  client to ensure that thread safety is enforced as needed.
+*  
+*  1) Call NVSDK_CONV NVSDK_NGX_D3D11/D3D12/CUDA_Init and pass your app Id
+*     and other parameters. This will initialize SDK or return an error code
+*     if SDK cannot run on target machine. Depending on error user might
+*     need to update drivers. Please note that application Id is provided
+*     by NVIDIA so if you do not have one please contact us.
+* 
+*  2) Call NVSDK_NGX_D3D11/D3D12/CUDA_GetCapabilityParameters to obtain pointer to 
+*     interface used to pass parameters to SDK. Interface instance is 
+*     allocated and released by SDK so there is no need to do any memory 
+*     management on client side.
+*    
+*  3) Set key parameters for the feature you want to use. For example, 
+*     width and height are required for all features and they can be
+*     set like this: 
+*         Params->Set(NVSDK_NGX_Parameter_Width,MY_WIDTH);
+*         Params->Set(NVSDK_NGX_Parameter_Height,MY_HEIGHT);
+*
+*     You can also provide hints like NVSDK_NGX_Parameter_Hint_HDR to tell
+*     SDK that it should expect HDR color space is needed. Please refer to 
+*     samples since different features need different parameters and hints.
+*
+*  4) Call NVSDK_NGX_D3D11/D3D12/CUDA_GetScratchBufferSize to obtain size of
+*     the scratch buffer needed by specific feature. This D3D or CUDA buffer
+*     should be allocated by client and passed as:
+*        Params->Set(NVSDK_NGX_Parameter_Scratch,MY_SCRATCH_POINTER)
+*        Params->Set(NVSDK_NGX_Parameter_Scratch_SizeInBytes,MY_SCRATCH_SIZE_IN_BYTES)
+*     NOTE: Returned size can be 0 if feature does not use any scratch buffer.
+*     It is OK to use bigger buffer or reuse buffers across features as long
+*     as minimum size requirement is met.
+*
+*  5) Call NVSDK_NGX_D3D11/D3D12/CUDA_CreateFeature to create feature you need.
+*     On success SDK will return a handle which must be used in any successive 
+*     calls to SDK which require feature handle. SDK will use all parameters
+*     and hints provided by client to generate feature. If feature with the same
+*     parameters already exists and error code will be returned.
+*
+*  6) Call NVSDK_NGX_D3D11/D3D12/CUDA_EvaluateFeature to invoke execution of
+*     specific feature. Before feature can be evaluated input parameters must
+*     be specified (like for example color/albedo buffer, motion vectors etc)
+* 
+*  6) Call NVSDK_NGX_D3D11/D3D12/CUDA_ReleaseFeature when feature is no longer
+*     needed. After this call feature handle becomes invalid and cannot be used.
+* 
+*  7) Call NVSDK_NGX_D3D11/D3D12/CUDA_Shutdown when SDK is no longer needed to
+*     release all resources.
+
+*  Contact: ngxsupport@nvidia.com
+*/
+
+
+#ifndef NVSDK_NGX_H
+#define NVSDK_NGX_H
+
+#include <stddef.h> // For size_t
+
+#include "nvsdk_ngx_defs.h"
+#include "nvsdk_ngx_params.h"
+#ifndef __cplusplus
+#include <stdbool.h> 
+#include <wchar.h> 
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+typedef struct IUnknown IUnknown;
+
+typedef struct IDXGIAdapter              IDXGIAdapter;
+typedef struct ID3D11Device              ID3D11Device;
+typedef struct ID3D11Resource            ID3D11Resource;
+typedef struct ID3D11DeviceContext       ID3D11DeviceContext;
+typedef struct D3D11_TEXTURE2D_DESC      D3D11_TEXTURE2D_DESC;
+typedef struct D3D11_BUFFER_DESC         D3D11_BUFFER_DESC;
+typedef struct ID3D11Buffer              ID3D11Buffer;
+typedef struct ID3D11Texture2D           ID3D11Texture2D;
+
+typedef struct ID3D12Device              ID3D12Device;
+typedef struct ID3D12Resource            ID3D12Resource;
+typedef struct ID3D12GraphicsCommandList ID3D12GraphicsCommandList;
+typedef struct D3D12_RESOURCE_DESC       D3D12_RESOURCE_DESC;
+typedef struct CD3DX12_HEAP_PROPERTIES   CD3DX12_HEAP_PROPERTIES;
+
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_D3D12_ResourceAllocCallback)(D3D12_RESOURCE_DESC *InDesc, int InState, CD3DX12_HEAP_PROPERTIES *InHeap, ID3D12Resource **OutResource);
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_D3D11_BufferAllocCallback)(D3D11_BUFFER_DESC *InDesc, ID3D11Buffer **OutResource);
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_D3D11_Tex2DAllocCallback)(D3D11_TEXTURE2D_DESC *InDesc, ID3D11Texture2D **OutResource);
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_ResourceReleaseCallback)(IUnknown *InResource);
+
+typedef unsigned long long CUtexObject;
+
+// NOTE: Functions under the same name and different function signatures exist
+// between the NGX SDK, NGX Core (driver), and NGX Snippets. To discern the
+// different signatures here we check if NGX_SNIPPET_BUILD is defined. When that
+// is the case we know that the function signature in-use should be that of
+// between NGX Core and the Snippet. Otherwise the signature should be between
+// NGX SDK and NGX Core.
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Init
+// -------------------------------------
+// 
+// InApplicationId:
+//      Unique Id provided by NVIDIA
+//
+// InApplicationDataPath:
+//      Folder to store logs and other temporary files (write access required),
+//      Normally this would be a location in Documents or ProgramData.
+//
+// InDevice: [d3d11/12 only]
+//      DirectX device to use
+//
+// InFeatureInfo:
+//      Contains information common to all features, presently only a list of all paths 
+//      feature dlls can be located in, other than the default path - application directory.
+//
+// DESCRIPTION:
+//      Initializes new SDK instance.
+//
+#if defined(NGX_SNIPPET_BUILD)
+#ifdef __cplusplus
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init_Ext(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API, const NVSDK_NGX_Parameter* InParameters = nullptr);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init_Ext(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API, const NVSDK_NGX_Parameter* InParameters = nullptr);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init_Ext(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API, const NVSDK_NGX_Parameter* InParameters = nullptr);
+#else
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, NVSDK_NGX_Version InSDKVersion);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init_Ext(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, NVSDK_NGX_Version InSDKVersion, const NVSDK_NGX_Parameter* InParameters);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, NVSDK_NGX_Version InSDKVersion);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init_Ext(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, NVSDK_NGX_Version InSDKVersion, const NVSDK_NGX_Parameter* InParameters);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, NVSDK_NGX_Version InSDKVersion);
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init_Ext(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, NVSDK_NGX_Version InSDKVersion, const NVSDK_NGX_Parameter* InParameters);
+#endif
+#else
+#ifdef __cplusplus
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+#else
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+#endif
+#endif // defined(NGX_SNIPPET_BUILD)
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Init_with_ProjectID
+// -------------------------------------
+// 
+// InProjectId:
+//      Unique Id provided by the rendering engine used
+//
+// InEngineType:
+//      Rendering engine used by the application / plugin.
+//      Use NVSDK_NGX_ENGINE_TYPE_CUSTOM if the specific engine type is not supported explicitly
+//
+// InEngineVersion:
+//      Version number of the rendering engine used by the application / plugin.
+//
+// InApplicationDataPath:
+//      Folder to store logs and other temporary files (write access required),
+//      Normally this would be a location in Documents or ProgramData.
+//
+// InDevice: [d3d11/12 only]
+//      DirectX device to use
+//
+// InFeatureInfo:
+//      Contains information common to all features, presently only a list of all paths 
+//      feature dlls can be located in, other than the default path - application directory.
+//
+// DESCRIPTION:
+//      Initializes new SDK instance.
+//
+#if defined(NGX_SNIPPET_BUILD)
+// No NGX Core <---> Snippet interfaces
+#else
+#ifdef __cplusplus
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+#else
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D11_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, ID3D11Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_D3D12_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, ID3D12Device *InDevice, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_CUDA_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+#endif
+#endif // defined(NGX_SNIPPET_BUILD)
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Shutdown
+// -------------------------------------
+// 
+// DESCRIPTION:
+//      Shuts down the current SDK instance and releases all resources.
+//      Shutdown1(Device) only affects specified device
+//      Shutdown1(nullptr) = Shutdown() and shuts down all devices
+//
+#ifdef NGX_ENABLE_DEPRECATED_SHUTDOWN
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_Shutdown(void);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_Shutdown(void);
+#endif
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_Shutdown1(ID3D11Device *InDevice);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_Shutdown1(ID3D12Device *InDevice);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_Shutdown(void);
+
+#ifdef NGX_ENABLE_DEPRECATED_GET_PARAMETERS
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetParameters
+// ----------------------------------------------------------
+//
+// OutParameters:
+//      Parameters interface used to set any parameter needed by the SDK
+//
+// DESCRIPTION:
+//      This interface allows simple parameter setup using named fields.
+//      For example one can set width by calling Set(NVSDK_NGX_Parameter_Denoiser_Width,100) or
+//      provide CUDA buffer pointer by calling Set(NVSDK_NGX_Parameter_Denoiser_Color,cudaBuffer)
+//      For more details please see sample code. Please note that allocated memory
+//      will be freed by NGX so free/delete operator should NOT be called.
+//      Parameter maps output by NVSDK_NGX_GetParameters are also pre-populated
+//      with NGX capabilities and available features.
+//      Unlike with NVSDK_NGX_AllocateParameters, parameter maps output by NVSDK_NGX_GetParameters
+//      have their lifetimes managed by NGX, and must not
+//      be destroyed by the app using NVSDK_NGX_DestroyParameters.
+//      NVSDK_NGX_GetParameters is deprecated and apps should move to using
+//      NVSDK_NGX_AllocateParameters and NVSDK_NGX_GetCapabilityParameters when possible.
+//      Nevertheless, due to the possibility that the user will be using an older driver version,
+//      NVSDK_NGX_GetParameters may still be used as a fallback if NVSDK_NGX_AllocateParameters
+//      or NVSDK_NGX_GetCapabilityParameters return NVSDK_NGX_Result_FAIL_OutOfDate.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_GetParameters(NVSDK_NGX_Parameter **OutParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_GetParameters(NVSDK_NGX_Parameter **OutParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_GetParameters(NVSDK_NGX_Parameter **OutParameters);
+#endif // NGX_ENABLE_DEPRECATED_GET_PARAMETERS
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_AllocateParameters
+// ----------------------------------------------------------
+//
+// OutParameters:
+//      Parameters interface used to set any parameter needed by the SDK
+//
+// DESCRIPTION:
+//      This interface allows allocating a simple parameter setup using named fields, whose
+//      lifetime the app must manage.
+//      For example one can set width by calling Set(NVSDK_NGX_Parameter_Denoiser_Width,100) or
+//      provide CUDA buffer pointer by calling Set(NVSDK_NGX_Parameter_Denoiser_Color,cudaBuffer)
+//      For more details please see sample code.
+//      Parameter maps output by NVSDK_NGX_AllocateParameters must NOT be freed using
+//      the free/delete operator; to free a parameter map 
+//      output by NVSDK_NGX_AllocateParameters, NVSDK_NGX_DestroyParameters should be used.
+//      Unlike with NVSDK_NGX_GetParameters, parameter maps allocated with NVSDK_NGX_AllocateParameters
+//      must be destroyed by the app using NVSDK_NGX_DestroyParameters.
+//      Also unlike with NVSDK_NGX_GetParameters, parameter maps output by NVSDK_NGX_AllocateParameters
+//      do not come pre-populated with NGX capabilities and available features.
+//      To create a new parameter map pre-populated with such information, NVSDK_NGX_GetCapabilityParameters
+//      should be used.
+//      This function may return NVSDK_NGX_Result_FAIL_OutOfDate if an older driver, which
+//      does not support this API call is being used. In such a case, NVSDK_NGX_GetParameters
+//      may be used as a fallback.
+//      This function may only be called after a successful call into NVSDK_NGX_Init.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_AllocateParameters(NVSDK_NGX_Parameter** OutParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_AllocateParameters(NVSDK_NGX_Parameter** OutParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_AllocateParameters(NVSDK_NGX_Parameter** OutParameters);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetCapabilityParameters
+// ----------------------------------------------------------
+//
+// OutParameters:
+//      The parameters interface populated with NGX and feature capabilities
+//
+// DESCRIPTION:
+//      This interface allows the app to create a new parameter map
+//      pre-populated with NGX capabilities and available features.
+//      The output parameter map can also be used for any purpose
+//      parameter maps output by NVSDK_NGX_AllocateParameters can be used for
+//      but it is not recommended to use NVSDK_NGX_GetCapabilityParameters
+//      unless querying NGX capabilities and available features
+//      due to the overhead associated with pre-populating the parameter map.
+//      Parameter maps output by NVSDK_NGX_GetCapabilityParameters must NOT be freed using
+//      the free/delete operator; to free a parameter map
+//      output by NVSDK_NGX_GetCapabilityParameters, NVSDK_NGX_DestroyParameters should be used.
+//      Unlike with NVSDK_NGX_GetParameters, parameter maps allocated with NVSDK_NGX_GetCapabilityParameters
+//      must be destroyed by the app using NVSDK_NGX_DestroyParameters.
+//      This function may return NVSDK_NGX_Result_FAIL_OutOfDate if an older driver, which
+//      does not support this API call is being used. This function may only be called
+//      after a successful call into NVSDK_NGX_Init.
+//      If NVSDK_NGX_GetCapabilityParameters fails with NVSDK_NGX_Result_FAIL_OutOfDate,
+//      NVSDK_NGX_GetParameters may be used as a fallback, to get a parameter map pre-populated
+//      with NGX capabilities and available features.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_GetCapabilityParameters(NVSDK_NGX_Parameter** OutParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_GetCapabilityParameters(NVSDK_NGX_Parameter** OutParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_GetCapabilityParameters(NVSDK_NGX_Parameter** OutParameters);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_DestroyParameters
+// ----------------------------------------------------------
+//
+// InParameters:
+//      The parameters interface to be destroyed
+//
+// DESCRIPTION:
+//      This interface allows the app to destroy the parameter map passed in. Once
+//      NVSDK_NGX_DestroyParameters is called on a parameter map, it
+//      must not be used again.
+//      NVSDK_NGX_DestroyParameters must not be called on any parameter map returned
+//      by NVSDK_NGX_GetParameters; NGX will manage the lifetime of those
+//      parameter maps.
+//      This function may return NVSDK_NGX_Result_FAIL_OutOfDate if an older driver, which
+//      does not support this API call is being used. This function may only be called
+//      after a successful call into NVSDK_NGX_Init.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_DestroyParameters(NVSDK_NGX_Parameter* InParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_DestroyParameters(NVSDK_NGX_Parameter* InParameters);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_DestroyParameters(NVSDK_NGX_Parameter* InParameters);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetScratchBufferSize
+// ----------------------------------------------------------
+//
+// InFeatureId:
+//      AI feature in question
+//
+// InParameters:
+//      Parameters used by the feature to help estimate scratch buffer size
+//
+// OutSizeInBytes:
+//      Number of bytes needed for the scratch buffer for the specified feature.
+//
+// DESCRIPTION:
+//      SDK needs a buffer of a certain size provided by the client in
+//      order to initialize AI feature. Once feature is no longer
+//      needed buffer can be released. It is safe to reuse the same
+//      scratch buffer for different features as long as minimum size
+//      requirement is met for all features. Please note that some
+//      features might not need a scratch buffer so return size of 0
+//      is completely valid.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_GetScratchBufferSize(NVSDK_NGX_Feature InFeatureId, const NVSDK_NGX_Parameter *InParameters, size_t *OutSizeInBytes);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_GetScratchBufferSize(NVSDK_NGX_Feature InFeatureId, const NVSDK_NGX_Parameter *InParameters, size_t *OutSizeInBytes);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_GetScratchBufferSize(NVSDK_NGX_Feature InFeatureId, const NVSDK_NGX_Parameter *InParameters, size_t *OutSizeInBytes);
+
+/////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_CreateFeature
+// -------------------------------------
+//
+// InCmdList:[d3d12 only]
+//      Command list to use to execute GPU commands. Must be:
+//      - Open and recording 
+//      - With node mask including the device provided in NVSDK_NGX_D3D12_Init
+//      - Execute on non-copy command queue.
+// InDevCtx: [d3d11 only]
+//      Device context to use to execute GPU commands
+//
+// InFeatureID:
+//      AI feature to initialize
+//
+// InParameters:
+//      List of parameters 
+// 
+// OutHandle:
+//      Handle which uniquely identifies the feature. If feature with
+//      provided parameters already exists the "already exists" error code is returned.
+//
+// DESCRIPTION:
+//      Each feature needs to be created before it can be used. 
+//      Refer to the sample code to find out which input parameters
+//      are needed to create specific feature.
+//
+#if defined(NGX_SNIPPET_BUILD)
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_CreateFeature(ID3D11DeviceContext *InDevCtx, NVSDK_NGX_Feature InFeatureID, const NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_CreateFeature(ID3D12GraphicsCommandList *InCmdList, NVSDK_NGX_Feature InFeatureID, const NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_CreateFeature(NVSDK_NGX_Feature InFeatureID, const NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+#else
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_CreateFeature(ID3D11DeviceContext *InDevCtx, NVSDK_NGX_Feature InFeatureID, NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_CreateFeature(ID3D12GraphicsCommandList *InCmdList, NVSDK_NGX_Feature InFeatureID, NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_CreateFeature(NVSDK_NGX_Feature InFeatureID, const NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+
+#endif // defined(NGX_SNIPPET_BUILD)
+
+/////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Release
+// -------------------------------------
+// 
+// InHandle:
+//      Handle to feature to be released
+//
+// DESCRIPTION:
+//      Releases feature with a given handle.
+//      Handles are not reference counted so
+//      after this call it is invalid to use provided handle.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_ReleaseFeature(NVSDK_NGX_Handle *InHandle);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_ReleaseFeature(NVSDK_NGX_Handle *InHandle);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_ReleaseFeature(NVSDK_NGX_Handle *InHandle);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetFeatureRequirements
+// -------------------------------------
+// Adapter:
+//      Physical adapter Information
+//
+// FeatureDiscoveryInfo:
+//      Contains information common to all NGX Features - required for Feature discovery, Initialization and Logging.
+//
+// DESCRIPTION:
+//      Utility function used to identify system requirements to support a given NGX Feature
+//      on a system given its display device subsytem adapter information that will be subsequently used for creating the graphics device.
+//      The output parameter OutSupported will be populated with requirements and are valid if and only if NVSDK_NGX_Result_Success is returned:
+//          OutSupported::FeatureSupported: bitfield of bit shifted values specified in NVSDK_NGX_Feature_Support_Result. 0 if Feature is Supported.
+//          OutSupported::MinHWArchitecture: Returned HW Architecture value corresponding to NV_GPU_ARCHITECTURE_ID values defined in NvAPI GPU Framework.
+//          OutSupported::MinOSVersion: Value corresponding to minimum OS version required for NGX Feature Support
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_GetFeatureRequirements(IDXGIAdapter *Adapter,
+                                                                                 const NVSDK_NGX_FeatureDiscoveryInfo *FeatureDiscoveryInfo,
+                                                                                 NVSDK_NGX_FeatureRequirement *OutSupported);
+ 
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_GetFeatureRequirements(IDXGIAdapter *Adapter,
+                                                                                 const NVSDK_NGX_FeatureDiscoveryInfo *FeatureDiscoveryInfo,
+                                                                                 NVSDK_NGX_FeatureRequirement *OutSupported);
+
+/////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_EvaluateFeature
+// -------------------------------------
+//
+// InCmdList:[d3d12 only]
+//      Command list to use to execute GPU commands. Must be:
+//      - Open and recording 
+//      - With node mask including the device provided in NVSDK_NGX_D3D12_Init
+//      - Execute on non-copy command queue.
+// InDevCtx: [d3d11 only]
+//      Device context to use to execute GPU commands
+//
+// InFeatureHandle:
+//      Handle representing feature to be evaluated
+// 
+// InParameters:
+//      List of parameters required to evaluate feature
+//
+// InCallback:
+//      Optional callback for features which might take longer
+//      to execute. If specified SDK will call it with progress
+//      values in range 0.0f - 1.0f
+//
+// DESCRIPTION:
+//      Evaluates given feature using the provided parameters and
+//      pre-trained NN. Please note that for most features
+//      it can be beneficial to pass as many input buffers and parameters
+//      as possible (for example provide all render targets like color, albedo, normals, depth etc)
+//
+
+#ifdef __cplusplus
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_ProgressCallback)(float InCurrentProgress, bool &OutShouldCancel);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_EvaluateFeature(ID3D11DeviceContext *InDevCtx, const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback InCallback = NULL);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_EvaluateFeature(ID3D12GraphicsCommandList *InCmdList, const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback InCallback = NULL);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_EvaluateFeature(const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback InCallback = NULL);
+#endif
+
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_ProgressCallback_C)(float InCurrentProgress, bool *OutShouldCancel);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D11_EvaluateFeature_C(ID3D11DeviceContext *InDevCtx, const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback_C InCallback);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_D3D12_EvaluateFeature_C(ID3D12GraphicsCommandList *InCmdList, const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback_C InCallback);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_CUDA_EvaluateFeature_C(const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback_C InCallback);
+
+#if defined(NGX_SNIPPET_BUILD)
+// No NGX Core <---> Snippet interfaces
+#else
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_UpdateFeature(const NVSDK_NGX_Application_Identifier *ApplicationId, const NVSDK_NGX_Feature FeatureID);
+#endif // defined(NGX_SNIPPET_BUILD)
+
+// NGX return-code conversion-to-string utility only as a helper for debugging/logging - not for official use.
+const wchar_t* NVSDK_CONV GetNGXResultAsString(NVSDK_NGX_Result InNGXResult);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // #define NVSDK_NGX_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_defs.h

@@ -0,0 +1,792 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2018-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#ifndef NVSDK_NGX_DEFS_H
+#define NVSDK_NGX_DEFS_H
+#pragma once
+
+#ifndef __cplusplus
+#include <stddef.h> // For size_t
+#include <stdbool.h>
+#include <wchar.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef __cplusplus
+#if defined(NVSDK_NGX) && defined(_WIN32)
+#define NVSDK_NGX_API extern "C" __declspec(dllexport)
+#else
+#define NVSDK_NGX_API extern "C"
+#endif
+#else
+#if defined(NVSDK_NGX) && defined(_WIN32)
+#define NVSDK_NGX_API __declspec(dllexport)
+#else
+#define NVSDK_NGX_API
+#endif
+#endif
+
+#ifdef __GNUC__
+#define NVSDK_CONV
+#else
+#define NVSDK_CONV __cdecl
+#endif
+
+#define NVSDK_NGX_ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0]))
+    
+//  Version Notes:
+//      Version 0x0000014:
+//          * Added a logging callback that the app may pass in on init
+//          * Added ability for the app to override the logging level
+//      Version 0x0000015:
+//          * Support multiple GPUs (bug 3270533)
+#define NVSDK_NGX_VERSION_API_MACRO 0x0000015  // NGX_VERSION_DOT 1.5.0
+
+typedef unsigned long long AppId;
+
+typedef enum NVSDK_NGX_DLSS_Hint_Render_Preset
+{
+    NVSDK_NGX_DLSS_Hint_Render_Preset_Default,     // default behavior, may or may not change after OTA
+    NVSDK_NGX_DLSS_Hint_Render_Preset_A,
+    NVSDK_NGX_DLSS_Hint_Render_Preset_B,
+    NVSDK_NGX_DLSS_Hint_Render_Preset_C,
+    NVSDK_NGX_DLSS_Hint_Render_Preset_D,
+    NVSDK_NGX_DLSS_Hint_Render_Preset_E,
+    NVSDK_NGX_DLSS_Hint_Render_Preset_F,
+    NVSDK_NGX_DLSS_Hint_Render_Preset_G,           // do not use, reverts to default behavior
+    NVSDK_NGX_DLSS_Hint_Render_Preset_H_Reserved,  // do not use, reverts to default behavior
+    NVSDK_NGX_DLSS_Hint_Render_Preset_I_Reserved,  // do not use, reverts to default behavior
+    NVSDK_NGX_DLSS_Hint_Render_Preset_J,
+    NVSDK_NGX_DLSS_Hint_Render_Preset_K,           // do not use, reverts to default behavior
+    NVSDK_NGX_DLSS_Hint_Render_Preset_L,           // do not use, reverts to default behavior
+    NVSDK_NGX_DLSS_Hint_Render_Preset_M,           // do not use, reverts to default behavior
+    NVSDK_NGX_DLSS_Hint_Render_Preset_N,           // do not use, reverts to default behavior
+    NVSDK_NGX_DLSS_Hint_Render_Preset_O,           // do not use, reverts to default behavior
+} NVSDK_NGX_DLSS_Hint_Render_Preset;
+
+typedef struct NVSDK_NGX_FeatureCommonInfo_Internal NVSDK_NGX_FeatureCommonInfo_Internal;
+
+typedef enum NVSDK_NGX_Version { NVSDK_NGX_Version_API = NVSDK_NGX_VERSION_API_MACRO } NVSDK_NGX_Version;
+
+typedef enum NVSDK_NGX_Result
+{
+    NVSDK_NGX_Result_Success = 0x1,
+
+    NVSDK_NGX_Result_Fail = 0xBAD00000,
+
+    // Feature is not supported on current hardware
+    NVSDK_NGX_Result_FAIL_FeatureNotSupported = NVSDK_NGX_Result_Fail | 1,
+
+    // Platform error - for example - check d3d12 debug layer log for more information
+    NVSDK_NGX_Result_FAIL_PlatformError = NVSDK_NGX_Result_Fail | 2,
+
+    // Feature with given parameters already exists
+    NVSDK_NGX_Result_FAIL_FeatureAlreadyExists = NVSDK_NGX_Result_Fail | 3,
+
+    // Feature with provided handle does not exist
+    NVSDK_NGX_Result_FAIL_FeatureNotFound = NVSDK_NGX_Result_Fail | 4,
+
+    // Invalid parameter was provided
+    NVSDK_NGX_Result_FAIL_InvalidParameter = NVSDK_NGX_Result_Fail | 5,
+
+    // Provided buffer is too small, please use size provided by NVSDK_NGX_GetScratchBufferSize
+    NVSDK_NGX_Result_FAIL_ScratchBufferTooSmall = NVSDK_NGX_Result_Fail | 6,
+
+    // SDK was not initialized properly
+    NVSDK_NGX_Result_FAIL_NotInitialized = NVSDK_NGX_Result_Fail | 7,
+
+    //  Unsupported format used for input/output buffers
+    NVSDK_NGX_Result_FAIL_UnsupportedInputFormat = NVSDK_NGX_Result_Fail | 8,
+
+    // Feature input/output needs RW access (UAV) (d3d11/d3d12 specific)
+    NVSDK_NGX_Result_FAIL_RWFlagMissing = NVSDK_NGX_Result_Fail | 9,
+
+    // Feature was created with specific input but none is provided at evaluation
+    NVSDK_NGX_Result_FAIL_MissingInput = NVSDK_NGX_Result_Fail | 10,
+
+    // Feature is not available on the system
+    NVSDK_NGX_Result_FAIL_UnableToInitializeFeature = NVSDK_NGX_Result_Fail | 11,
+
+    // NGX system libraries are old and need an update
+    NVSDK_NGX_Result_FAIL_OutOfDate = NVSDK_NGX_Result_Fail | 12,
+
+    // Feature requires more GPU memory than it is available on system
+    NVSDK_NGX_Result_FAIL_OutOfGPUMemory = NVSDK_NGX_Result_Fail | 13,
+
+    // Format used in input buffer(s) is not supported by feature
+    NVSDK_NGX_Result_FAIL_UnsupportedFormat = NVSDK_NGX_Result_Fail | 14,
+
+    // Path provided in InApplicationDataPath cannot be written to
+    NVSDK_NGX_Result_FAIL_UnableToWriteToAppDataPath = NVSDK_NGX_Result_Fail | 15,
+
+    // Unsupported parameter was provided (e.g. specific scaling factor is unsupported)
+    NVSDK_NGX_Result_FAIL_UnsupportedParameter = NVSDK_NGX_Result_Fail | 16,
+
+    // The feature or application was denied (contact NVIDIA for further details)
+    NVSDK_NGX_Result_FAIL_Denied = NVSDK_NGX_Result_Fail | 17,
+
+    // The feature or functionality is not implemented
+    NVSDK_NGX_Result_FAIL_NotImplemented = NVSDK_NGX_Result_Fail | 18,
+} NVSDK_NGX_Result;
+
+#define NVSDK_NGX_SUCCEED(value) (((value) & 0xFFF00000) != NVSDK_NGX_Result_Fail)
+#define NVSDK_NGX_FAILED(value) (((value) & 0xFFF00000) == NVSDK_NGX_Result_Fail)
+
+typedef enum NVSDK_NGX_Feature
+{
+    NVSDK_NGX_Feature_Reserved0             = 0,
+
+    NVSDK_NGX_Feature_SuperSampling         = 1,
+
+    NVSDK_NGX_Feature_InPainting            = 2,
+
+    NVSDK_NGX_Feature_ImageSuperResolution  = 3,
+
+    NVSDK_NGX_Feature_SlowMotion            = 4,
+
+    NVSDK_NGX_Feature_VideoSuperResolution  = 5,
+
+    NVSDK_NGX_Feature_Reserved1             = 6,
+
+    NVSDK_NGX_Feature_Reserved2             = 7,
+
+    NVSDK_NGX_Feature_Reserved3             = 8,
+
+    NVSDK_NGX_Feature_ImageSignalProcessing = 9,
+
+    NVSDK_NGX_Feature_DeepResolve           = 10,
+
+    NVSDK_NGX_Feature_FrameGeneration       = 11,
+
+    NVSDK_NGX_Feature_DeepDVC               = 12,
+
+    NVSDK_NGX_Feature_RayReconstruction     = 13,
+
+    NVSDK_NGX_Feature_Reserved14            = 14,
+
+    NVSDK_NGX_Feature_Reserved15            = 15,
+
+    NVSDK_NGX_Feature_Reserved16            = 16,
+
+    // New features go here
+    NVSDK_NGX_Feature_Count,
+
+    // These members are not strictly NGX features, but are
+    // components of the NGX system, and it may sometimes
+    // be useful to identify them using the same enum
+    NVSDK_NGX_Feature_Reserved_SDK          = 32764,
+
+    NVSDK_NGX_Feature_Reserved_Core         = 32765,
+
+    NVSDK_NGX_Feature_Reserved_Unknown      = 32766
+} NVSDK_NGX_Feature;
+
+//TODO create grayscale format (R32F?)
+typedef enum NVSDK_NGX_Buffer_Format
+{
+    NVSDK_NGX_Buffer_Format_Unknown,
+    NVSDK_NGX_Buffer_Format_RGB8UI,
+    NVSDK_NGX_Buffer_Format_RGB16F,
+    NVSDK_NGX_Buffer_Format_RGB32F,
+    NVSDK_NGX_Buffer_Format_RGBA8UI,
+    NVSDK_NGX_Buffer_Format_RGBA16F,
+    NVSDK_NGX_Buffer_Format_RGBA32F,
+} NVSDK_NGX_Buffer_Format;
+
+typedef enum NVSDK_NGX_PerfQuality_Value
+{
+    NVSDK_NGX_PerfQuality_Value_MaxPerf,
+    NVSDK_NGX_PerfQuality_Value_Balanced,
+    NVSDK_NGX_PerfQuality_Value_MaxQuality,
+    // Extended PerfQuality modes
+    NVSDK_NGX_PerfQuality_Value_UltraPerformance,
+    NVSDK_NGX_PerfQuality_Value_UltraQuality,
+    NVSDK_NGX_PerfQuality_Value_DLAA,
+} NVSDK_NGX_PerfQuality_Value;
+
+typedef enum NVSDK_NGX_RTX_Value
+{
+    NVSDK_NGX_RTX_Value_Off,
+    NVSDK_NGX_RTX_Value_On,
+} NVSDK_NGX_RTX_Value;
+
+typedef enum NVSDK_NGX_DLSS_Mode
+{
+    NVSDK_NGX_DLSS_Mode_Off,        // use existing in-engine AA + upscale solution
+    NVSDK_NGX_DLSS_Mode_DLSS_DLISP,
+    NVSDK_NGX_DLSS_Mode_DLISP_Only, // use existing in-engine AA solution
+    NVSDK_NGX_DLSS_Mode_DLSS,       // DLSS will apply AA and upsample at the same time
+} NVSDK_NGX_DLSS_Mode;
+
+typedef struct NVSDK_NGX_Handle { unsigned int Id; } NVSDK_NGX_Handle;
+
+typedef enum NVSDK_NGX_GPU_Arch
+{
+    NVSDK_NGX_GPU_Arch_NotSupported = 0,
+
+    // Match NvAPI's NV_GPU_ARCHITECTURE_ID values for GV100 and TU100 for
+    // backwards compatibility with snippets built against NvAPI
+    NVSDK_NGX_GPU_Arch_Volta        = 0x0140,
+    NVSDK_NGX_GPU_Arch_Turing       = 0x0160,
+    NVSDK_NGX_GPU_Arch_Ampere       = 0x0170,
+    NVSDK_NGX_GPU_Arch_Ada          = 0x0190,
+    NVSDK_NGX_GPU_Arch_Hopper       = 0x0180,
+    NVSDK_NGX_GPU_Arch_Blackwell    = 0x01A0,
+    NVSDK_NGX_GPU_Arch_Blackwell2   = 0x01B0,
+
+    // Presumably something newer
+    NVSDK_NGX_GPU_Arch_Unknown      = 0x7FFFFFF
+} NVSDK_NGX_GPU_Arch;
+
+typedef enum NVSDK_NGX_DLSS_Feature_Flags
+{
+    NVSDK_NGX_DLSS_Feature_Flags_IsInvalid      = 1 << 31,
+
+    NVSDK_NGX_DLSS_Feature_Flags_None           = 0,
+    NVSDK_NGX_DLSS_Feature_Flags_IsHDR          = 1 << 0,
+    NVSDK_NGX_DLSS_Feature_Flags_MVLowRes       = 1 << 1,
+    NVSDK_NGX_DLSS_Feature_Flags_MVJittered     = 1 << 2,
+    NVSDK_NGX_DLSS_Feature_Flags_DepthInverted  = 1 << 3,
+    NVSDK_NGX_DLSS_Feature_Flags_Reserved_0     = 1 << 4,
+    NVSDK_NGX_DLSS_Feature_Flags_DoSharpening   = 1 << 5,
+    NVSDK_NGX_DLSS_Feature_Flags_AutoExposure   = 1 << 6,
+    NVSDK_NGX_DLSS_Feature_Flags_AlphaUpscaling = 1 << 7,
+} NVSDK_NGX_DLSS_Feature_Flags;
+
+typedef enum NVSDK_NGX_ToneMapperType
+{
+    NVSDK_NGX_TONEMAPPER_STRING = 0,
+    NVSDK_NGX_TONEMAPPER_REINHARD,
+    NVSDK_NGX_TONEMAPPER_ONEOVERLUMA,
+    NVSDK_NGX_TONEMAPPER_ACES,
+    NVSDK_NGX_TONEMAPPERTYPE_NUM
+} NVSDK_NGX_ToneMapperType;
+
+typedef enum NVSDK_NGX_GBufferType
+{
+    NVSDK_NGX_GBUFFER_ALBEDO = 0,
+    NVSDK_NGX_GBUFFER_ROUGHNESS,
+    NVSDK_NGX_GBUFFER_METALLIC,
+    NVSDK_NGX_GBUFFER_SPECULAR,
+    NVSDK_NGX_GBUFFER_SUBSURFACE,
+    NVSDK_NGX_GBUFFER_NORMALS,
+    NVSDK_NGX_GBUFFER_SHADINGMODELID,  /* unique identifier for drawn object or how the object is drawn */
+    NVSDK_NGX_GBUFFER_MATERIALID, /* unique identifier for material */
+    NVSDK_NGX_GBUFFER_SPECULAR_ALBEDO,
+    NVSDK_NGX_GBUFFER_INDIRECT_ALBEDO,
+    NVSDK_NGX_GBUFFER_SPECULAR_MVEC,
+    NVSDK_NGX_GBUFFER_DISOCCL_MASK,
+    NVSDK_NGX_GBUFFER_EMISSIVE,
+    NVSDK_NGX_GBUFFERTYPE_NUM = 16
+} NVSDK_NGX_GBufferType;
+
+typedef struct NVSDK_NGX_Coordinates
+{
+    unsigned int X;
+    unsigned int Y;
+} NVSDK_NGX_Coordinates;
+
+typedef struct NVSDK_NGX_Dimensions
+{
+    unsigned int Width;
+    unsigned int Height;
+} NVSDK_NGX_Dimensions;
+
+typedef struct NVSDK_NGX_PrecisionInfo
+{
+    // 1 if and only if the associated resource buffer is considered low-precision
+    unsigned int IsLowPrecision;
+
+    // Bias and Scale values, such that `hi = lo * Scale + Bias`
+    float        Bias;
+    float        Scale;
+} NVSDK_NGX_PrecisionInfo;
+
+typedef struct NVSDK_NGX_PathListInfo
+{
+    // Pointer to a const string
+    wchar_t const* const* Path;
+    // Path-list length
+    unsigned int Length;
+} NVSDK_NGX_PathListInfo;
+
+typedef enum NVSDK_NGX_Logging_Level
+{
+    NVSDK_NGX_LOGGING_LEVEL_OFF = 0,
+    NVSDK_NGX_LOGGING_LEVEL_ON,
+    NVSDK_NGX_LOGGING_LEVEL_VERBOSE,
+    NVSDK_NGX_LOGGING_LEVEL_NUM
+} NVSDK_NGX_Logging_Level;
+
+// A logging callback provided by the app to allow piping log lines back to the app.
+// Please take careful note of the signature and calling convention.
+// The callback must be able to be called from any thread.
+// It must also be fully thread-safe and any number of threads may call into it concurrently.
+// It must fully process message by the time it returns, and there is no guarantee that
+// message will still be valid or allocated after it returns.
+// message will be a null-terminated string and may contain multibyte characters.
+#if defined(__GNUC__) || defined(__clang__)
+typedef void NVSDK_CONV(*NVSDK_NGX_AppLogCallback)(const char* message, NVSDK_NGX_Logging_Level loggingLevel, NVSDK_NGX_Feature sourceComponent);
+#else
+typedef void(NVSDK_CONV* NVSDK_NGX_AppLogCallback)(const char* message, NVSDK_NGX_Logging_Level loggingLevel, NVSDK_NGX_Feature sourceComponent);
+#endif
+
+typedef struct NVSDK_NGX_LoggingInfo
+{
+    // Fields below were introduced in SDK version 0x0000014
+
+    // App-provided logging callback
+    NVSDK_NGX_AppLogCallback LoggingCallback;
+
+    // The minimum logging level to use. If this is higher
+    // than the logging level otherwise configured, this will override
+    // that logging level. Otherwise, that logging level will be used.
+    NVSDK_NGX_Logging_Level MinimumLoggingLevel;
+
+    // Whether or not to disable writing log lines to sinks other than the app log callback. This
+    // may be useful if the app provides a logging callback. LoggingCallback must be non-null and point
+    // to a valid logging callback if this is set to true.
+    bool DisableOtherLoggingSinks;
+
+} NVSDK_NGX_LoggingInfo;
+
+typedef struct NVSDK_NGX_FeatureCommonInfo
+{
+    // List of all paths in descending order of search sequence to locate a feature dll in, other than the default path - application folder.
+    NVSDK_NGX_PathListInfo PathListInfo;
+    // Used internally by NGX
+    NVSDK_NGX_FeatureCommonInfo_Internal* InternalData; // Introduced in SDK version 0x0000013
+
+    // Fields below were introduced in SDK version 0x0000014
+    NVSDK_NGX_LoggingInfo LoggingInfo;
+} NVSDK_NGX_FeatureCommonInfo;
+
+typedef enum NVSDK_NGX_Resource_VK_Type
+{
+    NVSDK_NGX_RESOURCE_VK_TYPE_VK_IMAGEVIEW,
+    NVSDK_NGX_RESOURCE_VK_TYPE_VK_BUFFER
+} NVSDK_NGX_Resource_VK_Type;
+
+typedef enum NVSDK_NGX_Opt_Level
+{
+    NVSDK_NGX_OPT_LEVEL_UNDEFINED = 0,
+    NVSDK_NGX_OPT_LEVEL_DEBUG = 20,
+    NVSDK_NGX_OPT_LEVEL_DEVELOP = 30,
+    NVSDK_NGX_OPT_LEVEL_RELEASE = 40
+} NVSDK_NGX_Opt_Level;
+
+typedef enum NVSDK_NGX_EngineType
+{
+    NVSDK_NGX_ENGINE_TYPE_CUSTOM = 0,
+    NVSDK_NGX_ENGINE_TYPE_UNREAL,
+    NVSDK_NGX_ENGINE_TYPE_UNITY,
+    NVSDK_NGX_ENGINE_TYPE_OMNIVERSE,
+    NVSDK_NGX_ENGINE_COUNT
+} NVSDK_NGX_EngineType;
+
+typedef enum NVSDK_NGX_Feature_Support_Result
+{
+    NVSDK_NGX_FeatureSupportResult_Supported = 0,
+    NVSDK_NGX_FeatureSupportResult_CheckNotPresent = 1,
+    NVSDK_NGX_FeatureSupportResult_DriverVersionUnsupported = 2,
+    NVSDK_NGX_FeatureSupportResult_AdapterUnsupported = 4,
+    NVSDK_NGX_FeatureSupportResult_OSVersionBelowMinimumSupported = 8,
+    NVSDK_NGX_FeatureSupportResult_NotImplemented = 16
+} NVSDK_NGX_Feature_Support_Result;
+
+typedef enum NVSDK_NGX_Application_Identifier_Type
+{
+    NVSDK_NGX_Application_Identifier_Type_Application_Id = 0,
+    NVSDK_NGX_Application_Identifier_Type_Project_Id = 1,
+} NVSDK_NGX_Application_Identifier_Type;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_ProjectIdDescription
+// -------------------------------------
+// Contains information to identify an application built using a common rendering engine (list of supported rendering engines is defined in NVSDK_NGX_EngineType).
+// Should only be used by plugins for the supported rendering engines, unless using NVSDK_NGX_ENGINE_TYPE_CUSTOM as the engine type.
+//
+// ProjectId
+//      Unique Id provided by the rendering engine used
+//
+// EngineType
+//      Rendering engine used by the application / plugin.
+//      Use NVSDK_NGX_ENGINE_TYPE_CUSTOM if the specific engine type is not supported explicitly
+//
+// EngineVersion
+//      Version number of the rendering engine used by the application / plugin.
+//
+// DESCRIPTION:
+// Contains information to identify an application built using a common rendering engine (list of supported rendering engines is defined in NVSDK_NGX_EngineType).
+// Should only be used by plugins for the supported rendering engines, unless using NVSDK_NGX_ENGINE_TYPE_CUSTOM as the engine type.
+//
+typedef struct NVSDK_NGX_ProjectIdDescription
+{
+    const char* ProjectId;
+    NVSDK_NGX_EngineType EngineType;
+    const char* EngineVersion;
+} NVSDK_NGX_ProjectIdDescription;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Application_Identifier
+// -------------------------------------
+// Identifier for each application. Required for over the air updates (both optional and mandatory)
+// as well as for app-specific customizations for features like DLSS-SR
+//
+// IdentifierType:
+//      Whether using a NVSDK_NGX_ProjectIdDescription or an Unique Application Identifier
+//
+// ProjectDesc:
+//      If using NVSDK_NGX_ProjectIdDescription, this contains the project ID and engine info required to identify this app
+//
+// ApplicationIdentifier:
+//      If not using NVSDK_NGX_ProjectIdDescription, this contains an ID provided by NVIDIA for this app
+//      If your NVIDIA contact did not provide you an ID for this purpose, use ProjectDesc with NVSDK_NGX_ENGINE_TYPE_CUSTOM as the engine type
+//
+typedef struct NVSDK_NGX_Application_Identifier
+{
+    NVSDK_NGX_Application_Identifier_Type IdentifierType;
+    union v {
+        NVSDK_NGX_ProjectIdDescription ProjectDesc;
+        unsigned long long ApplicationId;
+    } v;
+} NVSDK_NGX_Application_Identifier;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_FeatureDiscoveryInfo
+// -------------------------------------
+// Contains information common to all features, used by NGX in determining requested Feature availability
+//
+// InSDKVersion:
+//      API Struct version number
+//
+// FeatureID
+//      Valid NVSDK_NGX_Feature enum corresponding to DLSS v3 Feature which is being queried for availability
+//
+// ApplicationId
+//      Unique Id provided by NVIDIA corresponding to a particular Application or alternatively custom Id set by Engine
+//
+// InApplicationDataPath:
+//      Folder to store logs and other temporary files (write access required),
+//      Normally this would be a location in Documents or ProgramData.
+//
+// FeatureInfo:
+//      Contains information common to all features, presently only a list of all paths
+//      feature dlls can be located in, other than the default path - application directory.
+//
+typedef struct NVSDK_NGX_FeatureDiscoveryInfo
+{
+    NVSDK_NGX_Version SDKVersion;
+    NVSDK_NGX_Feature FeatureID;
+    NVSDK_NGX_Application_Identifier Identifier;
+    const wchar_t* ApplicationDataPath;
+    const NVSDK_NGX_FeatureCommonInfo* FeatureInfo;
+} NVSDK_NGX_FeatureDiscoveryInfo;
+
+typedef struct NVSDK_NGX_FeatureRequirement
+{
+    // Bitfield of bit shifted values specified in NVSDK_NGX_Feature_Support_Result. 0 if Feature is Supported.
+    NVSDK_NGX_Feature_Support_Result FeatureSupported;
+
+    // Returned HW Architecture value corresponding to NV_GPU_ARCHITECTURE_ID values defined in NvAPI GPU Framework.
+    unsigned int MinHWArchitecture;
+
+    // Value corresponding to minimum OS version required for NGX Feature Support
+    char MinOSVersion[255];
+} NVSDK_NGX_FeatureRequirement;
+
+// Read-only parameters provided by NGX
+#define NVSDK_NGX_EParameter_Reserved00                           "#\x00"
+#define NVSDK_NGX_EParameter_SuperSampling_Available              "#\x01"
+#define NVSDK_NGX_EParameter_InPainting_Available                 "#\x02"
+#define NVSDK_NGX_EParameter_ImageSuperResolution_Available       "#\x03"
+#define NVSDK_NGX_EParameter_SlowMotion_Available                 "#\x04"
+#define NVSDK_NGX_EParameter_VideoSuperResolution_Available       "#\x05"
+#define NVSDK_NGX_EParameter_Reserved06                           "#\x06"
+#define NVSDK_NGX_EParameter_Reserved07                           "#\x07"
+#define NVSDK_NGX_EParameter_Reserved08                           "#\x08"
+#define NVSDK_NGX_EParameter_ImageSignalProcessing_Available      "#\x09"
+#define NVSDK_NGX_EParameter_ImageSuperResolution_ScaleFactor_2_1 "#\x0a"
+#define NVSDK_NGX_EParameter_ImageSuperResolution_ScaleFactor_3_1 "#\x0b"
+#define NVSDK_NGX_EParameter_ImageSuperResolution_ScaleFactor_3_2 "#\x0c"
+#define NVSDK_NGX_EParameter_ImageSuperResolution_ScaleFactor_4_3 "#\x0d"
+#define NVSDK_NGX_EParameter_NumFrames           "#\x0e"
+#define NVSDK_NGX_EParameter_Scale               "#\x0f"
+#define NVSDK_NGX_EParameter_Width               "#\x10"
+#define NVSDK_NGX_EParameter_Height              "#\x11"
+#define NVSDK_NGX_EParameter_OutWidth            "#\x12"
+#define NVSDK_NGX_EParameter_OutHeight           "#\x13"
+#define NVSDK_NGX_EParameter_Sharpness           "#\x14"
+#define NVSDK_NGX_EParameter_Scratch             "#\x15"
+#define NVSDK_NGX_EParameter_Scratch_SizeInBytes "#\x16"
+#define NVSDK_NGX_EParameter_EvaluationNode      "#\x17" // valid since API 0x13 (replaced a deprecated param)
+#define NVSDK_NGX_EParameter_Input1              "#\x18"
+#define NVSDK_NGX_EParameter_Input1_Format       "#\x19"
+#define NVSDK_NGX_EParameter_Input1_SizeInBytes  "#\x1a"
+#define NVSDK_NGX_EParameter_Input2              "#\x1b"
+#define NVSDK_NGX_EParameter_Input2_Format       "#\x1c"
+#define NVSDK_NGX_EParameter_Input2_SizeInBytes  "#\x1d"
+#define NVSDK_NGX_EParameter_Color               "#\x1e"
+#define NVSDK_NGX_EParameter_Color_Format        "#\x1f"
+#define NVSDK_NGX_EParameter_Color_SizeInBytes   "#\x20"
+#define NVSDK_NGX_EParameter_Albedo              "#\x21"
+#define NVSDK_NGX_EParameter_Output              "#\x22"
+#define NVSDK_NGX_EParameter_Output_Format       "#\x23"
+#define NVSDK_NGX_EParameter_Output_SizeInBytes  "#\x24"
+#define NVSDK_NGX_EParameter_Reset               "#\x25"
+#define NVSDK_NGX_EParameter_BlendFactor         "#\x26"
+#define NVSDK_NGX_EParameter_MotionVectors       "#\x27"
+#define NVSDK_NGX_EParameter_Rect_X              "#\x28"
+#define NVSDK_NGX_EParameter_Rect_Y              "#\x29"
+#define NVSDK_NGX_EParameter_Rect_W              "#\x2a"
+#define NVSDK_NGX_EParameter_Rect_H              "#\x2b"
+#define NVSDK_NGX_EParameter_MV_Scale_X          "#\x2c"
+#define NVSDK_NGX_EParameter_MV_Scale_Y          "#\x2d"
+#define NVSDK_NGX_EParameter_Model               "#\x2e"
+#define NVSDK_NGX_EParameter_Format              "#\x2f"
+#define NVSDK_NGX_EParameter_SizeInBytes         "#\x30"
+#define NVSDK_NGX_EParameter_ResourceAllocCallback      "#\x31"
+#define NVSDK_NGX_EParameter_BufferAllocCallback        "#\x32"
+#define NVSDK_NGX_EParameter_Tex2DAllocCallback         "#\x33"
+#define NVSDK_NGX_EParameter_ResourceReleaseCallback    "#\x34"
+#define NVSDK_NGX_EParameter_CreationNodeMask           "#\x35"
+#define NVSDK_NGX_EParameter_VisibilityNodeMask         "#\x36"
+#define NVSDK_NGX_EParameter_PreviousOutput             "#\x37"
+#define NVSDK_NGX_EParameter_MV_Offset_X                 "#\x38"
+#define NVSDK_NGX_EParameter_MV_Offset_Y                 "#\x39"
+#define NVSDK_NGX_EParameter_Hint_UseFireflySwatter      "#\x3a"
+#define NVSDK_NGX_EParameter_Resource_Width              "#\x3b"
+#define NVSDK_NGX_EParameter_Resource_Height             "#\x3c"
+#define NVSDK_NGX_EParameter_Depth                       "#\x3d"
+#define NVSDK_NGX_EParameter_DLSSOptimalSettingsCallback "#\x3e"
+#define NVSDK_NGX_EParameter_PerfQualityValue            "#\x3f"
+#define NVSDK_NGX_EParameter_RTXValue                    "#\x40"
+#define NVSDK_NGX_EParameter_DLSSMode                    "#\x41"
+#define NVSDK_NGX_EParameter_DeepResolve_Available       "#\x42"
+#define NVSDK_NGX_EParameter_Deprecated_43               "#\x43"
+#define NVSDK_NGX_EParameter_OptLevel                    "#\x44"
+#define NVSDK_NGX_EParameter_IsDevSnippetBranch          "#\x45"
+#define NVSDK_NGX_EParameter_DeepDVC_Available           "#\x46"
+#define NVSDK_NGX_EParameter_Graphics_API                "#\x47"
+#define NVSDK_NGX_EParameter_Reserved_48                 "#\x48"
+#define NVSDK_NGX_EParameter_Reserved_49                 "#\x49"
+
+#define NVSDK_NGX_Parameter_OptLevel "Snippet.OptLevel"
+#define NVSDK_NGX_Parameter_IsDevSnippetBranch "Snippet.IsDevBranch"
+#define NVSDK_NGX_Parameter_SuperSampling_ScaleFactor  "SuperSampling.ScaleFactor"
+#define NVSDK_NGX_Parameter_ImageSignalProcessing_ScaleFactor "ImageSignalProcessing.ScaleFactor"
+#define NVSDK_NGX_Parameter_SuperSampling_Available "SuperSampling.Available"
+#define NVSDK_NGX_Parameter_InPainting_Available "InPainting.Available"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_Available "ImageSuperResolution.Available"
+#define NVSDK_NGX_Parameter_SlowMotion_Available "SlowMotion.Available"
+#define NVSDK_NGX_Parameter_VideoSuperResolution_Available "VideoSuperResolution.Available"
+#define NVSDK_NGX_Parameter_ImageSignalProcessing_Available "ImageSignalProcessing.Available"
+#define NVSDK_NGX_Parameter_DeepResolve_Available "DeepResolve.Available"
+#define NVSDK_NGX_Parameter_SuperSampling_NeedsUpdatedDriver            "SuperSampling.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_InPainting_NeedsUpdatedDriver               "InPainting.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_NeedsUpdatedDriver     "ImageSuperResolution.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_SlowMotion_NeedsUpdatedDriver               "SlowMotion.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_VideoSuperResolution_NeedsUpdatedDriver     "VideoSuperResolution.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_ImageSignalProcessing_NeedsUpdatedDriver    "ImageSignalProcessing.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_DeepResolve_NeedsUpdatedDriver              "DeepResolve.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_FrameInterpolation_NeedsUpdatedDriver       "FrameInterpolation.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_SuperSampling_MinDriverVersionMajor         "SuperSampling.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_InPainting_MinDriverVersionMajor            "InPainting.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_MinDriverVersionMajor  "ImageSuperResolution.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_SlowMotion_MinDriverVersionMajor            "SlowMotion.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_VideoSuperResolution_MinDriverVersionMajor  "VideoSuperResolution.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_ImageSignalProcessing_MinDriverVersionMajor "ImageSignalProcessing.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_DeepResolve_MinDriverVersionMajor           "DeepResolve.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_FrameInterpolation_MinDriverVersionMajor    "FrameInterpolation.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_SuperSampling_MinDriverVersionMinor         "SuperSampling.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_InPainting_MinDriverVersionMinor            "InPainting.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_MinDriverVersionMinor  "ImageSuperResolution.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_SlowMotion_MinDriverVersionMinor            "SlowMotion.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_VideoSuperResolution_MinDriverVersionMinor  "VideoSuperResolution.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_ImageSignalProcessing_MinDriverVersionMinor "ImageSignalProcessing.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_DeepResolve_MinDriverVersionMinor           "DeepResolve.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_SuperSampling_FeatureInitResult             "SuperSampling.FeatureInitResult"
+#define NVSDK_NGX_Parameter_InPainting_FeatureInitResult                "InPainting.FeatureInitResult"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_FeatureInitResult      "ImageSuperResolution.FeatureInitResult"
+#define NVSDK_NGX_Parameter_SlowMotion_FeatureInitResult                "SlowMotion.FeatureInitResult"
+#define NVSDK_NGX_Parameter_VideoSuperResolution_FeatureInitResult      "VideoSuperResolution.FeatureInitResult"
+#define NVSDK_NGX_Parameter_ImageSignalProcessing_FeatureInitResult     "ImageSignalProcessing.FeatureInitResult"
+#define NVSDK_NGX_Parameter_DeepResolve_FeatureInitResult               "DeepResolve.FeatureInitResult"
+#define NVSDK_NGX_Parameter_FrameInterpolation_FeatureInitResult        "FrameInterpolation.FeatureInitResult"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_ScaleFactor_2_1 "ImageSuperResolution.ScaleFactor.2.1"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_ScaleFactor_3_1 "ImageSuperResolution.ScaleFactor.3.1"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_ScaleFactor_3_2 "ImageSuperResolution.ScaleFactor.3.2"
+#define NVSDK_NGX_Parameter_ImageSuperResolution_ScaleFactor_4_3 "ImageSuperResolution.ScaleFactor.4.3"
+#define NVSDK_NGX_Parameter_NumFrames "NumFrames"
+#define NVSDK_NGX_Parameter_Scale "Scale"
+#define NVSDK_NGX_Parameter_Width "Width"
+#define NVSDK_NGX_Parameter_Height "Height"
+#define NVSDK_NGX_Parameter_OutWidth "OutWidth"
+#define NVSDK_NGX_Parameter_OutHeight "OutHeight"
+#define NVSDK_NGX_Parameter_Sharpness "Sharpness"
+#define NVSDK_NGX_Parameter_Scratch "Scratch"
+#define NVSDK_NGX_Parameter_Scratch_SizeInBytes "Scratch.SizeInBytes"
+#define NVSDK_NGX_Parameter_Input1 "Input1"
+#define NVSDK_NGX_Parameter_Input1_Format "Input1.Format"
+#define NVSDK_NGX_Parameter_Input1_SizeInBytes "Input1.SizeInBytes"
+#define NVSDK_NGX_Parameter_Input2 "Input2"
+#define NVSDK_NGX_Parameter_Input2_Format "Input2.Format"
+#define NVSDK_NGX_Parameter_Input2_SizeInBytes "Input2.SizeInBytes"
+#define NVSDK_NGX_Parameter_Color "Color"
+#define NVSDK_NGX_Parameter_Color_Format "Color.Format"
+#define NVSDK_NGX_Parameter_Color_SizeInBytes "Color.SizeInBytes"
+#define NVSDK_NGX_Parameter_FI_Color1 "Color1"
+#define NVSDK_NGX_Parameter_FI_Color2 "Color2"
+#define NVSDK_NGX_Parameter_Albedo "Albedo"
+#define NVSDK_NGX_Parameter_Output "Output"
+#define NVSDK_NGX_Parameter_Output_Format "Output.Format"
+#define NVSDK_NGX_Parameter_Output_SizeInBytes "Output.SizeInBytes"
+#define NVSDK_NGX_Parameter_FI_Output1 "Output1"
+#define NVSDK_NGX_Parameter_FI_Output2 "Output2"
+#define NVSDK_NGX_Parameter_FI_Output3 "Output3"
+#define NVSDK_NGX_Parameter_Reset "Reset"
+#define NVSDK_NGX_Parameter_BlendFactor "BlendFactor"
+#define NVSDK_NGX_Parameter_MotionVectors "MotionVectors"
+#define NVSDK_NGX_Parameter_FI_MotionVectors1 "MotionVectors1"
+#define NVSDK_NGX_Parameter_FI_MotionVectors2 "MotionVectors2"
+#define NVSDK_NGX_Parameter_Rect_X "Rect.X"
+#define NVSDK_NGX_Parameter_Rect_Y "Rect.Y"
+#define NVSDK_NGX_Parameter_Rect_W "Rect.W"
+#define NVSDK_NGX_Parameter_Rect_H "Rect.H"
+#define NVSDK_NGX_Parameter_OutRect_X "OutRect.X"
+#define NVSDK_NGX_Parameter_OutRect_Y "OutRect.Y"
+#define NVSDK_NGX_Parameter_OutRect_W "OutRect.W"
+#define NVSDK_NGX_Parameter_OutRect_H "OutRect.H"
+#define NVSDK_NGX_Parameter_MV_Scale_X "MV.Scale.X"
+#define NVSDK_NGX_Parameter_MV_Scale_Y "MV.Scale.Y"
+#define NVSDK_NGX_Parameter_Model "Model"
+#define NVSDK_NGX_Parameter_Format "Format"
+#define NVSDK_NGX_Parameter_SizeInBytes "SizeInBytes"
+#define NVSDK_NGX_Parameter_ResourceAllocCallback      "ResourceAllocCallback"
+#define NVSDK_NGX_Parameter_BufferAllocCallback        "BufferAllocCallback"
+#define NVSDK_NGX_Parameter_Tex2DAllocCallback         "Tex2DAllocCallback"
+#define NVSDK_NGX_Parameter_ResourceReleaseCallback    "ResourceReleaseCallback"
+#define NVSDK_NGX_Parameter_CreationNodeMask           "CreationNodeMask"
+#define NVSDK_NGX_Parameter_VisibilityNodeMask         "VisibilityNodeMask"
+#define NVSDK_NGX_Parameter_MV_Offset_X "MV.Offset.X"
+#define NVSDK_NGX_Parameter_MV_Offset_Y "MV.Offset.Y"
+#define NVSDK_NGX_Parameter_Hint_UseFireflySwatter "Hint.UseFireflySwatter"
+#define NVSDK_NGX_Parameter_Resource_Width "ResourceWidth"
+#define NVSDK_NGX_Parameter_Resource_Height "ResourceHeight"
+#define NVSDK_NGX_Parameter_Resource_OutWidth "ResourceOutWidth"
+#define NVSDK_NGX_Parameter_Resource_OutHeight "ResourceOutHeight"
+#define NVSDK_NGX_Parameter_Depth "Depth"
+#define NVSDK_NGX_Parameter_FI_Depth1 "Depth1"
+#define NVSDK_NGX_Parameter_FI_Depth2 "Depth2"
+#define NVSDK_NGX_Parameter_DLSSOptimalSettingsCallback    "DLSSOptimalSettingsCallback"
+#define NVSDK_NGX_Parameter_DLSSGetStatsCallback    "DLSSGetStatsCallback"
+#define NVSDK_NGX_Parameter_PerfQualityValue    "PerfQualityValue"
+#define NVSDK_NGX_Parameter_RTXValue    "RTXValue"
+#define NVSDK_NGX_Parameter_DLSSMode    "DLSSMode"
+#define NVSDK_NGX_Parameter_FI_Mode     "FIMode"
+#define NVSDK_NGX_Parameter_FI_OF_Preset    "FIOFPreset"
+#define NVSDK_NGX_Parameter_FI_OF_GridSize  "FIOFGridSize"
+#define NVSDK_NGX_Parameter_Jitter_Offset_X     "Jitter.Offset.X"
+#define NVSDK_NGX_Parameter_Jitter_Offset_Y     "Jitter.Offset.Y"
+#define NVSDK_NGX_Parameter_Denoise "Denoise"
+#define NVSDK_NGX_Parameter_TransparencyMask "TransparencyMask"
+#define NVSDK_NGX_Parameter_ExposureTexture   "ExposureTexture" // a 1x1 texture containing the final exposure scale
+#define NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags "DLSS.Feature.Create.Flags"
+#define NVSDK_NGX_Parameter_DLSS_Checkerboard_Jitter_Hack "DLSS.Checkerboard.Jitter.Hack"
+#define NVSDK_NGX_Parameter_GBuffer_Normals "GBuffer.Normals"
+#define NVSDK_NGX_Parameter_GBuffer_Albedo "GBuffer.Albedo"
+#define NVSDK_NGX_Parameter_GBuffer_Roughness "GBuffer.Roughness"
+#define NVSDK_NGX_Parameter_GBuffer_DiffuseAlbedo "GBuffer.DiffuseAlbedo"
+#define NVSDK_NGX_Parameter_GBuffer_SpecularAlbedo "GBuffer.SpecularAlbedo"
+#define NVSDK_NGX_Parameter_GBuffer_IndirectAlbedo "GBuffer.IndirectAlbedo"
+#define NVSDK_NGX_Parameter_GBuffer_SpecularMvec "GBuffer.SpecularMvec"
+#define NVSDK_NGX_Parameter_GBuffer_DisocclusionMask "GBuffer.DisocclusionMask"
+#define NVSDK_NGX_Parameter_GBuffer_Metallic "GBuffer.Metallic"
+#define NVSDK_NGX_Parameter_GBuffer_Specular "GBuffer.Specular"
+#define NVSDK_NGX_Parameter_GBuffer_Subsurface "GBuffer.Subsurface"
+#define NVSDK_NGX_Parameter_GBuffer_ShadingModelId "GBuffer.ShadingModelId"
+#define NVSDK_NGX_Parameter_GBuffer_MaterialId "GBuffer.MaterialId"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_8 "GBuffer.Attrib.8"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_9 "GBuffer.Attrib.9"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_10 "GBuffer.Attrib.10"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_11 "GBuffer.Attrib.11"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_12 "GBuffer.Attrib.12"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_13 "GBuffer.Attrib.13"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_14 "GBuffer.Attrib.14"
+#define NVSDK_NGX_Parameter_GBuffer_Atrrib_15 "GBuffer.Attrib.15"
+#define NVSDK_NGX_Parameter_TonemapperType "TonemapperType"
+#define NVSDK_NGX_Parameter_FreeMemOnReleaseFeature "FreeMemOnReleaseFeature"
+#define NVSDK_NGX_Parameter_MotionVectors3D "MotionVectors3D"
+#define NVSDK_NGX_Parameter_IsParticleMask "IsParticleMask"
+#define NVSDK_NGX_Parameter_AnimatedTextureMask "AnimatedTextureMask"
+#define NVSDK_NGX_Parameter_DepthHighRes "DepthHighRes"
+#define NVSDK_NGX_Parameter_Position_ViewSpace "Position.ViewSpace"
+#define NVSDK_NGX_Parameter_FrameTimeDeltaInMsec "FrameTimeDeltaInMsec"
+#define NVSDK_NGX_Parameter_RayTracingHitDistance "RayTracingHitDistance"
+#define NVSDK_NGX_Parameter_MotionVectorsReflection "MotionVectorsReflection"
+#define NVSDK_NGX_Parameter_DLSS_Enable_Output_Subrects "DLSS.Enable.Output.Subrects"
+#define NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X "DLSS.Input.Color.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y "DLSS.Input.Color.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X "DLSS.Input.Depth.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y "DLSS.Input.Depth.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X "DLSS.Input.MV.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y "DLSS.Input.MV.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_X "DLSS.Input.Translucency.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_Y "DLSS.Input.Translucency.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X "DLSS.Output.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y "DLSS.Output.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width  "DLSS.Render.Subrect.Dimensions.Width"
+#define NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height "DLSS.Render.Subrect.Dimensions.Height"
+#define NVSDK_NGX_Parameter_DLSS_Pre_Exposure "DLSS.Pre.Exposure"
+#define NVSDK_NGX_Parameter_DLSS_Exposure_Scale "DLSS.Exposure.Scale"
+#define NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask          "DLSS.Input.Bias.Current.Color.Mask"
+#define NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X "DLSS.Input.Bias.Current.Color.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y "DLSS.Input.Bias.Current.Color.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Indicator_Invert_Y_Axis          "DLSS.Indicator.Invert.Y.Axis"
+#define NVSDK_NGX_Parameter_DLSS_Indicator_Invert_X_Axis          "DLSS.Indicator.Invert.X.Axis"
+#define NVSDK_NGX_Parameter_DLSS_INV_VIEW_PROJECTION_MATRIX "InvViewProjectionMatrix"
+#define NVSDK_NGX_Parameter_DLSS_CLIP_TO_PREV_CLIP_MATRIX   "ClipToPrevClipMatrix"
+
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayer "DLSS.TransparencyLayer"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_X "DLSS.TransparencyLayer.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_Y "DLSS.TransparencyLayer.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity "DLSS.TransparencyLayerOpacity"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_X "DLSS.TransparencyLayerOpacity.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_Y "DLSS.TransparencyLayerOpacity.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs "DLSS.TransparencyLayerMvecs"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_X "DLSS.TransparencyLayerMvecs.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_Y "DLSS.TransparencyLayerMvecs.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_DisocclusionMask "DLSS.DisocclusionMask"
+#define NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_X "DLSS.DisocclusionMask.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_Y "DLSS.DisocclusionMask.Subrect.Base.Y"
+
+#define NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Max_Render_Width     "DLSS.Get.Dynamic.Max.Render.Width"
+#define NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Max_Render_Height    "DLSS.Get.Dynamic.Max.Render.Height"
+#define NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Min_Render_Width     "DLSS.Get.Dynamic.Min.Render.Width"
+#define NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Min_Render_Height    "DLSS.Get.Dynamic.Min.Render.Height"
+
+#define NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_DLAA "DLSS.Hint.Render.Preset.DLAA"
+#define NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Quality "DLSS.Hint.Render.Preset.Quality"
+#define NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Balanced "DLSS.Hint.Render.Preset.Balanced"
+#define NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Performance "DLSS.Hint.Render.Preset.Performance"
+#define NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraPerformance "DLSS.Hint.Render.Preset.UltraPerformance"
+#define NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraQuality "DLSS.Hint.Render.Preset.UltraQuality"
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_defs_dlssd.h

@@ -0,0 +1,157 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#ifndef NVSDK_NGX_DEFS_DLSSD_H
+#define NVSDK_NGX_DEFS_DLSSD_H
+#pragma once
+
+typedef enum NVSDK_NGX_DLSS_Denoise_Mode
+{
+    NVSDK_NGX_DLSS_Denoise_Mode_Off = 0,
+    NVSDK_NGX_DLSS_Denoise_Mode_DLUnified = 1, // DL based unified upscaler
+} NVSDK_NGX_DLSS_Denoise_Mode;
+
+typedef enum NVSDK_NGX_DLSS_Roughness_Mode
+{
+    NVSDK_NGX_DLSS_Roughness_Mode_Unpacked = 0, // Read roughness separately 
+    NVSDK_NGX_DLSS_Roughness_Mode_Packed = 1, // Read roughness from normals.w
+} NVSDK_NGX_DLSS_Roughness_Mode;
+
+typedef enum NVSDK_NGX_DLSS_Depth_Type
+{
+    NVSDK_NGX_DLSS_Depth_Type_Linear = 0, // Linear Depth
+    NVSDK_NGX_DLSS_Depth_Type_HW = 1,     // HW Depth
+} NVSDK_NGX_DLSS_Depth_Type;
+
+
+typedef enum NVSDK_NGX_RayReconstruction_Hint_Render_Preset
+{
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_Default,     // default behavior, may or may not change after OTA
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_A,
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_B,
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_C,
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_D,
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_E,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_F,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_G,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_H,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_I,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_J,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_K,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_L,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_M,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_N,           // do not use, reverts to default behavior
+    NVSDK_NGX_RayReconstruction_Hint_Render_Preset_O,           // do not use, reverts to default behavior
+} NVSDK_NGX_RayReconstruction_Hint_Render_Preset;
+
+#define NVSDK_NGX_Parameter_DLSS_Denoise_Mode "DLSS.Denoise.Mode"
+#define NVSDK_NGX_Parameter_DLSS_Roughness_Mode "DLSS.Roughness.Mode"
+#define NVSDK_NGX_Parameter_DiffuseAlbedo  "DLSS.Input.DiffuseAlbedo"
+#define NVSDK_NGX_Parameter_SpecularAlbedo "DLSS.Input.SpecularAlbedo"
+#define NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_X "DLSS.Input.DiffuseAlbedo.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_Y "DLSS.Input.DiffuseAlbedo.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_X "DLSS.Input.SpecularAlbedo.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_Y "DLSS.Input.SpecularAlbedo.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_X "DLSS.Input.Normals.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_Y "DLSS.Input.Normals.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_X "DLSS.Input.Roughness.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_Y "DLSS.Input.Roughness.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_ViewToClipMatrix "ViewToClipMatrix"
+#define NVSDK_NGX_Parameter_GBuffer_Emissive "GBuffer.Emissive"
+#define NVSDK_NGX_Parameter_Use_Folded_Network "DLSS.Use.Folded.Network"
+#define NVSDK_NGX_Parameter_Diffuse_Ray_Direction "Diffuse.Ray.Direction"
+#define NVSDK_NGX_Parameter_DLSS_WORLD_TO_VIEW_MATRIX "WorldToViewMatrix"
+#define NVSDK_NGX_Parameter_DLSS_VIEW_TO_CLIP_MATRIX "ViewToClipMatrix"
+#define NVSDK_NGX_Parameter_Use_HW_Depth "DLSS.Use.HW.Depth"
+#define NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo "DLSSD.ReflectedAlbedo"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles "DLSSD.ColorBeforeParticles"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles "DLSSD.ColorAfterParticles"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency "DLSSD.ColorBeforeTransparency"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency "DLSSD.ColorAfterTransparency"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog "DLSSD.ColorBeforeFog"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterFog "DLSSD.ColorAfterFog"
+#define NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide "DLSSD.ScreenSpaceSubsurfaceScatteringGuide"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering "DLSSD.ColorBeforeScreenSpaceSubsurfaceScattering"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering "DLSSD.ColorAfterScreenSpaceSubsurfaceScattering"
+#define NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide "DLSSD.ScreenSpaceRefractionGuide"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction "DLSSD.ColorBeforeScreenSpaceRefraction"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction "DLSSD.ColorAfterScreenSpaceRefraction"
+#define NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide "DLSSD.DepthOfFieldGuide"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField "DLSSD.ColorBeforeDepthOfField"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField "DLSSD.ColorAfterDepthOfField"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance "DLSSD.DiffuseHitDistance"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance "DLSSD.SpecularHitDistance"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection "DLSSD.DiffuseRayDirection"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection "DLSSD.SpecularRayDirection"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance "DLSSD.DiffuseRayDirectionHitDistance"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance "DLSSD.SpecularRayDirectionHitDistance"
+#define NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_X "DLSSD.ReflectedAlbedo.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_Y "DLSSD.ReflectedAlbedo.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_X "DLSSD.ColorBeforeParticles.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_Y "DLSSD.ColorBeforeParticles.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_X "DLSSD.ColorAfterParticles.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_Y "DLSSD.ColorAfterParticles.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_X "DLSSD.ColorBeforeTransparency.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_Y "DLSSD.ColorBeforeTransparency.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_X "DLSSD.ColorAfterTransparency.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_Y "DLSSD.ColorAfterTransparency.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_X "DLSSD.ColorBeforeFog.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_Y "DLSSD.ColorBeforeFog.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_X "DLSSD.ColorAfterFog.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_Y "DLSSD.ColorAfterFog.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_X "DLSSD.ScreenSpaceSubsurfaceScatteringGuide.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_Y "DLSSD.ScreenSpaceSubsurfaceScatteringGuide.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_X "DLSSD.ColorBeforeScreenSpaceSubsurfaceScattering.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_Y "DLSSD.ColorBeforeScreenSpaceSubsurfaceScattering.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_X "DLSSD.ColorAfterScreenSpaceSubsurfaceScattering.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_Y "DLSSD.ColorAfterScreenSpaceSubsurfaceScattering.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_X "DLSSD.ScreenSpaceRefractionGuide.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_Y "DLSSD.ScreenSpaceRefractionGuide.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_X "DLSSD.ColorBeforeScreenSpaceRefraction.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_Y "DLSSD.ColorBeforeScreenSpaceRefraction.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_X "DLSSD.ColorAfterScreenSpaceRefraction.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_Y "DLSSD.ColorAfterScreenSpaceRefraction.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_X "DLSSD.DepthOfFieldGuide.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_Y "DLSSD.DepthOfFieldGuide.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_X "DLSSD.ColorBeforeDepthOfField.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_Y "DLSSD.ColorBeforeDepthOfField.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_X "DLSSD.ColorAfterDepthOfField.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_Y "DLSSD.ColorAfterDepthOfField.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_X "DLSSD.DiffuseHitDistance.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_Y "DLSSD.DiffuseHitDistance.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_X "DLSSD.SpecularHitDistance.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_Y "DLSSD.SpecularHitDistance.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_X "DLSSD.DiffuseRayDirection.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_Y "DLSSD.DiffuseRayDirection.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_X "DLSSD.SpecularRayDirection.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_Y "DLSSD.SpecularRayDirection.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_X "DLSSD.DiffuseRayDirectionHitDistance.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_Y "DLSSD.DiffuseRayDirectionHitDistance.Subrect.Base.Y"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_X "DLSSD.SpecularRayDirectionHitDistance.Subrect.Base.X"
+#define NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_Y "DLSSD.SpecularRayDirectionHitDistance.Subrect.Base.Y"
+
+#define NVSDK_NGX_Parameter_SuperSamplingDenoising_Available             "SuperSamplingDenoising.Available"
+#define NVSDK_NGX_Parameter_SuperSamplingDenoising_NeedsUpdatedDriver    "SuperSamplingDenoising.NeedsUpdatedDriver"
+#define NVSDK_NGX_Parameter_SuperSamplingDenoising_MinDriverVersionMajor "SuperSamplingDenoising.MinDriverVersionMajor"
+#define NVSDK_NGX_Parameter_SuperSamplingDenoising_MinDriverVersionMinor "SuperSamplingDenoising.MinDriverVersionMinor"
+#define NVSDK_NGX_Parameter_SuperSamplingDenoising_FeatureInitResult     "SuperSamplingDenoising.FeatureInitResult"
+#define NVSDK_NGX_Parameter_DLSSDOptimalSettingsCallback "DLSSDOptimalSettingsCallback"
+#define NVSDK_NGX_Parameter_DLSSDGetStatsCallback        "DLSSDGetStatsCallback"
+
+#define NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_DLAA "RayReconstruction.Hint.Render.Preset.DLAA"
+#define NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_Quality "RayReconstruction.Hint.Render.Preset.Quality"
+#define NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_Balanced "RayReconstruction.Hint.Render.Preset.Balanced"
+#define NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_Performance "RayReconstruction.Hint.Render.Preset.Performance"
+#define NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_UltraPerformance "RayReconstruction.Hint.Render.Preset.UltraPerformance"
+#define NVSDK_NGX_Parameter_RayReconstruction_Hint_Render_Preset_UltraQuality "RayReconstruction.Hint.Render.Preset.UltraQuality"
+
+#endif // NVSDK_NGX_DEFS_DLSSD_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_helpers.h

@@ -0,0 +1,627 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2019-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#ifndef NVSDK_NGX_HELPERS_H
+#define NVSDK_NGX_HELPERS_H
+#pragma once
+
+#include "nvsdk_ngx.h"
+#include "nvsdk_ngx_defs.h"
+
+typedef NVSDK_NGX_Result(NVSDK_CONV *PFN_NVSDK_NGX_DLSS_GetStatsCallback)(NVSDK_NGX_Parameter *InParams);
+
+static inline NVSDK_NGX_Result NGX_DLSS_GET_STATS_2(
+    NVSDK_NGX_Parameter *pInParams,
+    unsigned long long *pVRAMAllocatedBytes,
+    unsigned int *pOptLevel, unsigned int *IsDevSnippetBranch)
+{
+    void *Callback = NULL;
+    NVSDK_NGX_Parameter_GetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSGetStatsCallback, &Callback);
+    if (!Callback)
+    {
+        // Possible reasons for this:
+        // - Installed DLSS is out of date and does not support the feature we need
+        // - You used NVSDK_NGX_AllocateParameters() for creating InParams. Try using NVSDK_NGX_GetCapabilityParameters() instead
+        return NVSDK_NGX_Result_FAIL_OutOfDate;
+    }
+
+    NVSDK_NGX_Result Res = NVSDK_NGX_Result_Success;
+    PFN_NVSDK_NGX_DLSS_GetStatsCallback PFNCallback = (PFN_NVSDK_NGX_DLSS_GetStatsCallback)Callback;
+    Res = PFNCallback(pInParams);
+    if (NVSDK_NGX_FAILED(Res))
+    {
+        return Res;
+    }
+    NVSDK_NGX_Parameter_GetULL(pInParams, NVSDK_NGX_Parameter_SizeInBytes, pVRAMAllocatedBytes);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_EParameter_OptLevel, pOptLevel);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_EParameter_IsDevSnippetBranch, IsDevSnippetBranch);
+    return Res;
+}
+
+static inline NVSDK_NGX_Result NGX_DLSS_GET_STATS_1(
+    NVSDK_NGX_Parameter *pInParams,
+    unsigned long long *pVRAMAllocatedBytes,
+    unsigned int *pOptLevel)
+{
+    unsigned int dummy = 0;
+    return NGX_DLSS_GET_STATS_2(pInParams, pVRAMAllocatedBytes, pOptLevel, &dummy);
+}
+
+static inline NVSDK_NGX_Result NGX_DLSS_GET_STATS(
+    NVSDK_NGX_Parameter *pInParams,
+    unsigned long long *pVRAMAllocatedBytes)
+{
+    unsigned int dummy = 0;
+    return NGX_DLSS_GET_STATS_2(pInParams, pVRAMAllocatedBytes, &dummy, &dummy);
+}
+
+typedef NVSDK_NGX_Result(NVSDK_CONV *PFN_NVSDK_NGX_DLSS_GetOptimalSettingsCallback)(NVSDK_NGX_Parameter *InParams);
+
+static inline NVSDK_NGX_Result NGX_DLSS_GET_OPTIMAL_SETTINGS(
+    NVSDK_NGX_Parameter *pInParams,
+    unsigned int InUserSelectedWidth,
+    unsigned int InUserSelectedHeight,
+    NVSDK_NGX_PerfQuality_Value InPerfQualityValue,
+    unsigned int *pOutRenderOptimalWidth,
+    unsigned int *pOutRenderOptimalHeight,
+    unsigned int *pOutRenderMaxWidth,
+    unsigned int *pOutRenderMaxHeight,
+    unsigned int *pOutRenderMinWidth,
+    unsigned int *pOutRenderMinHeight,
+    float *pOutSharpness)
+{
+    void *Callback = NULL;
+    NVSDK_NGX_Parameter_GetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSOptimalSettingsCallback, &Callback);
+    if (!Callback)
+    {
+        // Possible reasons for this:
+        // - Installed DLSS is out of date and does not support the feature we need
+        // - You used NVSDK_NGX_AllocateParameters() for creating InParams. Try using NVSDK_NGX_GetCapabilityParameters() instead
+        return NVSDK_NGX_Result_FAIL_OutOfDate;
+    }
+
+    // These are selections made by user in UI
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, InUserSelectedWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, InUserSelectedHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_RTXValue, false); // Some older DLSS dlls still expect this value to be set
+
+    NVSDK_NGX_Result Res = NVSDK_NGX_Result_Success;
+    PFN_NVSDK_NGX_DLSS_GetOptimalSettingsCallback PFNCallback = (PFN_NVSDK_NGX_DLSS_GetOptimalSettingsCallback)Callback;
+    Res = PFNCallback(pInParams);
+    if (NVSDK_NGX_FAILED(Res))
+    {
+        return Res;
+    }
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pOutRenderOptimalWidth);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pOutRenderOptimalHeight);
+    // If we have an older DLSS Dll those might need to be set to the optimal dimensions instead
+    *pOutRenderMaxWidth  = *pOutRenderOptimalWidth;
+    *pOutRenderMaxHeight = *pOutRenderOptimalHeight;
+    *pOutRenderMinWidth  = *pOutRenderOptimalWidth;
+    *pOutRenderMinHeight = *pOutRenderOptimalHeight;
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Max_Render_Width,  pOutRenderMaxWidth);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Max_Render_Height, pOutRenderMaxHeight);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Min_Render_Width,  pOutRenderMinWidth);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Min_Render_Height, pOutRenderMinHeight);
+    NVSDK_NGX_Parameter_GetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pOutSharpness);
+    return Res;
+}
+
+/*** D3D11 ***/
+typedef struct NVSDK_NGX_D3D11_Feature_Eval_Params
+{
+    ID3D11Resource*  pInColor;
+    ID3D11Resource*  pInOutput;
+    /*** OPTIONAL for DLSS ***/
+    float       InSharpness;
+} NVSDK_NGX_D3D11_Feature_Eval_Params;
+
+typedef struct NVSDK_NGX_CUDA_Feature_Eval_Params
+{
+    CUtexObject* pInColor;
+    CUtexObject* pInOutput;
+    /*** OPTIONAL for DLSS ***/
+    float       InSharpness;
+} NVSDK_NGX_CUDA_Feature_Eval_Params;
+
+typedef struct NVSDK_NGX_D3D11_GBuffer
+{
+    ID3D11Resource* pInAttrib[NVSDK_NGX_GBUFFERTYPE_NUM];
+} NVSDK_NGX_D3D11_GBuffer;
+
+typedef struct NVSDK_NGX_D3D11_DLSS_Eval_Params
+{
+    NVSDK_NGX_D3D11_Feature_Eval_Params Feature;
+    ID3D11Resource*                     pInDepth;
+    ID3D11Resource*                     pInMotionVectors;
+    float                               InJitterOffsetX;     /* Jitter offset must be in input/render pixel space */
+    float                               InJitterOffsetY;
+    NVSDK_NGX_Dimensions                InRenderSubrectDimensions;
+    /*** OPTIONAL - leave to 0/0.0f if unused ***/
+    int                                 InReset;             /* Set to 1 when scene changes completely (new level etc) */
+    float                               InMVScaleX;          /* If MVs need custom scaling to convert to pixel space */
+    float                               InMVScaleY;
+    ID3D11Resource*                     pInTransparencyMask; /* Unused/Reserved for future use */
+    ID3D11Resource*                     pInExposureTexture;
+    ID3D11Resource*                     pInBiasCurrentColorMask;
+    NVSDK_NGX_Coordinates               InColorSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthSubrectBase;
+    NVSDK_NGX_Coordinates               InMVSubrectBase;
+    NVSDK_NGX_Coordinates               InTranslucencySubrectBase;
+    NVSDK_NGX_Coordinates               InBiasCurrentColorSubrectBase;
+    NVSDK_NGX_Coordinates               InOutputSubrectBase;
+    float                               InPreExposure;
+    float                               InExposureScale;
+    int                                 InIndicatorInvertXAxis;
+    int                                 InIndicatorInvertYAxis;
+    /*** OPTIONAL - only for research purposes ***/
+    NVSDK_NGX_D3D11_GBuffer             GBufferSurface;
+    NVSDK_NGX_ToneMapperType            InToneMapperType;
+    ID3D11Resource*                     pInMotionVectors3D;
+    ID3D11Resource*                     pInIsParticleMask; /* to identify which pixels contains particles, essentially that are not drawn as part of base pass */
+    ID3D11Resource*                     pInAnimatedTextureMask; /* a binary mask covering pixels occupied by animated textures */
+    ID3D11Resource*                     pInDepthHighRes;
+    ID3D11Resource*                     pInPositionViewSpace;
+    float                               InFrameTimeDeltaInMsec; /* helps in determining the amount to denoise or anti-alias based on the speed of the object from motion vector magnitudes and fps as determined by this delta */
+    ID3D11Resource*                     pInRayTracingHitDistance; /* for each effect - approximation to the amount of noise in a ray-traced color */
+    ID3D11Resource*                     pInMotionVectorsReflections; /* motion vectors of reflected objects like for mirrored surfaces */
+} NVSDK_NGX_D3D11_DLSS_Eval_Params;
+
+typedef struct NVSDK_NGX_D3D11_DLISP_Eval_Params
+{
+    NVSDK_NGX_D3D11_Feature_Eval_Params Feature;
+    /*** OPTIONAL - leave to 0/0.0f if unused  ***/
+    unsigned int                    InRectX;
+    unsigned int                    InRectY;
+    unsigned int                    InRectW;
+    unsigned int                    InRectH;
+    float                           InDenoise;
+} NVSDK_NGX_D3D11_DLISP_Eval_Params;
+
+typedef struct NVSDK_NGX_CUDA_DLISP_Eval_Params
+{
+    NVSDK_NGX_CUDA_Feature_Eval_Params Feature;
+    /*** OPTIONAL - leave to 0/0.0f if unused  ***/
+    unsigned int                    InRectX;
+    unsigned int                    InRectY;
+    unsigned int                    InRectW;
+    unsigned int                    InRectH;
+    float                           InDenoise;
+} NVSDK_NGX_CUDA_DLISP_Eval_Params;
+
+
+static inline NVSDK_NGX_Result NGX_D3D11_CREATE_DLSS_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_DLSS_Create_Params *pInDlssCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlssCreateParams->Feature.InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlssCreateParams->Feature.InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlssCreateParams->Feature.InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlssCreateParams->Feature.InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pInDlssCreateParams->Feature.InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, pInDlssCreateParams->InFeatureCreateFlags);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Enable_Output_Subrects, pInDlssCreateParams->InEnableOutputSubrects ? 1 : 0);
+
+    return NVSDK_NGX_D3D11_CreateFeature(pInCtx, NVSDK_NGX_Feature_SuperSampling, pInParams, ppOutHandle);
+}
+
+
+static inline NVSDK_NGX_Result NGX_D3D11_EVALUATE_DLSS_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D11_DLSS_Eval_Params *pInDlssEvalParams)
+{
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Color, pInDlssEvalParams->Feature.pInColor);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Output, pInDlssEvalParams->Feature.pInOutput);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Depth, pInDlssEvalParams->pInDepth);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors, pInDlssEvalParams->pInMotionVectors);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_X, pInDlssEvalParams->InJitterOffsetX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_Y, pInDlssEvalParams->InJitterOffsetY);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pInDlssEvalParams->Feature.InSharpness);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_Reset, pInDlssEvalParams->InReset);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_X, pInDlssEvalParams->InMVScaleX == 0.0f ? 1.0f : pInDlssEvalParams->InMVScaleX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_Y, pInDlssEvalParams->InMVScaleY == 0.0f ? 1.0f : pInDlssEvalParams->InMVScaleY);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_TransparencyMask, pInDlssEvalParams->pInTransparencyMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_ExposureTexture, pInDlssEvalParams->pInExposureTexture);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, pInDlssEvalParams->pInBiasCurrentColorMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Albedo, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ALBEDO]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ROUGHNESS]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Metallic, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_METALLIC]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Specular, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SPECULAR]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Subsurface, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SUBSURFACE]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_NORMALS]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_ShadingModelId, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SHADINGMODELID]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_MaterialId, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_MATERIALID]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_8, pInDlssEvalParams->GBufferSurface.pInAttrib[8]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_9, pInDlssEvalParams->GBufferSurface.pInAttrib[9]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_10, pInDlssEvalParams->GBufferSurface.pInAttrib[10]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_11, pInDlssEvalParams->GBufferSurface.pInAttrib[11]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_12, pInDlssEvalParams->GBufferSurface.pInAttrib[12]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_13, pInDlssEvalParams->GBufferSurface.pInAttrib[13]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_14, pInDlssEvalParams->GBufferSurface.pInAttrib[14]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_15, pInDlssEvalParams->GBufferSurface.pInAttrib[15]);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_TonemapperType, pInDlssEvalParams->InToneMapperType);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors3D, pInDlssEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_IsParticleMask, pInDlssEvalParams->pInIsParticleMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_AnimatedTextureMask, pInDlssEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DepthHighRes, pInDlssEvalParams->pInDepthHighRes);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Position_ViewSpace, pInDlssEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_FrameTimeDeltaInMsec, pInDlssEvalParams->InFrameTimeDeltaInMsec);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_RayTracingHitDistance, pInDlssEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_MotionVectorsReflection, pInDlssEvalParams->pInMotionVectorsReflections);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, pInDlssEvalParams->InColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y, pInDlssEvalParams->InColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, pInDlssEvalParams->InDepthSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y, pInDlssEvalParams->InDepthSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, pInDlssEvalParams->InMVSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y, pInDlssEvalParams->InMVSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_X, pInDlssEvalParams->InTranslucencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_Y, pInDlssEvalParams->InTranslucencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, pInDlssEvalParams->InBiasCurrentColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y, pInDlssEvalParams->InBiasCurrentColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, pInDlssEvalParams->InOutputSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y, pInDlssEvalParams->InOutputSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width , pInDlssEvalParams->InRenderSubrectDimensions.Width);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, pInDlssEvalParams->InRenderSubrectDimensions.Height);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Pre_Exposure, pInDlssEvalParams->InPreExposure == 0.0f ? 1.0f : pInDlssEvalParams->InPreExposure);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Exposure_Scale, pInDlssEvalParams->InExposureScale == 0.0f ? 1.0f : pInDlssEvalParams->InExposureScale);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_X_Axis, pInDlssEvalParams->InIndicatorInvertXAxis);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_Y_Axis, pInDlssEvalParams->InIndicatorInvertYAxis);
+
+    return NVSDK_NGX_D3D11_EvaluateFeature_C(pInCtx, pInHandle, pInParams, NULL);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D11_CREATE_DLISP_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_Feature_Create_Params *pDlispCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pDlispCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pDlispCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pDlispCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pDlispCreateParams->InTargetHeight);
+
+    return NVSDK_NGX_D3D11_CreateFeature(pInCtx, NVSDK_NGX_Feature_ImageSignalProcessing, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_CUDA_CREATE_DLISP_EXT(
+    NVSDK_NGX_Handle** ppOutHandle,
+    NVSDK_NGX_Parameter* pInParams,
+    NVSDK_NGX_Feature_Create_Params* pDlispCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pDlispCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pDlispCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pDlispCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pDlispCreateParams->InTargetHeight);
+
+    return NVSDK_NGX_CUDA_CreateFeature(NVSDK_NGX_Feature_ImageSignalProcessing, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D11_EVALUATE_DLISP_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D11_DLISP_Eval_Params *pDlispEvalParams)
+{
+    if (pDlispEvalParams->Feature.InSharpness < 0.0f || pDlispEvalParams->Feature.InSharpness > 1.0f || pDlispEvalParams->InDenoise < 0.0f || pDlispEvalParams->InDenoise > 1.0f)
+    {
+        return NVSDK_NGX_Result_FAIL_InvalidParameter;
+    }
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Color, pDlispEvalParams->Feature.pInColor);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Output, pDlispEvalParams->Feature.pInOutput);
+    // Both sharpness and denoise in range [0.0f,1.0f]
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pDlispEvalParams->Feature.InSharpness);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Denoise, pDlispEvalParams->InDenoise);
+    // If input is atlas - use RECT to upscale only the required area
+    if (pDlispEvalParams->InRectW)
+    {
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_X, pDlispEvalParams->InRectX);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_Y, pDlispEvalParams->InRectY);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_W, pDlispEvalParams->InRectW);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_H, pDlispEvalParams->InRectH);
+    }
+
+    return NVSDK_NGX_D3D11_EvaluateFeature_C(pInCtx, pInHandle, pInParams, NULL);
+}
+
+static inline NVSDK_NGX_Result NGX_CUDA_EVALUATE_DLISP_EXT(
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_CUDA_DLISP_Eval_Params *pDlispEvalParams)
+{
+    if (pDlispEvalParams->Feature.InSharpness < 0.0f || pDlispEvalParams->Feature.InSharpness > 1.0f || pDlispEvalParams->InDenoise < 0.0f || pDlispEvalParams->InDenoise > 1.0f)
+    {
+        return NVSDK_NGX_Result_FAIL_InvalidParameter;
+    }
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Color, pDlispEvalParams->Feature.pInColor);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Output, pDlispEvalParams->Feature.pInOutput);
+    // Both sharpness and denoise in range [0.0f,1.0f]
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pDlispEvalParams->Feature.InSharpness);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Denoise, pDlispEvalParams->InDenoise);
+    // If input is atlas - use RECT to upscale only the required area
+    if (pDlispEvalParams->InRectW)
+    {
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_X, pDlispEvalParams->InRectX);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_Y, pDlispEvalParams->InRectY);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_W, pDlispEvalParams->InRectW);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_H, pDlispEvalParams->InRectH);
+    }
+
+    return NVSDK_NGX_CUDA_EvaluateFeature_C(pInHandle, pInParams, NULL);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D11_CREATE_DLRESOLVE_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_Feature_Create_Params *pDlresolveCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pDlresolveCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pDlresolveCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pDlresolveCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pDlresolveCreateParams->InTargetHeight);
+
+    return NVSDK_NGX_D3D11_CreateFeature(pInCtx, NVSDK_NGX_Feature_DeepResolve, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D11_EVALUATE_DLRESOLVE_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle *InHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D11_Feature_Eval_Params *pDlresolveEvalParams)
+{
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Color, pDlresolveEvalParams->pInColor);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Output, pDlresolveEvalParams->pInOutput);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pDlresolveEvalParams->InSharpness);
+
+    return NVSDK_NGX_D3D11_EvaluateFeature_C(pInCtx, InHandle, pInParams, NULL);
+}
+
+/*** D3D12 ***/
+typedef struct NVSDK_NGX_D3D12_Feature_Eval_Params
+{
+    ID3D12Resource*  pInColor;
+    ID3D12Resource*  pInOutput;
+    /*** OPTIONAL for DLSS ***/
+    float       InSharpness;
+} NVSDK_NGX_D3D12_Feature_Eval_Params;
+
+typedef struct NVSDK_NGX_D3D12_GBuffer
+{
+    ID3D12Resource* pInAttrib[NVSDK_NGX_GBUFFERTYPE_NUM];
+} NVSDK_NGX_D3D12_GBuffer;
+
+typedef struct NVSDK_NGX_D3D12_DLSS_Eval_Params
+{
+    NVSDK_NGX_D3D12_Feature_Eval_Params Feature;
+    ID3D12Resource*                     pInDepth;
+    ID3D12Resource*                     pInMotionVectors;
+    float                               InJitterOffsetX;     /* Jitter offset must be in input/render pixel space */
+    float                               InJitterOffsetY;
+    NVSDK_NGX_Dimensions                InRenderSubrectDimensions;
+    /*** OPTIONAL - leave to 0/0.0f if unused ***/
+    int                                 InReset;             /* Set to 1 when scene changes completely (new level etc) */
+    float                               InMVScaleX;          /* If MVs need custom scaling to convert to pixel space */
+    float                               InMVScaleY;
+    ID3D12Resource*                     pInTransparencyMask; /* Unused/Reserved for future use */
+    ID3D12Resource*                     pInExposureTexture;
+    ID3D12Resource*                     pInBiasCurrentColorMask;
+    NVSDK_NGX_Coordinates               InColorSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthSubrectBase;
+    NVSDK_NGX_Coordinates               InMVSubrectBase;
+    NVSDK_NGX_Coordinates               InTranslucencySubrectBase;
+    NVSDK_NGX_Coordinates               InBiasCurrentColorSubrectBase;
+    NVSDK_NGX_Coordinates               InOutputSubrectBase;
+    float                               InPreExposure;
+    float                               InExposureScale;
+    int                                 InIndicatorInvertXAxis;
+    int                                 InIndicatorInvertYAxis;
+    /*** OPTIONAL - only for research purposes ***/
+    NVSDK_NGX_D3D12_GBuffer             GBufferSurface;
+    NVSDK_NGX_ToneMapperType            InToneMapperType;
+    ID3D12Resource*                     pInMotionVectors3D;
+    ID3D12Resource*                     pInIsParticleMask; /* to identify which pixels contains particles, essentially that are not drawn as part of base pass */
+    ID3D12Resource*                     pInAnimatedTextureMask; /* a binary mask covering pixels occupied by animated textures */
+    ID3D12Resource*                     pInDepthHighRes;
+    ID3D12Resource*                     pInPositionViewSpace;
+    float                               InFrameTimeDeltaInMsec; /* helps in determining the amount to denoise or anti-alias based on the speed of the object from motion vector magnitudes and fps as determined by this delta */
+    ID3D12Resource*                     pInRayTracingHitDistance; /* for each effect - approximation to the amount of noise in a ray-traced color */
+    ID3D12Resource*                     pInMotionVectorsReflections; /* motion vectors of reflected objects like for mirrored surfaces */
+} NVSDK_NGX_D3D12_DLSS_Eval_Params;
+
+typedef struct NVSDK_NGX_D3D12_DLISP_Eval_Params
+{
+    NVSDK_NGX_D3D12_Feature_Eval_Params Feature;
+    /*** OPTIONAL ***/
+    unsigned int                        InRectX;
+    unsigned int                        InRectY;
+    unsigned int                        InRectW;
+    unsigned int                        InRectH;
+    float                               InDenoise;
+} NVSDK_NGX_D3D12_DLISP_Eval_Params;
+
+
+static inline NVSDK_NGX_Result NGX_D3D12_CREATE_DLSS_EXT(
+    ID3D12GraphicsCommandList *pInCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_DLSS_Create_Params *pInDlssCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlssCreateParams->Feature.InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlssCreateParams->Feature.InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlssCreateParams->Feature.InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlssCreateParams->Feature.InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pInDlssCreateParams->Feature.InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, pInDlssCreateParams->InFeatureCreateFlags);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Enable_Output_Subrects, pInDlssCreateParams->InEnableOutputSubrects ? 1 : 0);
+
+    return NVSDK_NGX_D3D12_CreateFeature(pInCmdList, NVSDK_NGX_Feature_SuperSampling, pInParams, ppOutHandle);
+}
+
+
+static inline NVSDK_NGX_Result NGX_D3D12_EVALUATE_DLSS_EXT(
+    ID3D12GraphicsCommandList *pInCmdList,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D12_DLSS_Eval_Params *pInDlssEvalParams)
+{
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Color, pInDlssEvalParams->Feature.pInColor);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Output, pInDlssEvalParams->Feature.pInOutput);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Depth, pInDlssEvalParams->pInDepth);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors, pInDlssEvalParams->pInMotionVectors);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_X, pInDlssEvalParams->InJitterOffsetX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_Y, pInDlssEvalParams->InJitterOffsetY);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pInDlssEvalParams->Feature.InSharpness);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_Reset, pInDlssEvalParams->InReset);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_X, pInDlssEvalParams->InMVScaleX == 0.0f ? 1.0f : pInDlssEvalParams->InMVScaleX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_Y, pInDlssEvalParams->InMVScaleY == 0.0f ? 1.0f : pInDlssEvalParams->InMVScaleY);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_TransparencyMask, pInDlssEvalParams->pInTransparencyMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_ExposureTexture, pInDlssEvalParams->pInExposureTexture);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, pInDlssEvalParams->pInBiasCurrentColorMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Albedo, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ALBEDO]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ROUGHNESS]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Metallic, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_METALLIC]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Specular, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SPECULAR]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Subsurface, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SUBSURFACE]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_NORMALS]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_ShadingModelId, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SHADINGMODELID]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_MaterialId, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_MATERIALID]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_8, pInDlssEvalParams->GBufferSurface.pInAttrib[8]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_9, pInDlssEvalParams->GBufferSurface.pInAttrib[9]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_10, pInDlssEvalParams->GBufferSurface.pInAttrib[10]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_11, pInDlssEvalParams->GBufferSurface.pInAttrib[11]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_12, pInDlssEvalParams->GBufferSurface.pInAttrib[12]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_13, pInDlssEvalParams->GBufferSurface.pInAttrib[13]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_14, pInDlssEvalParams->GBufferSurface.pInAttrib[14]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_15, pInDlssEvalParams->GBufferSurface.pInAttrib[15]);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_TonemapperType, pInDlssEvalParams->InToneMapperType);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors3D, pInDlssEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_IsParticleMask, pInDlssEvalParams->pInIsParticleMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_AnimatedTextureMask, pInDlssEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DepthHighRes, pInDlssEvalParams->pInDepthHighRes);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Position_ViewSpace, pInDlssEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_FrameTimeDeltaInMsec, pInDlssEvalParams->InFrameTimeDeltaInMsec);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_RayTracingHitDistance, pInDlssEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_MotionVectorsReflection, pInDlssEvalParams->pInMotionVectorsReflections);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, pInDlssEvalParams->InColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y, pInDlssEvalParams->InColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, pInDlssEvalParams->InDepthSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y, pInDlssEvalParams->InDepthSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, pInDlssEvalParams->InMVSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y, pInDlssEvalParams->InMVSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_X, pInDlssEvalParams->InTranslucencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_Y, pInDlssEvalParams->InTranslucencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, pInDlssEvalParams->InBiasCurrentColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y, pInDlssEvalParams->InBiasCurrentColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, pInDlssEvalParams->InOutputSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y, pInDlssEvalParams->InOutputSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width , pInDlssEvalParams->InRenderSubrectDimensions.Width);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, pInDlssEvalParams->InRenderSubrectDimensions.Height);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Pre_Exposure, pInDlssEvalParams->InPreExposure == 0.0f ? 1.0f : pInDlssEvalParams->InPreExposure);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Exposure_Scale, pInDlssEvalParams->InExposureScale == 0.0f ? 1.0f : pInDlssEvalParams->InExposureScale);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_X_Axis, pInDlssEvalParams->InIndicatorInvertXAxis);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_Y_Axis, pInDlssEvalParams->InIndicatorInvertYAxis);
+
+    return NVSDK_NGX_D3D12_EvaluateFeature_C(pInCmdList, pInHandle, pInParams, NULL);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D12_CREATE_DLISP_EXT(
+    ID3D12GraphicsCommandList *InCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_Feature_Create_Params *pDlispCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pDlispCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pDlispCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pDlispCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pDlispCreateParams->InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pDlispCreateParams->InPerfQualityValue);
+
+    return NVSDK_NGX_D3D12_CreateFeature(InCmdList, NVSDK_NGX_Feature_ImageSignalProcessing, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D12_EVALUATE_DLISP_EXT(
+    ID3D12GraphicsCommandList *pInCmdList,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D12_DLISP_Eval_Params *pDlispEvalParams)
+{
+    if (pDlispEvalParams->Feature.InSharpness < 0.0f || pDlispEvalParams->Feature.InSharpness > 1.0f || pDlispEvalParams->InDenoise < 0.0f || pDlispEvalParams->InDenoise > 1.0f)
+    {
+        return NVSDK_NGX_Result_FAIL_InvalidParameter;
+    }
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Color, pDlispEvalParams->Feature.pInColor);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Output, pDlispEvalParams->Feature.pInOutput);
+    // Both sharpness and denoise in range [0.0f,1.0f]
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pDlispEvalParams->Feature.InSharpness);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Denoise, pDlispEvalParams->InDenoise);
+    // If input is atlas - use RECT to upscale only the required area
+    if (pDlispEvalParams->InRectW)
+    {
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_X, pDlispEvalParams->InRectX);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_Y, pDlispEvalParams->InRectY);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_W, pDlispEvalParams->InRectW);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_H, pDlispEvalParams->InRectH);
+    }
+    return NVSDK_NGX_D3D12_EvaluateFeature_C(pInCmdList, pInHandle, pInParams, NULL);
+}
+
+
+static inline NVSDK_NGX_Result NGX_D3D12_CREATE_DLRESOLVE_EXT(
+    ID3D12GraphicsCommandList *pInCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_Feature_Create_Params *pDlresolveCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pDlresolveCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pDlresolveCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pDlresolveCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pDlresolveCreateParams->InTargetHeight);
+
+    return NVSDK_NGX_D3D12_CreateFeature(pInCmdList, NVSDK_NGX_Feature_DeepResolve, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D12_EVALUATE_DLRESOLVE_EXT(
+    ID3D12GraphicsCommandList *pInCmdList,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D12_Feature_Eval_Params *pDlresolveEvalParams)
+{
+    // This call to NVSDK_NGX_Parameter_SetXXX() is equivalent to the Params->Set below functionally
+    // but to work around the lack of virtual functions and polymorphism in a C only project
+    // we introduced this new way to set params.
+    // The test should enforce that both paths work.
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Color, pDlresolveEvalParams->pInColor);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Output, pDlresolveEvalParams->pInOutput);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pDlresolveEvalParams->InSharpness);
+
+    return NVSDK_NGX_D3D12_EvaluateFeature_C(pInCmdList, pInHandle, pInParams, NULL);
+}
+
+#endif

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_helpers_dlssd.h

@@ -0,0 +1,695 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#ifndef NVSDK_NGX_HELPERS_DLSSD_H
+#define NVSDK_NGX_HELPERS_DLSSD_H
+#pragma once
+
+#include "nvsdk_ngx_helpers.h"
+#include "nvsdk_ngx_defs_dlssd.h"
+#include "nvsdk_ngx_params_dlssd.h"
+
+typedef NVSDK_NGX_Result(NVSDK_CONV* PFN_NVSDK_NGX_DLSS_GetStatsCallback)(NVSDK_NGX_Parameter* InParams);
+
+static inline NVSDK_NGX_Result NGX_DLSSD_GET_STATS_2(
+    NVSDK_NGX_Parameter* pInParams,
+    unsigned long long* pVRAMAllocatedBytes,
+    unsigned int* pOptLevel, unsigned int* IsDevSnippetBranch)
+{
+    void* Callback = NULL;
+    NVSDK_NGX_Parameter_GetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSDGetStatsCallback, &Callback);
+    if (!Callback)
+    {
+        // Possible reasons for this:
+        // - Installed DLSS is out of date and does not support the feature we need
+        // - You used NVSDK_NGX_AllocateParameters() for creating InParams. Try using NVSDK_NGX_GetCapabilityParameters() instead
+        return NVSDK_NGX_Result_FAIL_OutOfDate;
+    }
+
+    NVSDK_NGX_Result Res = NVSDK_NGX_Result_Success;
+    PFN_NVSDK_NGX_DLSS_GetStatsCallback PFNCallback = (PFN_NVSDK_NGX_DLSS_GetStatsCallback)Callback;
+    Res = PFNCallback(pInParams);
+    if (NVSDK_NGX_FAILED(Res))
+    {
+        return Res;
+    }
+    NVSDK_NGX_Parameter_GetULL(pInParams, NVSDK_NGX_Parameter_SizeInBytes, pVRAMAllocatedBytes);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_EParameter_OptLevel, pOptLevel);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_EParameter_IsDevSnippetBranch, IsDevSnippetBranch);
+    return Res;
+}
+
+static inline NVSDK_NGX_Result NGX_DLSSD_GET_STATS_1(
+    NVSDK_NGX_Parameter* pInParams,
+    unsigned long long* pVRAMAllocatedBytes,
+    unsigned int* pOptLevel)
+{
+    unsigned int dummy = 0;
+    return NGX_DLSSD_GET_STATS_2(pInParams, pVRAMAllocatedBytes, pOptLevel, &dummy);
+}
+
+static inline NVSDK_NGX_Result NGX_DLSSD_GET_STATS(
+    NVSDK_NGX_Parameter* pInParams,
+    unsigned long long* pVRAMAllocatedBytes)
+{
+    unsigned int dummy = 0;
+    return NGX_DLSSD_GET_STATS_2(pInParams, pVRAMAllocatedBytes, &dummy, &dummy);
+}
+
+typedef NVSDK_NGX_Result(NVSDK_CONV* PFN_NVSDK_NGX_DLSS_GetOptimalSettingsCallback)(NVSDK_NGX_Parameter* InParams);
+
+static inline NVSDK_NGX_Result NGX_DLSSD_GET_OPTIMAL_SETTINGS(
+    NVSDK_NGX_Parameter* pInParams,
+    unsigned int InUserSelectedWidth,
+    unsigned int InUserSelectedHeight,
+    NVSDK_NGX_PerfQuality_Value InPerfQualityValue,
+    unsigned int* pOutRenderOptimalWidth,
+    unsigned int* pOutRenderOptimalHeight,
+    unsigned int* pOutRenderMaxWidth,
+    unsigned int* pOutRenderMaxHeight,
+    unsigned int* pOutRenderMinWidth,
+    unsigned int* pOutRenderMinHeight,
+    float* pOutSharpness)
+{
+    void* Callback = NULL;
+    NVSDK_NGX_Parameter_GetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSDOptimalSettingsCallback, &Callback);
+    if (!Callback)
+    {
+        // Possible reasons for this:
+        // - Installed DLSS is out of date and does not support the feature we need
+        // - You used NVSDK_NGX_AllocateParameters() for creating InParams. Try using NVSDK_NGX_GetCapabilityParameters() instead
+        return NVSDK_NGX_Result_FAIL_OutOfDate;
+    }
+
+    // These are selections made by user in UI
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, InUserSelectedWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, InUserSelectedHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_RTXValue, false); // Some older DLSS dlls still expect this value to be set
+
+    NVSDK_NGX_Result Res = NVSDK_NGX_Result_Success;
+    PFN_NVSDK_NGX_DLSS_GetOptimalSettingsCallback PFNCallback = (PFN_NVSDK_NGX_DLSS_GetOptimalSettingsCallback)Callback;
+    Res = PFNCallback(pInParams);
+    if (NVSDK_NGX_FAILED(Res))
+    {
+        return Res;
+    }
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pOutRenderOptimalWidth);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pOutRenderOptimalHeight);
+    // If we have an older DLSS Dll those might need to be set to the optimal dimensions instead
+    *pOutRenderMaxWidth = *pOutRenderOptimalWidth;
+    *pOutRenderMaxHeight = *pOutRenderOptimalHeight;
+    *pOutRenderMinWidth = *pOutRenderOptimalWidth;
+    *pOutRenderMinHeight = *pOutRenderOptimalHeight;
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Max_Render_Width, pOutRenderMaxWidth);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Max_Render_Height, pOutRenderMaxHeight);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Min_Render_Width, pOutRenderMinWidth);
+    NVSDK_NGX_Parameter_GetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Get_Dynamic_Min_Render_Height, pOutRenderMinHeight);
+    NVSDK_NGX_Parameter_GetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pOutSharpness);
+    return Res;
+}
+
+typedef struct NVSDK_NGX_D3D11_DLSSD_Eval_Params
+{
+    ID3D11Resource*                     pInDiffuseAlbedo;
+    ID3D11Resource*                     pInSpecularAlbedo;
+    ID3D11Resource*                     pInNormals;
+    ID3D11Resource*                     pInRoughness;
+
+    ID3D11Resource*                     pInColor;
+    ID3D11Resource*                     pInOutput;
+    ID3D11Resource*                     pInDepth;
+    ID3D11Resource*                     pInMotionVectors;
+    float                               InJitterOffsetX;     /* Jitter offset must be in input/render pixel space */
+    float                               InJitterOffsetY;
+    NVSDK_NGX_Dimensions                InRenderSubrectDimensions;
+    /*** OPTIONAL - leave to 0/0.0f if unused ***/
+    int                                 InReset;             /* Set to 1 when scene changes completely (new level etc) */
+    float                               InMVScaleX;          /* If MVs need custom scaling to convert to pixel space */
+    float                               InMVScaleY;
+    ID3D11Resource*                     pInTransparencyMask; /* Unused/Reserved for future use */
+    ID3D11Resource*                     pInExposureTexture;
+    ID3D11Resource*                     pInBiasCurrentColorMask;
+    NVSDK_NGX_Coordinates               InDiffuseAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InNormalsSubrectBase;
+    NVSDK_NGX_Coordinates               InRoughnessSubrectBase;
+    NVSDK_NGX_Coordinates               InColorSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthSubrectBase;
+    NVSDK_NGX_Coordinates               InMVSubrectBase;
+    NVSDK_NGX_Coordinates               InTranslucencySubrectBase;
+    NVSDK_NGX_Coordinates               InBiasCurrentColorSubrectBase;
+    NVSDK_NGX_Coordinates               InOutputSubrectBase;
+
+    ID3D11Resource*                     pInReflectedAlbedo;
+    ID3D11Resource*                     pInColorBeforeParticles;
+    ID3D11Resource*                     pInColorAfterParticles;
+    ID3D11Resource*                     pInColorBeforeTransparency;
+    ID3D11Resource*                     pInColorAfterTransparency;
+    ID3D11Resource*                     pInColorBeforeFog;
+    ID3D11Resource*                     pInColorAfterFog;
+    ID3D11Resource*                     pInScreenSpaceSubsurfaceScatteringGuide;
+    ID3D11Resource*                     pInColorBeforeScreenSpaceSubsurfaceScattering;
+    ID3D11Resource*                     pInColorAfterScreenSpaceSubsurfaceScattering;
+    ID3D11Resource*                     pInScreenSpaceRefractionGuide;
+    ID3D11Resource*                     pInColorBeforeScreenSpaceRefraction;
+    ID3D11Resource*                     pInColorAfterScreenSpaceRefraction;
+    ID3D11Resource*                     pInDepthOfFieldGuide;
+    ID3D11Resource*                     pInColorBeforeDepthOfField;
+    ID3D11Resource*                     pInColorAfterDepthOfField;
+    ID3D11Resource*                     pInDiffuseHitDistance;
+    ID3D11Resource*                     pInSpecularHitDistance;
+    ID3D11Resource*                     pInDiffuseRayDirection;
+    ID3D11Resource*                     pInSpecularRayDirection;
+    ID3D11Resource*                     pInDiffuseRayDirectionHitDistance;
+    ID3D11Resource*                     pInSpecularRayDirectionHitDistance;
+    NVSDK_NGX_Coordinates               InReflectedAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeParticlesSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterParticlesSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeTransparencySubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterTransparencySubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeFogSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterFogSubrectBase;
+    NVSDK_NGX_Coordinates               InScreenSpaceSubsurfaceScatteringGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InScreenSpaceRefractionGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthOfFieldGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseRayDirectionSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularRayDirectionSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseRayDirectionHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularRayDirectionHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeScreenSpaceRefractionSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterScreenSpaceRefractionSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeDepthOfFieldSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterDepthOfFieldSubtectBase;
+    float*                              pInWorldToViewMatrix;
+    float*                              pInViewToClipMatrix;
+
+    float                               InPreExposure;
+    float                               InExposureScale;
+    int                                 InIndicatorInvertXAxis;
+    int                                 InIndicatorInvertYAxis;
+    /*** OPTIONAL - only for research purposes ***/
+    NVSDK_NGX_D3D11_GBuffer             GBufferSurface;
+    NVSDK_NGX_ToneMapperType            InToneMapperType;
+    ID3D11Resource*                     pInMotionVectors3D;
+    ID3D11Resource*                     pInIsParticleMask; /* to identify which pixels contains particles, essentially that are not drawn as part of base pass */
+    ID3D11Resource*                     pInAnimatedTextureMask; /* a binary mask covering pixels occupied by animated textures */
+    ID3D11Resource*                     pInDepthHighRes;
+    ID3D11Resource*                     pInPositionViewSpace;
+    float                               InFrameTimeDeltaInMsec; /* helps in determining the amount to denoise or anti-alias based on the speed of the object from motion vector magnitudes and fps as determined by this delta */
+    ID3D11Resource*                     pInRayTracingHitDistance; /* for each effect - approximation to the amount of noise in a ray-traced color */
+    ID3D11Resource*                     pInMotionVectorsReflections; /* motion vectors of reflected objects like for mirrored surfaces */
+    ID3D11Resource*                     pInTransparencyLayer; /* optional input res particle layer */
+    NVSDK_NGX_Coordinates               InTransparencyLayerSubrectBase;
+    ID3D11Resource*                     pInTransparencyLayerOpacity; /* optional input res particle opacity layer */
+    NVSDK_NGX_Coordinates               InTransparencyLayerOpacitySubrectBase;
+    ID3D11Resource*                     pInTransparencyLayerMvecs; /* optional input res transparency layer mvecs */
+    NVSDK_NGX_Coordinates               InTransparencyLayerMvecsSubrectBase;
+    ID3D11Resource*                     pInDisocclusionMask; /* optional input res disocclusion mask */
+    NVSDK_NGX_Coordinates               InDisocclusionMaskSubrectBase;
+} NVSDK_NGX_D3D11_DLSSD_Eval_Params;
+
+static inline NVSDK_NGX_Result NGX_D3D11_CREATE_DLSSD_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_DLSSD_Create_Params *pInDlssDCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlssDCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlssDCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlssDCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlssDCreateParams->InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pInDlssDCreateParams->InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, pInDlssDCreateParams->InFeatureCreateFlags);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Enable_Output_Subrects, pInDlssDCreateParams->InEnableOutputSubrects ? 1 : 0);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Denoise_Mode, NVSDK_NGX_DLSS_Denoise_Mode_DLUnified);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Roughness_Mode, pInDlssDCreateParams->InRoughnessMode);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Use_HW_Depth, pInDlssDCreateParams->InUseHWDepth);
+
+    return NVSDK_NGX_D3D11_CreateFeature(pInCtx, NVSDK_NGX_Feature_RayReconstruction, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D11_EVALUATE_DLSSD_EXT(
+    ID3D11DeviceContext *pInCtx,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D11_DLSSD_Eval_Params *pInDlssDEvalParams)
+{
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Color, pInDlssDEvalParams->pInColor);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Output, pInDlssDEvalParams->pInOutput);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Depth, pInDlssDEvalParams->pInDepth);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors, pInDlssDEvalParams->pInMotionVectors);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_X, pInDlssDEvalParams->InJitterOffsetX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_Y, pInDlssDEvalParams->InJitterOffsetY);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_Reset, pInDlssDEvalParams->InReset);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_X, pInDlssDEvalParams->InMVScaleX == 0.0f ? 1.0f : pInDlssDEvalParams->InMVScaleX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_Y, pInDlssDEvalParams->InMVScaleY == 0.0f ? 1.0f : pInDlssDEvalParams->InMVScaleY);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_TransparencyMask, pInDlssDEvalParams->pInTransparencyMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_ExposureTexture, pInDlssDEvalParams->pInExposureTexture);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, pInDlssDEvalParams->pInBiasCurrentColorMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Albedo, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ALBEDO]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ROUGHNESS]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Metallic, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_METALLIC]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Specular, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SPECULAR]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Subsurface, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SUBSURFACE]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_NORMALS]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_ShadingModelId, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SHADINGMODELID]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_MaterialId, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_MATERIALID]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_8, pInDlssDEvalParams->GBufferSurface.pInAttrib[8]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_9, pInDlssDEvalParams->GBufferSurface.pInAttrib[9]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_SpecularMvec, pInDlssDEvalParams->pInMotionVectorsReflections);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_11, pInDlssDEvalParams->GBufferSurface.pInAttrib[11]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_12, pInDlssDEvalParams->GBufferSurface.pInAttrib[12]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_13, pInDlssDEvalParams->GBufferSurface.pInAttrib[13]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_14, pInDlssDEvalParams->GBufferSurface.pInAttrib[14]);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_15, pInDlssDEvalParams->GBufferSurface.pInAttrib[15]);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_TonemapperType, pInDlssDEvalParams->InToneMapperType);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors3D, pInDlssDEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_IsParticleMask, pInDlssDEvalParams->pInIsParticleMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_AnimatedTextureMask, pInDlssDEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DepthHighRes, pInDlssDEvalParams->pInDepthHighRes);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_Position_ViewSpace, pInDlssDEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_FrameTimeDeltaInMsec, pInDlssDEvalParams->InFrameTimeDeltaInMsec);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_RayTracingHitDistance, pInDlssDEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, pInDlssDEvalParams->InColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y, pInDlssDEvalParams->InColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, pInDlssDEvalParams->InDepthSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y, pInDlssDEvalParams->InDepthSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, pInDlssDEvalParams->InMVSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y, pInDlssDEvalParams->InMVSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_X, pInDlssDEvalParams->InTranslucencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_Y, pInDlssDEvalParams->InTranslucencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, pInDlssDEvalParams->InBiasCurrentColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y, pInDlssDEvalParams->InBiasCurrentColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, pInDlssDEvalParams->InOutputSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y, pInDlssDEvalParams->InOutputSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width , pInDlssDEvalParams->InRenderSubrectDimensions.Width);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, pInDlssDEvalParams->InRenderSubrectDimensions.Height);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Pre_Exposure, pInDlssDEvalParams->InPreExposure == 0.0f ? 1.0f : pInDlssDEvalParams->InPreExposure);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Exposure_Scale, pInDlssDEvalParams->InExposureScale == 0.0f ? 1.0f : pInDlssDEvalParams->InExposureScale);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_X_Axis, pInDlssDEvalParams->InIndicatorInvertXAxis);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_Y_Axis, pInDlssDEvalParams->InIndicatorInvertYAxis);
+
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DiffuseAlbedo, pInDlssDEvalParams->pInDiffuseAlbedo);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_SpecularAlbedo, pInDlssDEvalParams->pInSpecularAlbedo);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_X, pInDlssDEvalParams->InDiffuseAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_X, pInDlssDEvalParams->InSpecularAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InSpecularAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_X, pInDlssDEvalParams->InNormalsSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_Y, pInDlssDEvalParams->InNormalsSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_X, pInDlssDEvalParams->InRoughnessSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_Y, pInDlssDEvalParams->InRoughnessSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Emissive, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_EMISSIVE]);
+
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo, pInDlssDEvalParams->pInReflectedAlbedo);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles, pInDlssDEvalParams->pInColorBeforeParticles);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles, pInDlssDEvalParams->pInColorAfterParticles);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency, pInDlssDEvalParams->pInColorBeforeTransparency);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency, pInDlssDEvalParams->pInColorAfterTransparency);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog, pInDlssDEvalParams->pInColorBeforeFog);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog, pInDlssDEvalParams->pInColorAfterFog);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide, pInDlssDEvalParams->pInScreenSpaceSubsurfaceScatteringGuide);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering, pInDlssDEvalParams->pInColorBeforeScreenSpaceSubsurfaceScattering);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering, pInDlssDEvalParams->pInColorAfterScreenSpaceSubsurfaceScattering);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide, pInDlssDEvalParams->pInScreenSpaceRefractionGuide);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction, pInDlssDEvalParams->pInColorBeforeScreenSpaceRefraction);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction, pInDlssDEvalParams->pInColorAfterScreenSpaceRefraction);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide, pInDlssDEvalParams->pInDepthOfFieldGuide);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField, pInDlssDEvalParams->pInColorBeforeDepthOfField);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField, pInDlssDEvalParams->pInColorAfterDepthOfField);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance, pInDlssDEvalParams->pInDiffuseHitDistance);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance, pInDlssDEvalParams->pInSpecularHitDistance);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection, pInDlssDEvalParams->pInDiffuseRayDirection);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection, pInDlssDEvalParams->pInSpecularRayDirection);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance, pInDlssDEvalParams->pInDiffuseRayDirectionHitDistance);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance, pInDlssDEvalParams->pInSpecularRayDirectionHitDistance);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_X, pInDlssDEvalParams->InReflectedAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InReflectedAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_X, pInDlssDEvalParams->InColorAfterParticlesSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterParticlesSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeParticlesSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeParticlesSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeTransparencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeTransparencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_X, pInDlssDEvalParams->InColorAfterTransparencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterTransparencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeFogSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeFogSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_X, pInDlssDEvalParams->InColorAfterFogSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterFogSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_X, pInDlssDEvalParams->InScreenSpaceSubsurfaceScatteringGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_Y, pInDlssDEvalParams->InScreenSpaceSubsurfaceScatteringGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_X, pInDlssDEvalParams->InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_X, pInDlssDEvalParams->InScreenSpaceRefractionGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_Y, pInDlssDEvalParams->InScreenSpaceRefractionGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeScreenSpaceRefractionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeScreenSpaceRefractionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_X, pInDlssDEvalParams->InColorAfterScreenSpaceRefractionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterScreenSpaceRefractionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_X, pInDlssDEvalParams->InDepthOfFieldGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_Y, pInDlssDEvalParams->InDepthOfFieldGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeDepthOfFieldSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeDepthOfFieldSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_X, pInDlssDEvalParams->InColorAfterDepthOfFieldSubtectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterDepthOfFieldSubtectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_X, pInDlssDEvalParams->InDiffuseHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_X, pInDlssDEvalParams->InSpecularHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InSpecularHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_X, pInDlssDEvalParams->InDiffuseRayDirectionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseRayDirectionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_X, pInDlssDEvalParams->InSpecularRayDirectionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_Y, pInDlssDEvalParams->InSpecularRayDirectionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_X, pInDlssDEvalParams->InDiffuseRayDirectionHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseRayDirectionHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_X, pInDlssDEvalParams->InSpecularRayDirectionHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InSpecularRayDirectionHitDistanceSubrectBase.Y);
+
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_WORLD_TO_VIEW_MATRIX, pInDlssDEvalParams->pInWorldToViewMatrix);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_VIEW_TO_CLIP_MATRIX, pInDlssDEvalParams->pInViewToClipMatrix);
+
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssDEvalParams->pInNormals);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssDEvalParams->pInRoughness);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer, pInDlssDEvalParams->pInTransparencyLayer);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity, pInDlssDEvalParams->pInTransparencyLayerOpacity);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs, pInDlssDEvalParams->pInTransparencyLayerMvecs);
+    NVSDK_NGX_Parameter_SetD3d11Resource(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask, pInDlssDEvalParams->pInDisocclusionMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerOpacitySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerOpacitySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerMvecsSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerMvecsSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_X, pInDlssDEvalParams->InDisocclusionMaskSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_Y, pInDlssDEvalParams->InDisocclusionMaskSubrectBase.Y);
+
+
+    return NVSDK_NGX_D3D11_EvaluateFeature_C(pInCtx, pInHandle, pInParams, NULL);
+}
+
+typedef struct NVSDK_NGX_D3D12_DLSSD_Eval_Params
+{
+    ID3D12Resource*                     pInDiffuseAlbedo;
+    ID3D12Resource*                     pInSpecularAlbedo;
+    ID3D12Resource*                     pInNormals;
+    ID3D12Resource*                     pInRoughness;
+
+    ID3D12Resource*                     pInColor;
+    ID3D12Resource*                     pInOutput;
+    ID3D12Resource*                     pInDepth;
+    ID3D12Resource*                     pInMotionVectors;
+    float                               InJitterOffsetX;     /* Jitter offset must be in input/render pixel space */
+    float                               InJitterOffsetY;
+    NVSDK_NGX_Dimensions                InRenderSubrectDimensions;
+    /*** OPTIONAL - leave to 0/0.0f if unused ***/
+    int                                 InReset;             /* Set to 1 when scene changes completely (new level etc) */
+    float                               InMVScaleX;          /* If MVs need custom scaling to convert to pixel space */
+    float                               InMVScaleY;
+    ID3D12Resource*                     pInTransparencyMask; /* Unused/Reserved for future use */
+    ID3D12Resource*                     pInExposureTexture;
+    ID3D12Resource*                     pInBiasCurrentColorMask;
+    NVSDK_NGX_Coordinates               InDiffuseAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InNormalsSubrectBase;
+    NVSDK_NGX_Coordinates               InRoughnessSubrectBase;
+    NVSDK_NGX_Coordinates               InColorSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthSubrectBase;
+    NVSDK_NGX_Coordinates               InMVSubrectBase;
+    NVSDK_NGX_Coordinates               InTranslucencySubrectBase;
+    NVSDK_NGX_Coordinates               InBiasCurrentColorSubrectBase;
+    NVSDK_NGX_Coordinates               InOutputSubrectBase;
+
+    ID3D12Resource*                     pInReflectedAlbedo;
+    ID3D12Resource*                     pInColorBeforeParticles;
+    ID3D12Resource*                     pInColorAfterParticles;
+    ID3D12Resource*                     pInColorBeforeTransparency;
+    ID3D12Resource*                     pInColorAfterTransparency;
+    ID3D12Resource*                     pInColorBeforeFog;
+    ID3D12Resource*                     pInColorAfterFog;
+    ID3D12Resource*                     pInScreenSpaceSubsurfaceScatteringGuide;
+    ID3D12Resource*                     pInColorBeforeScreenSpaceSubsurfaceScattering;
+    ID3D12Resource*                     pInColorAfterScreenSpaceSubsurfaceScattering;
+    ID3D12Resource*                     pInScreenSpaceRefractionGuide;
+    ID3D12Resource*                     pInColorBeforeScreenSpaceRefraction;
+    ID3D12Resource*                     pInColorAfterScreenSpaceRefraction;
+    ID3D12Resource*                     pInDepthOfFieldGuide;
+    ID3D12Resource*                     pInColorBeforeDepthOfField;
+    ID3D12Resource*                     pInColorAfterDepthOfField;
+    ID3D12Resource*                     pInDiffuseHitDistance;
+    ID3D12Resource*                     pInSpecularHitDistance;
+    ID3D12Resource*                     pInDiffuseRayDirection;
+    ID3D12Resource*                     pInSpecularRayDirection;
+    ID3D12Resource*                     pInDiffuseRayDirectionHitDistance;
+    ID3D12Resource*                     pInSpecularRayDirectionHitDistance;
+    NVSDK_NGX_Coordinates               InReflectedAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeParticlesSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterParticlesSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeTransparencySubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterTransparencySubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeFogSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterFogSubrectBase;
+    NVSDK_NGX_Coordinates               InScreenSpaceSubsurfaceScatteringGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InScreenSpaceRefractionGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthOfFieldGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseRayDirectionSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularRayDirectionSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseRayDirectionHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularRayDirectionHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeScreenSpaceRefractionSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterScreenSpaceRefractionSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeDepthOfFieldSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterDepthOfFieldSubtectBase;
+    float*                              pInWorldToViewMatrix;
+    float*                              pInViewToClipMatrix;
+
+    float                               InPreExposure;
+    float                               InExposureScale;
+    int                                 InIndicatorInvertXAxis;
+    int                                 InIndicatorInvertYAxis;
+    /*** OPTIONAL - only for research purposes ***/
+    NVSDK_NGX_D3D12_GBuffer             GBufferSurface;
+    NVSDK_NGX_ToneMapperType            InToneMapperType;
+    ID3D12Resource*                     pInMotionVectors3D;
+    ID3D12Resource*                     pInIsParticleMask; /* to identify which pixels contains particles, essentially that are not drawn as part of base pass */
+    ID3D12Resource*                     pInAnimatedTextureMask; /* a binary mask covering pixels occupied by animated textures */
+    ID3D12Resource*                     pInDepthHighRes;
+    ID3D12Resource*                     pInPositionViewSpace;
+    float                               InFrameTimeDeltaInMsec; /* helps in determining the amount to denoise or anti-alias based on the speed of the object from motion vector magnitudes and fps as determined by this delta */
+    ID3D12Resource*                     pInRayTracingHitDistance; /* for each effect - approximation to the amount of noise in a ray-traced color */
+    ID3D12Resource*                     pInMotionVectorsReflections; /* motion vectors of reflected objects like for mirrored surfaces */
+    ID3D12Resource*                     pInTransparencyLayer; /* optional input res particle layer */
+    NVSDK_NGX_Coordinates               InTransparencyLayerSubrectBase;
+    ID3D12Resource*                     pInTransparencyLayerOpacity; /* optional input res particle opacity layer */
+    NVSDK_NGX_Coordinates               InTransparencyLayerOpacitySubrectBase;
+    ID3D12Resource*                     pInTransparencyLayerMvecs; /* optional input res transparency layer mvecs */
+    NVSDK_NGX_Coordinates               InTransparencyLayerMvecsSubrectBase;
+    ID3D12Resource*                     pInDisocclusionMask; /* optional input res disocclusion mask */
+    NVSDK_NGX_Coordinates               InDisocclusionMaskSubrectBase;
+
+} NVSDK_NGX_D3D12_DLSSD_Eval_Params;
+
+static inline NVSDK_NGX_Result NGX_D3D12_CREATE_DLSSD_EXT(
+    ID3D12GraphicsCommandList *pInCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_DLSSD_Create_Params *pInDlssDCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlssDCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlssDCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlssDCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlssDCreateParams->InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pInDlssDCreateParams->InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, pInDlssDCreateParams->InFeatureCreateFlags);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Enable_Output_Subrects, pInDlssDCreateParams->InEnableOutputSubrects ? 1 : 0);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Denoise_Mode, NVSDK_NGX_DLSS_Denoise_Mode_DLUnified);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Roughness_Mode, pInDlssDCreateParams->InRoughnessMode);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Use_HW_Depth, pInDlssDCreateParams->InUseHWDepth);
+    return NVSDK_NGX_D3D12_CreateFeature(pInCmdList, NVSDK_NGX_Feature_RayReconstruction, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_D3D12_EVALUATE_DLSSD_EXT(
+    ID3D12GraphicsCommandList *pInCmdList,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_D3D12_DLSSD_Eval_Params *pInDlssDEvalParams)
+{
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Color, pInDlssDEvalParams->pInColor);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Output, pInDlssDEvalParams->pInOutput);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Depth, pInDlssDEvalParams->pInDepth);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors, pInDlssDEvalParams->pInMotionVectors);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_X, pInDlssDEvalParams->InJitterOffsetX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_Y, pInDlssDEvalParams->InJitterOffsetY);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_Reset, pInDlssDEvalParams->InReset);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_X, pInDlssDEvalParams->InMVScaleX == 0.0f ? 1.0f : pInDlssDEvalParams->InMVScaleX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_Y, pInDlssDEvalParams->InMVScaleY == 0.0f ? 1.0f : pInDlssDEvalParams->InMVScaleY);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_TransparencyMask, pInDlssDEvalParams->pInTransparencyMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_ExposureTexture, pInDlssDEvalParams->pInExposureTexture);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, pInDlssDEvalParams->pInBiasCurrentColorMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Albedo, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ALBEDO]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ROUGHNESS]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Metallic, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_METALLIC]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Specular, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SPECULAR]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Subsurface, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SUBSURFACE]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_NORMALS]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_ShadingModelId, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SHADINGMODELID]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_MaterialId, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_MATERIALID]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_8, pInDlssDEvalParams->GBufferSurface.pInAttrib[8]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_9, pInDlssDEvalParams->GBufferSurface.pInAttrib[9]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_11, pInDlssDEvalParams->GBufferSurface.pInAttrib[11]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_12, pInDlssDEvalParams->GBufferSurface.pInAttrib[12]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_13, pInDlssDEvalParams->GBufferSurface.pInAttrib[13]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_14, pInDlssDEvalParams->GBufferSurface.pInAttrib[14]);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_15, pInDlssDEvalParams->GBufferSurface.pInAttrib[15]);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_TonemapperType, pInDlssDEvalParams->InToneMapperType);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_MotionVectors3D, pInDlssDEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_IsParticleMask, pInDlssDEvalParams->pInIsParticleMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_AnimatedTextureMask, pInDlssDEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DepthHighRes, pInDlssDEvalParams->pInDepthHighRes);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_Position_ViewSpace, pInDlssDEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_FrameTimeDeltaInMsec, pInDlssDEvalParams->InFrameTimeDeltaInMsec);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_RayTracingHitDistance, pInDlssDEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_SpecularMvec, pInDlssDEvalParams->pInMotionVectorsReflections);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, pInDlssDEvalParams->InColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y, pInDlssDEvalParams->InColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, pInDlssDEvalParams->InDepthSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y, pInDlssDEvalParams->InDepthSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, pInDlssDEvalParams->InMVSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y, pInDlssDEvalParams->InMVSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_X, pInDlssDEvalParams->InTranslucencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_Y, pInDlssDEvalParams->InTranslucencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, pInDlssDEvalParams->InBiasCurrentColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y, pInDlssDEvalParams->InBiasCurrentColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, pInDlssDEvalParams->InOutputSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y, pInDlssDEvalParams->InOutputSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width , pInDlssDEvalParams->InRenderSubrectDimensions.Width);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, pInDlssDEvalParams->InRenderSubrectDimensions.Height);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Pre_Exposure, pInDlssDEvalParams->InPreExposure == 0.0f ? 1.0f : pInDlssDEvalParams->InPreExposure);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Exposure_Scale, pInDlssDEvalParams->InExposureScale == 0.0f ? 1.0f : pInDlssDEvalParams->InExposureScale);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_X_Axis, pInDlssDEvalParams->InIndicatorInvertXAxis);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_Y_Axis, pInDlssDEvalParams->InIndicatorInvertYAxis);
+
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Emissive, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_EMISSIVE]);
+
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DiffuseAlbedo, pInDlssDEvalParams->pInDiffuseAlbedo);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_SpecularAlbedo, pInDlssDEvalParams->pInSpecularAlbedo);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_X, pInDlssDEvalParams->InDiffuseAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_X, pInDlssDEvalParams->InSpecularAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InSpecularAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_X, pInDlssDEvalParams->InNormalsSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_Y, pInDlssDEvalParams->InNormalsSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_X, pInDlssDEvalParams->InRoughnessSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_Y, pInDlssDEvalParams->InRoughnessSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssDEvalParams->pInNormals);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssDEvalParams->pInRoughness);
+
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo, pInDlssDEvalParams->pInReflectedAlbedo);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles, pInDlssDEvalParams->pInColorBeforeParticles);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles, pInDlssDEvalParams->pInColorAfterParticles);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency, pInDlssDEvalParams->pInColorBeforeTransparency);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency, pInDlssDEvalParams->pInColorAfterTransparency);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog, pInDlssDEvalParams->pInColorBeforeFog);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog, pInDlssDEvalParams->pInColorAfterFog);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide, pInDlssDEvalParams->pInScreenSpaceSubsurfaceScatteringGuide);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering, pInDlssDEvalParams->pInColorBeforeScreenSpaceSubsurfaceScattering);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering, pInDlssDEvalParams->pInColorAfterScreenSpaceSubsurfaceScattering);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide, pInDlssDEvalParams->pInScreenSpaceRefractionGuide);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction, pInDlssDEvalParams->pInColorBeforeScreenSpaceRefraction);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction, pInDlssDEvalParams->pInColorAfterScreenSpaceRefraction);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide, pInDlssDEvalParams->pInDepthOfFieldGuide);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField, pInDlssDEvalParams->pInColorBeforeDepthOfField);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField, pInDlssDEvalParams->pInColorAfterDepthOfField);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance, pInDlssDEvalParams->pInDiffuseHitDistance);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance, pInDlssDEvalParams->pInSpecularHitDistance);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection, pInDlssDEvalParams->pInDiffuseRayDirection);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection, pInDlssDEvalParams->pInSpecularRayDirection);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance, pInDlssDEvalParams->pInDiffuseRayDirectionHitDistance);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance, pInDlssDEvalParams->pInSpecularRayDirectionHitDistance);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_X, pInDlssDEvalParams->InReflectedAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InReflectedAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_X, pInDlssDEvalParams->InColorAfterParticlesSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterParticlesSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeParticlesSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeParticlesSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeTransparencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeTransparencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_X, pInDlssDEvalParams->InColorAfterTransparencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterTransparencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_X, pInDlssDEvalParams->InColorAfterFogSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterFogSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeFogSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeFogSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_X, pInDlssDEvalParams->InScreenSpaceSubsurfaceScatteringGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_Y, pInDlssDEvalParams->InScreenSpaceSubsurfaceScatteringGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_X, pInDlssDEvalParams->InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_X, pInDlssDEvalParams->InScreenSpaceRefractionGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_Y, pInDlssDEvalParams->InScreenSpaceRefractionGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeScreenSpaceRefractionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeScreenSpaceRefractionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_X, pInDlssDEvalParams->InColorAfterScreenSpaceRefractionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterScreenSpaceRefractionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_X, pInDlssDEvalParams->InDepthOfFieldGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_Y, pInDlssDEvalParams->InDepthOfFieldGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeDepthOfFieldSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeDepthOfFieldSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_X, pInDlssDEvalParams->InColorAfterDepthOfFieldSubtectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterDepthOfFieldSubtectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_X, pInDlssDEvalParams->InDiffuseHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_X, pInDlssDEvalParams->InSpecularHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InSpecularHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_X, pInDlssDEvalParams->InDiffuseRayDirectionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseRayDirectionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_X, pInDlssDEvalParams->InSpecularRayDirectionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_Y, pInDlssDEvalParams->InSpecularRayDirectionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_X, pInDlssDEvalParams->InDiffuseRayDirectionHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseRayDirectionHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_X, pInDlssDEvalParams->InSpecularRayDirectionHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InSpecularRayDirectionHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_WORLD_TO_VIEW_MATRIX, pInDlssDEvalParams->pInWorldToViewMatrix);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_VIEW_TO_CLIP_MATRIX, pInDlssDEvalParams->pInViewToClipMatrix);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer, pInDlssDEvalParams->pInTransparencyLayer);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity, pInDlssDEvalParams->pInTransparencyLayerOpacity);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs, pInDlssDEvalParams->pInTransparencyLayerMvecs);
+    NVSDK_NGX_Parameter_SetD3d12Resource(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask, pInDlssDEvalParams->pInDisocclusionMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerOpacitySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerOpacitySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerMvecsSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerMvecsSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_X, pInDlssDEvalParams->InDisocclusionMaskSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_Y, pInDlssDEvalParams->InDisocclusionMaskSubrectBase.Y);
+
+    return NVSDK_NGX_D3D12_EvaluateFeature_C(pInCmdList, pInHandle, pInParams, NULL);
+}
+
+#endif // NVSDK_NGX_HELPERS_DLSSD_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_helpers_dlssd_vk.h

@@ -0,0 +1,362 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#ifndef NVSDK_NGX_HELPERS_DLSSD_VK_H
+#define NVSDK_NGX_HELPERS_DLSSD_VK_H
+#pragma once
+
+#include "nvsdk_ngx_vk.h"
+#include "nvsdk_ngx_defs_dlssd.h"
+#include "nvsdk_ngx_params_dlssd.h"
+
+typedef struct NVSDK_NGX_VK_DLSSD_Eval_Params
+{
+    NVSDK_NGX_Resource_VK*              pInDiffuseAlbedo;
+    NVSDK_NGX_Resource_VK*              pInSpecularAlbedo;
+    NVSDK_NGX_Resource_VK*              pInNormals;
+    NVSDK_NGX_Resource_VK*              pInRoughness;
+
+    NVSDK_NGX_Resource_VK*              pInColor;
+    NVSDK_NGX_Resource_VK*              pInOutput;
+    NVSDK_NGX_Resource_VK *             pInDepth;
+    NVSDK_NGX_Resource_VK *             pInMotionVectors;
+    float                               InJitterOffsetX;     /* Jitter offset must be in input/render pixel space */
+    float                               InJitterOffsetY;
+    NVSDK_NGX_Dimensions                InRenderSubrectDimensions;
+    /*** OPTIONAL - leave to 0/0.0f if unused ***/
+    int                                 InReset;             /* Set to 1 when scene changes completely (new level etc) */
+    float                               InMVScaleX;          /* If MVs need custom scaling to convert to pixel space */
+    float                               InMVScaleY;
+    NVSDK_NGX_Resource_VK *             pInTransparencyMask; /* Unused/Reserved for future use */
+    NVSDK_NGX_Resource_VK *             pInExposureTexture;
+    NVSDK_NGX_Resource_VK *             pInBiasCurrentColorMask;
+    NVSDK_NGX_Coordinates               InDiffuseAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InNormalsSubrectBase;
+    NVSDK_NGX_Coordinates               InRoughnessSubrectBase;
+    NVSDK_NGX_Coordinates               InColorSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthSubrectBase;
+    NVSDK_NGX_Coordinates               InMVSubrectBase;
+    NVSDK_NGX_Coordinates               InTranslucencySubrectBase;
+    NVSDK_NGX_Coordinates               InBiasCurrentColorSubrectBase;
+    NVSDK_NGX_Coordinates               InOutputSubrectBase;
+    float                               InPreExposure;
+    float                               InExposureScale;
+    int                                 InIndicatorInvertXAxis;
+    int                                 InIndicatorInvertYAxis;
+    /*** OPTIONAL - only for research purposes ***/
+
+    NVSDK_NGX_Resource_VK*              pInReflectedAlbedo;
+    NVSDK_NGX_Resource_VK*              pInColorBeforeParticles;
+	NVSDK_NGX_Resource_VK*              pInColorAfterParticles;
+    NVSDK_NGX_Resource_VK*              pInColorBeforeTransparency;
+	NVSDK_NGX_Resource_VK*              pInColorAfterTransparency;
+    NVSDK_NGX_Resource_VK*              pInColorBeforeFog;
+    NVSDK_NGX_Resource_VK*              pInColorAfterFog;
+    NVSDK_NGX_Resource_VK*              pInScreenSpaceSubsurfaceScatteringGuide;
+    NVSDK_NGX_Resource_VK*              pInColorBeforeScreenSpaceSubsurfaceScattering;
+	NVSDK_NGX_Resource_VK*              pInColorAfterScreenSpaceSubsurfaceScattering;
+    NVSDK_NGX_Resource_VK*              pInScreenSpaceRefractionGuide;
+	NVSDK_NGX_Resource_VK*              pInColorBeforeScreenSpaceRefraction;
+	NVSDK_NGX_Resource_VK*              pInColorAfterScreenSpaceRefraction;
+    NVSDK_NGX_Resource_VK*              pInDepthOfFieldGuide;
+    NVSDK_NGX_Resource_VK*              pInColorBeforeDepthOfField;
+    NVSDK_NGX_Resource_VK*              pInColorAfterDepthOfField;
+    NVSDK_NGX_Resource_VK*              pInDiffuseHitDistance;
+    NVSDK_NGX_Resource_VK*              pInSpecularHitDistance;
+    NVSDK_NGX_Resource_VK*              pInDiffuseRayDirection;
+    NVSDK_NGX_Resource_VK*              pInSpecularRayDirection;
+    NVSDK_NGX_Resource_VK*              pInDiffuseRayDirectionHitDistance;
+    NVSDK_NGX_Resource_VK*              pInSpecularRayDirectionHitDistance;
+    NVSDK_NGX_Coordinates               InReflectedAlbedoSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeParticlesSubrectBase;
+	NVSDK_NGX_Coordinates               InColorAfterParticlesSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeTransparencySubrectBase;
+	NVSDK_NGX_Coordinates               InColorAfterTransparencySubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeFogSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterFogSubrectBase;
+    NVSDK_NGX_Coordinates               InScreenSpaceSubsurfaceScatteringGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase;
+	NVSDK_NGX_Coordinates               InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase;
+    NVSDK_NGX_Coordinates               InScreenSpaceRefractionGuideSubrectBase;
+	NVSDK_NGX_Coordinates               InColorBeforeScreenSpaceRefractionSubrectBase;
+	NVSDK_NGX_Coordinates               InColorAfterScreenSpaceRefractionSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthOfFieldGuideSubrectBase;
+    NVSDK_NGX_Coordinates               InColorBeforeDepthOfFieldSubrectBase;
+    NVSDK_NGX_Coordinates               InColorAfterDepthOfFieldSubrectBase;    
+    NVSDK_NGX_Coordinates               InDiffuseHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseRayDirectionSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularRayDirectionSubrectBase;
+    NVSDK_NGX_Coordinates               InDiffuseRayDirectionHitDistanceSubrectBase;
+    NVSDK_NGX_Coordinates               InSpecularRayDirectionHitDistanceSubrectBase;
+    float*                              pInWorldToViewMatrix;
+    float*                              pInViewToClipMatrix;
+
+    NVSDK_NGX_VK_GBuffer                GBufferSurface;
+    NVSDK_NGX_ToneMapperType            InToneMapperType;
+    NVSDK_NGX_Resource_VK *             pInMotionVectors3D;
+    NVSDK_NGX_Resource_VK *             pInIsParticleMask; /* to identify which pixels contains particles, essentially that are not drawn as part of base pass */
+    NVSDK_NGX_Resource_VK *             pInAnimatedTextureMask; /* a binary mask covering pixels occupied by animated textures */
+    NVSDK_NGX_Resource_VK *             pInDepthHighRes;
+    NVSDK_NGX_Resource_VK *             pInPositionViewSpace;
+    float                               InFrameTimeDeltaInMsec; /* helps in determining the amount to denoise or anti-alias based on the speed of the object from motion vector magnitudes and fps as determined by this delta */
+    NVSDK_NGX_Resource_VK *             pInRayTracingHitDistance; /* for each effect - approximation to the amount of noise in a ray-traced color */
+    NVSDK_NGX_Resource_VK *             pInMotionVectorsReflections; /* motion vectors of reflected objects like for mirrored surfaces */
+    NVSDK_NGX_Resource_VK*              pInTransparencyLayer; /* optional input res particle layer */
+    NVSDK_NGX_Coordinates               InTransparencyLayerSubrectBase;
+    NVSDK_NGX_Resource_VK*              pInTransparencyLayerOpacity; /* optional input res particle opacity layer */
+    NVSDK_NGX_Coordinates               InTransparencyLayerOpacitySubrectBase;
+    NVSDK_NGX_Resource_VK*              pInTransparencyLayerMvecs; /* optional input res transparency layer mvecs */
+    NVSDK_NGX_Coordinates               InTransparencyLayerMvecsSubrectBase;
+    NVSDK_NGX_Resource_VK*              pInDisocclusionMask; /* optional input res disocclusion mask */
+    NVSDK_NGX_Coordinates               InDisocclusionMaskSubrectBase;
+} NVSDK_NGX_VK_DLSSD_Eval_Params;
+
+static inline NVSDK_NGX_Result NGX_VULKAN_CREATE_DLSSD_EXT1(
+    VkDevice InDevice,
+    VkCommandBuffer InCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_DLSSD_Create_Params *pInDlssDCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlssDCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlssDCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlssDCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlssDCreateParams->InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pInDlssDCreateParams->InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, pInDlssDCreateParams->InFeatureCreateFlags);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Enable_Output_Subrects, pInDlssDCreateParams->InEnableOutputSubrects ? 1 : 0);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Denoise_Mode, NVSDK_NGX_DLSS_Denoise_Mode_DLUnified);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Roughness_Mode, pInDlssDCreateParams->InRoughnessMode);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Use_HW_Depth, pInDlssDCreateParams->InUseHWDepth);
+
+    if (InDevice) return NVSDK_NGX_VULKAN_CreateFeature1(InDevice, InCmdList, NVSDK_NGX_Feature_RayReconstruction, pInParams, ppOutHandle);
+    else return NVSDK_NGX_VULKAN_CreateFeature(InCmdList, NVSDK_NGX_Feature_RayReconstruction, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_VULKAN_EVALUATE_DLSSD_EXT(
+    VkCommandBuffer InCmdList,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_VK_DLSSD_Eval_Params *pInDlssDEvalParams)
+{
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColor);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInMotionVectors);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInOutput);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDepth);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDiffuseAlbedo);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInSpecularAlbedo);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInTransparencyMask);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInExposureTexture);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInBiasCurrentColorMask);
+	for (size_t i = 0; i <= 15; i++)
+	{
+        NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->GBufferSurface.pInAttrib[i]);
+	}
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInIsParticleMask);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDepthHighRes);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInMotionVectorsReflections);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInReflectedAlbedo);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorBeforeParticles);
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorAfterParticles);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorBeforeTransparency);
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorAfterTransparency);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorBeforeFog);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorAfterFog);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInScreenSpaceSubsurfaceScatteringGuide);
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorBeforeScreenSpaceSubsurfaceScattering);
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorAfterScreenSpaceSubsurfaceScattering);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInScreenSpaceRefractionGuide);
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorBeforeScreenSpaceRefraction);
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorAfterScreenSpaceRefraction);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDepthOfFieldGuide);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorBeforeDepthOfField);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInColorAfterDepthOfField);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDiffuseHitDistance);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInSpecularHitDistance);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDiffuseRayDirection);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInSpecularRayDirection);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDiffuseRayDirectionHitDistance);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInSpecularRayDirectionHitDistance);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInTransparencyLayer);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInTransparencyLayerOpacity);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInTransparencyLayerMvecs);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssDEvalParams->pInDisocclusionMask);
+
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Color, pInDlssDEvalParams->pInColor);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Output, pInDlssDEvalParams->pInOutput);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Depth, pInDlssDEvalParams->pInDepth);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_MotionVectors, pInDlssDEvalParams->pInMotionVectors);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_X, pInDlssDEvalParams->InJitterOffsetX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_Y, pInDlssDEvalParams->InJitterOffsetY);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_Reset, pInDlssDEvalParams->InReset);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_X, pInDlssDEvalParams->InMVScaleX == 0.0f ? 1.0f : pInDlssDEvalParams->InMVScaleX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_Y, pInDlssDEvalParams->InMVScaleY == 0.0f ? 1.0f : pInDlssDEvalParams->InMVScaleY);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_TransparencyMask, pInDlssDEvalParams->pInTransparencyMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_ExposureTexture, pInDlssDEvalParams->pInExposureTexture);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, pInDlssDEvalParams->pInBiasCurrentColorMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Albedo, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ALBEDO]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ROUGHNESS]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Metallic, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_METALLIC]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Specular, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SPECULAR]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Subsurface, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SUBSURFACE]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_NORMALS]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_ShadingModelId, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SHADINGMODELID]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_MaterialId, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_MATERIALID]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_8, pInDlssDEvalParams->GBufferSurface.pInAttrib[8]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_9, pInDlssDEvalParams->GBufferSurface.pInAttrib[9]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_SpecularMvec, pInDlssDEvalParams->pInMotionVectorsReflections);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_11, pInDlssDEvalParams->GBufferSurface.pInAttrib[11]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_12, pInDlssDEvalParams->GBufferSurface.pInAttrib[12]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_13, pInDlssDEvalParams->GBufferSurface.pInAttrib[13]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_14, pInDlssDEvalParams->GBufferSurface.pInAttrib[14]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_15, pInDlssDEvalParams->GBufferSurface.pInAttrib[15]);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_TonemapperType, pInDlssDEvalParams->InToneMapperType);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_MotionVectors3D, pInDlssDEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_IsParticleMask, pInDlssDEvalParams->pInIsParticleMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_AnimatedTextureMask, pInDlssDEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DepthHighRes, pInDlssDEvalParams->pInDepthHighRes);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Position_ViewSpace, pInDlssDEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_FrameTimeDeltaInMsec, pInDlssDEvalParams->InFrameTimeDeltaInMsec);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_RayTracingHitDistance, pInDlssDEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, pInDlssDEvalParams->InColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y, pInDlssDEvalParams->InColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, pInDlssDEvalParams->InDepthSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y, pInDlssDEvalParams->InDepthSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, pInDlssDEvalParams->InMVSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y, pInDlssDEvalParams->InMVSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_X, pInDlssDEvalParams->InTranslucencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_Y, pInDlssDEvalParams->InTranslucencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, pInDlssDEvalParams->InBiasCurrentColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y, pInDlssDEvalParams->InBiasCurrentColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, pInDlssDEvalParams->InOutputSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y, pInDlssDEvalParams->InOutputSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width , pInDlssDEvalParams->InRenderSubrectDimensions.Width);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, pInDlssDEvalParams->InRenderSubrectDimensions.Height);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Pre_Exposure, pInDlssDEvalParams->InPreExposure == 0.0f ? 1.0f : pInDlssDEvalParams->InPreExposure);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Exposure_Scale, pInDlssDEvalParams->InExposureScale == 0.0f ? 1.0f : pInDlssDEvalParams->InExposureScale);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_X_Axis, pInDlssDEvalParams->InIndicatorInvertXAxis);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_Y_Axis, pInDlssDEvalParams->InIndicatorInvertYAxis);
+
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Emissive, pInDlssDEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_EMISSIVE]);
+
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DiffuseAlbedo, pInDlssDEvalParams->pInDiffuseAlbedo);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_SpecularAlbedo, pInDlssDEvalParams->pInSpecularAlbedo);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssDEvalParams->pInNormals);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssDEvalParams->pInRoughness);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_X, pInDlssDEvalParams->InDiffuseAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_DiffuseAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_X, pInDlssDEvalParams->InSpecularAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_SpecularAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InSpecularAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_X, pInDlssDEvalParams->InNormalsSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Normals_Subrect_Base_Y, pInDlssDEvalParams->InNormalsSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_X, pInDlssDEvalParams->InRoughnessSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Roughness_Subrect_Base_Y, pInDlssDEvalParams->InRoughnessSubrectBase.Y);
+
+
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo, pInDlssDEvalParams->pInReflectedAlbedo);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles, pInDlssDEvalParams->pInColorBeforeParticles);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles, pInDlssDEvalParams->pInColorAfterParticles);
+	NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency, pInDlssDEvalParams->pInColorBeforeTransparency);
+	NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency, pInDlssDEvalParams->pInColorAfterTransparency);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog, pInDlssDEvalParams->pInColorBeforeFog);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog, pInDlssDEvalParams->pInColorAfterFog);
+    
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide, pInDlssDEvalParams->pInScreenSpaceSubsurfaceScatteringGuide);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering, pInDlssDEvalParams->pInColorBeforeScreenSpaceSubsurfaceScattering);
+	NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering, pInDlssDEvalParams->pInColorAfterScreenSpaceSubsurfaceScattering);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide, pInDlssDEvalParams->pInScreenSpaceRefractionGuide);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction, pInDlssDEvalParams->pInColorBeforeScreenSpaceRefraction);
+	NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction, pInDlssDEvalParams->pInColorAfterScreenSpaceRefraction);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide, pInDlssDEvalParams->pInDepthOfFieldGuide);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField, pInDlssDEvalParams->pInColorBeforeDepthOfField);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField, pInDlssDEvalParams->pInColorAfterDepthOfField);
+	NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance, pInDlssDEvalParams->pInDiffuseHitDistance);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance, pInDlssDEvalParams->pInSpecularHitDistance);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection, pInDlssDEvalParams->pInDiffuseRayDirection);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection, pInDlssDEvalParams->pInSpecularRayDirection);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance, pInDlssDEvalParams->pInDiffuseRayDirectionHitDistance);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance, pInDlssDEvalParams->pInSpecularRayDirectionHitDistance);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_X, pInDlssDEvalParams->InReflectedAlbedoSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ReflectedAlbedo_Subrect_Base_Y, pInDlssDEvalParams->InReflectedAlbedoSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeParticlesSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeParticles_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeParticlesSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_X, pInDlssDEvalParams->InColorAfterParticlesSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterParticles_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterParticlesSubrectBase.Y);
+	NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeTransparencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeTransparency_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeTransparencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_X, pInDlssDEvalParams->InColorAfterTransparencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterTransparency_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterTransparencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeFogSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeFog_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeFogSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_X, pInDlssDEvalParams->InColorAfterFogSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterFog_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterFogSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_X, pInDlssDEvalParams->InScreenSpaceSubsurfaceScatteringGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceSubsurfaceScatteringGuide_Subrect_Base_Y, pInDlssDEvalParams->InScreenSpaceSubsurfaceScatteringGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceSubsurfaceScattering_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeScreenSpaceSubsurfaceScatteringSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_X, pInDlssDEvalParams->InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceSubsurfaceScattering_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterScreenSpaceSubsurfaceScatteringSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_X, pInDlssDEvalParams->InScreenSpaceRefractionGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ScreenSpaceRefractionGuide_Subrect_Base_Y, pInDlssDEvalParams->InScreenSpaceRefractionGuideSubrectBase.Y);
+	NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeScreenSpaceRefractionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeScreenSpaceRefraction_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeScreenSpaceRefractionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_X, pInDlssDEvalParams->InColorAfterScreenSpaceRefractionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterScreenSpaceRefraction_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterScreenSpaceRefractionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_X, pInDlssDEvalParams->InDepthOfFieldGuideSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DepthOfFieldGuide_Subrect_Base_Y, pInDlssDEvalParams->InDepthOfFieldGuideSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_X, pInDlssDEvalParams->InColorBeforeDepthOfFieldSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorBeforeDepthOfField_Subrect_Base_Y, pInDlssDEvalParams->InColorBeforeDepthOfFieldSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_X, pInDlssDEvalParams->InColorAfterDepthOfFieldSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_ColorAfterDepthOfField_Subrect_Base_Y, pInDlssDEvalParams->InColorAfterDepthOfFieldSubrectBase.Y);
+	NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_X, pInDlssDEvalParams->InDiffuseHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_X, pInDlssDEvalParams->InSpecularHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InSpecularHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_X, pInDlssDEvalParams->InDiffuseRayDirectionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirection_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseRayDirectionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_X, pInDlssDEvalParams->InSpecularRayDirectionSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirection_Subrect_Base_Y, pInDlssDEvalParams->InSpecularRayDirectionSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_X, pInDlssDEvalParams->InDiffuseRayDirectionHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_DiffuseRayDirectionHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InDiffuseRayDirectionHitDistanceSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_X, pInDlssDEvalParams->InSpecularRayDirectionHitDistanceSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSSD_SpecularRayDirectionHitDistance_Subrect_Base_Y, pInDlssDEvalParams->InSpecularRayDirectionHitDistanceSubrectBase.Y);
+
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_WORLD_TO_VIEW_MATRIX, pInDlssDEvalParams->pInWorldToViewMatrix);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_VIEW_TO_CLIP_MATRIX, pInDlssDEvalParams->pInViewToClipMatrix);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer, pInDlssDEvalParams->pInTransparencyLayer);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity, pInDlssDEvalParams->pInTransparencyLayerOpacity);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs, pInDlssDEvalParams->pInTransparencyLayerMvecs);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask, pInDlssDEvalParams->pInDisocclusionMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayer_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerOpacitySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerOpacity_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerOpacitySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_X, pInDlssDEvalParams->InTransparencyLayerMvecsSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_TransparencyLayerMvecs_Subrect_Base_Y, pInDlssDEvalParams->InTransparencyLayerMvecsSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_X, pInDlssDEvalParams->InDisocclusionMaskSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_DisocclusionMask_Subrect_Base_Y, pInDlssDEvalParams->InDisocclusionMaskSubrectBase.Y);
+
+
+    return NVSDK_NGX_VULKAN_EvaluateFeature_C(InCmdList, pInHandle, pInParams, NULL);
+}
+
+#endif // NVSDK_NGX_HELPERS_DLSSD_VK_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_helpers_vk.h

@@ -0,0 +1,310 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2019-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#ifndef NVSDK_NGX_HELPERS_VK_H
+#define NVSDK_NGX_HELPERS_VK_H
+#pragma once
+
+#include "nvsdk_ngx_vk.h"
+
+#define NVSDK_NGX_ENSURE_VK_IMAGEVIEW(InResource) if ((InResource) && (InResource)->Type != NVSDK_NGX_RESOURCE_VK_TYPE_VK_IMAGEVIEW) { return NVSDK_NGX_Result_FAIL_InvalidParameter; }
+
+static inline NVSDK_NGX_Resource_VK NVSDK_NGX_Create_ImageView_Resource_VK(VkImageView imageView, VkImage image, VkImageSubresourceRange subresourceRange, VkFormat format, unsigned int width, unsigned int height, bool readWrite)
+{
+    NVSDK_NGX_Resource_VK resourceVK = {};
+    resourceVK.Type = NVSDK_NGX_RESOURCE_VK_TYPE_VK_IMAGEVIEW;
+    resourceVK.Resource.ImageViewInfo.ImageView = imageView;
+    resourceVK.Resource.ImageViewInfo.Image = image;
+    resourceVK.Resource.ImageViewInfo.SubresourceRange = subresourceRange;
+    resourceVK.Resource.ImageViewInfo.Height = height;
+    resourceVK.Resource.ImageViewInfo.Width = width;
+    resourceVK.Resource.ImageViewInfo.Format = format;
+    resourceVK.ReadWrite = readWrite;
+    return resourceVK;
+}
+
+static inline NVSDK_NGX_Resource_VK NVSDK_NGX_Create_Buffer_Resource_VK(VkBuffer buffer, unsigned int sizeInBytes, bool readWrite)
+{
+    NVSDK_NGX_Resource_VK resourceVK = {};
+    resourceVK.Type = NVSDK_NGX_RESOURCE_VK_TYPE_VK_BUFFER;
+    resourceVK.Resource.BufferInfo.Buffer = buffer;
+    resourceVK.Resource.BufferInfo.SizeInBytes = sizeInBytes;
+    resourceVK.ReadWrite = readWrite;
+    return resourceVK;
+}
+
+typedef struct NVSDK_NGX_VK_Feature_Eval_Params
+{
+    NVSDK_NGX_Resource_VK *pInColor;
+    NVSDK_NGX_Resource_VK *pInOutput;
+    /*** OPTIONAL for DLSS ***/
+    float                  InSharpness;
+} NVSDK_NGX_VK_Feature_Eval_Params;
+
+typedef struct NVSDK_NGX_VK_GBuffer
+{
+    NVSDK_NGX_Resource_VK *pInAttrib[NVSDK_NGX_GBUFFERTYPE_NUM];
+} NVSDK_NGX_VK_GBuffer;
+
+typedef struct NVSDK_NGX_Coordinates_VK
+{
+    unsigned int X;
+    unsigned int Y;
+} NVSDK_NGX_Coordinates_VK;
+
+typedef struct NVSDK_NGX_VK_DLSS_Eval_Params
+{
+    NVSDK_NGX_VK_Feature_Eval_Params    Feature;
+    NVSDK_NGX_Resource_VK *             pInDepth;
+    NVSDK_NGX_Resource_VK *             pInMotionVectors;
+    float                               InJitterOffsetX;     /* Jitter offset must be in input/render pixel space */
+    float                               InJitterOffsetY;
+    NVSDK_NGX_Dimensions                InRenderSubrectDimensions;
+    /*** OPTIONAL - leave to 0/0.0f if unused ***/
+    int                                 InReset;             /* Set to 1 when scene changes completely (new level etc) */
+    float                               InMVScaleX;          /* If MVs need custom scaling to convert to pixel space */
+    float                               InMVScaleY;
+    NVSDK_NGX_Resource_VK *             pInTransparencyMask; /* Unused/Reserved for future use */
+    NVSDK_NGX_Resource_VK *             pInExposureTexture;
+    NVSDK_NGX_Resource_VK *             pInBiasCurrentColorMask;
+    NVSDK_NGX_Coordinates               InColorSubrectBase;
+    NVSDK_NGX_Coordinates               InDepthSubrectBase;
+    NVSDK_NGX_Coordinates               InMVSubrectBase;
+    NVSDK_NGX_Coordinates               InTranslucencySubrectBase;
+    NVSDK_NGX_Coordinates               InBiasCurrentColorSubrectBase;
+    NVSDK_NGX_Coordinates               InOutputSubrectBase;
+    float                               InPreExposure;
+    float                               InExposureScale;
+    int                                 InIndicatorInvertXAxis;
+    int                                 InIndicatorInvertYAxis;
+    /*** OPTIONAL - only for research purposes ***/
+    NVSDK_NGX_VK_GBuffer                GBufferSurface;
+    NVSDK_NGX_ToneMapperType            InToneMapperType;
+    NVSDK_NGX_Resource_VK *             pInMotionVectors3D;
+    NVSDK_NGX_Resource_VK *             pInIsParticleMask; /* to identify which pixels contains particles, essentially that are not drawn as part of base pass */
+    NVSDK_NGX_Resource_VK *             pInAnimatedTextureMask; /* a binary mask covering pixels occupied by animated textures */
+    NVSDK_NGX_Resource_VK *             pInDepthHighRes;
+    NVSDK_NGX_Resource_VK *             pInPositionViewSpace;
+    float                               InFrameTimeDeltaInMsec; /* helps in determining the amount to denoise or anti-alias based on the speed of the object from motion vector magnitudes and fps as determined by this delta */
+    NVSDK_NGX_Resource_VK *             pInRayTracingHitDistance; /* for each effect - approximation to the amount of noise in a ray-traced color */
+    NVSDK_NGX_Resource_VK *             pInMotionVectorsReflections; /* motion vectors of reflected objects like for mirrored surfaces */
+} NVSDK_NGX_VK_DLSS_Eval_Params;
+
+typedef struct NVSDK_NGX_VK_DLISP_Eval_Params
+{
+    NVSDK_NGX_VK_Feature_Eval_Params Feature;
+    /*** OPTIONAL - leave to 0/0.0f if unused ***/
+    unsigned int                        InRectX;
+    unsigned int                        InRectY;
+    unsigned int                        InRectW;
+    unsigned int                        InRectH;
+    float                               InDenoise;
+} NVSDK_NGX_VK_DLISP_Eval_Params;
+
+static inline NVSDK_NGX_Result NGX_VULKAN_CREATE_DLSS_EXT1(
+    VkDevice InDevice,
+    VkCommandBuffer InCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_DLSS_Create_Params *pInDlssCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlssCreateParams->Feature.InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlssCreateParams->Feature.InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlssCreateParams->Feature.InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlssCreateParams->Feature.InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pInDlssCreateParams->Feature.InPerfQualityValue);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, pInDlssCreateParams->InFeatureCreateFlags);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Enable_Output_Subrects, pInDlssCreateParams->InEnableOutputSubrects ? 1 : 0);
+
+    if (InDevice) return NVSDK_NGX_VULKAN_CreateFeature1(InDevice, InCmdList, NVSDK_NGX_Feature_SuperSampling, pInParams, ppOutHandle);
+    else return NVSDK_NGX_VULKAN_CreateFeature(InCmdList, NVSDK_NGX_Feature_SuperSampling, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_VULKAN_CREATE_DLSS_EXT(
+    VkCommandBuffer InCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_DLSS_Create_Params *pInDlssCreateParams)
+{
+    return NGX_VULKAN_CREATE_DLSS_EXT1(NULL, InCmdList, InCreationNodeMask, InVisibilityNodeMask, ppOutHandle, pInParams, pInDlssCreateParams);
+}
+
+static inline NVSDK_NGX_Result NGX_VULKAN_EVALUATE_DLSS_EXT(
+    VkCommandBuffer InCmdList,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_VK_DLSS_Eval_Params *pInDlssEvalParams)
+{
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->Feature.pInColor);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInMotionVectors);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->Feature.pInOutput);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInDepth);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInTransparencyMask);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInExposureTexture);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInBiasCurrentColorMask);
+	for (size_t i = 0; i <= 15; i++)
+	{
+        NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->GBufferSurface.pInAttrib[i]);
+	}
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInIsParticleMask);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInDepthHighRes);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlssEvalParams->pInMotionVectorsReflections);
+
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Color, pInDlssEvalParams->Feature.pInColor);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Output, pInDlssEvalParams->Feature.pInOutput);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Depth, pInDlssEvalParams->pInDepth);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_MotionVectors, pInDlssEvalParams->pInMotionVectors);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_X, pInDlssEvalParams->InJitterOffsetX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Jitter_Offset_Y, pInDlssEvalParams->InJitterOffsetY);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pInDlssEvalParams->Feature.InSharpness);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_Reset, pInDlssEvalParams->InReset);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_X, pInDlssEvalParams->InMVScaleX == 0.0f ? 1.0f : pInDlssEvalParams->InMVScaleX);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_MV_Scale_Y, pInDlssEvalParams->InMVScaleY == 0.0f ? 1.0f : pInDlssEvalParams->InMVScaleY);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_TransparencyMask, pInDlssEvalParams->pInTransparencyMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_ExposureTexture, pInDlssEvalParams->pInExposureTexture);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, pInDlssEvalParams->pInBiasCurrentColorMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Albedo, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ALBEDO]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Roughness, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_ROUGHNESS]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Metallic, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_METALLIC]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Specular, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SPECULAR]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Subsurface, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SUBSURFACE]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Normals, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_NORMALS]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_ShadingModelId, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_SHADINGMODELID]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_MaterialId, pInDlssEvalParams->GBufferSurface.pInAttrib[NVSDK_NGX_GBUFFER_MATERIALID]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_8, pInDlssEvalParams->GBufferSurface.pInAttrib[8]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_9, pInDlssEvalParams->GBufferSurface.pInAttrib[9]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_10, pInDlssEvalParams->GBufferSurface.pInAttrib[10]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_11, pInDlssEvalParams->GBufferSurface.pInAttrib[11]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_12, pInDlssEvalParams->GBufferSurface.pInAttrib[12]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_13, pInDlssEvalParams->GBufferSurface.pInAttrib[13]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_14, pInDlssEvalParams->GBufferSurface.pInAttrib[14]);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_GBuffer_Atrrib_15, pInDlssEvalParams->GBufferSurface.pInAttrib[15]);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_TonemapperType, pInDlssEvalParams->InToneMapperType);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_MotionVectors3D, pInDlssEvalParams->pInMotionVectors3D);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_IsParticleMask, pInDlssEvalParams->pInIsParticleMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_AnimatedTextureMask, pInDlssEvalParams->pInAnimatedTextureMask);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_DepthHighRes, pInDlssEvalParams->pInDepthHighRes);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Position_ViewSpace, pInDlssEvalParams->pInPositionViewSpace);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_FrameTimeDeltaInMsec, pInDlssEvalParams->InFrameTimeDeltaInMsec);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_RayTracingHitDistance, pInDlssEvalParams->pInRayTracingHitDistance);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_MotionVectorsReflection, pInDlssEvalParams->pInMotionVectorsReflections);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, pInDlssEvalParams->InColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y, pInDlssEvalParams->InColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, pInDlssEvalParams->InDepthSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y, pInDlssEvalParams->InDepthSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, pInDlssEvalParams->InMVSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y, pInDlssEvalParams->InMVSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_X, pInDlssEvalParams->InTranslucencySubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Translucency_SubrectBase_Y, pInDlssEvalParams->InTranslucencySubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, pInDlssEvalParams->InBiasCurrentColorSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y, pInDlssEvalParams->InBiasCurrentColorSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, pInDlssEvalParams->InOutputSubrectBase.X);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y, pInDlssEvalParams->InOutputSubrectBase.Y);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width , pInDlssEvalParams->InRenderSubrectDimensions.Width);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, pInDlssEvalParams->InRenderSubrectDimensions.Height);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Pre_Exposure, pInDlssEvalParams->InPreExposure == 0.0f ? 1.0f : pInDlssEvalParams->InPreExposure);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_DLSS_Exposure_Scale, pInDlssEvalParams->InExposureScale == 0.0f ? 1.0f : pInDlssEvalParams->InExposureScale);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_X_Axis, pInDlssEvalParams->InIndicatorInvertXAxis);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_DLSS_Indicator_Invert_Y_Axis, pInDlssEvalParams->InIndicatorInvertYAxis);
+
+    return NVSDK_NGX_VULKAN_EvaluateFeature_C(InCmdList, pInHandle, pInParams, NULL);
+}
+
+static inline NVSDK_NGX_Result NGX_VULKAN_CREATE_DLISP_EXT(
+    VkCommandBuffer InCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_Feature_Create_Params *pInDlispCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlispCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlispCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlispCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlispCreateParams->InTargetHeight);
+    NVSDK_NGX_Parameter_SetI(pInParams, NVSDK_NGX_Parameter_PerfQualityValue, pInDlispCreateParams->InPerfQualityValue);
+
+    return NVSDK_NGX_VULKAN_CreateFeature(InCmdList, NVSDK_NGX_Feature_ImageSignalProcessing, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_VULKAN_EVALUATE_DLISP_EXT(
+    VkCommandBuffer InCmdList,
+    NVSDK_NGX_Handle *InHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_VK_DLISP_Eval_Params *pInDlispEvalParams)
+{
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlispEvalParams->Feature.pInColor);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlispEvalParams->Feature.pInOutput); 
+
+   	NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Color, pInDlispEvalParams->Feature.pInColor);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Output, pInDlispEvalParams->Feature.pInOutput);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pInDlispEvalParams->Feature.InSharpness);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Denoise, pInDlispEvalParams->InDenoise);
+    // If input is atlas - use RECT to upscale only the required area
+    if (pInDlispEvalParams->InRectW)
+    {
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_X, pInDlispEvalParams->InRectX);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_Y, pInDlispEvalParams->InRectY);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_W, pInDlispEvalParams->InRectW);
+        NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Rect_H, pInDlispEvalParams->InRectH);
+    }
+
+    return NVSDK_NGX_VULKAN_EvaluateFeature_C(InCmdList, InHandle, pInParams, NULL);
+}
+
+static inline NVSDK_NGX_Result NGX_VULKAN_CREATE_DLRESOLVE_EXT(
+    VkCommandBuffer InCmdList,
+    unsigned int InCreationNodeMask,
+    unsigned int InVisibilityNodeMask,
+    NVSDK_NGX_Handle **ppOutHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_Feature_Create_Params *pInDlresolveCreateParams)
+{
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_CreationNodeMask, InCreationNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_VisibilityNodeMask, InVisibilityNodeMask);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Width, pInDlresolveCreateParams->InWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_Height, pInDlresolveCreateParams->InHeight);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutWidth, pInDlresolveCreateParams->InTargetWidth);
+    NVSDK_NGX_Parameter_SetUI(pInParams, NVSDK_NGX_Parameter_OutHeight, pInDlresolveCreateParams->InTargetHeight);
+
+    return NVSDK_NGX_VULKAN_CreateFeature(InCmdList, NVSDK_NGX_Feature_DeepResolve, pInParams, ppOutHandle);
+}
+
+static inline NVSDK_NGX_Result NGX_VULKAN_EVALUATE_DLRESOLVE_EXT(
+    VkCommandBuffer InCmdList,
+    NVSDK_NGX_Handle *pInHandle,
+    NVSDK_NGX_Parameter *pInParams,
+    NVSDK_NGX_VK_Feature_Eval_Params *pInDlresolveEvalParams)
+{
+	NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlresolveEvalParams->pInColor);
+    NVSDK_NGX_ENSURE_VK_IMAGEVIEW(pInDlresolveEvalParams->pInOutput);
+    
+	NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Color, pInDlresolveEvalParams->pInColor);
+    NVSDK_NGX_Parameter_SetVoidPointer(pInParams, NVSDK_NGX_Parameter_Output, pInDlresolveEvalParams->pInOutput);
+    NVSDK_NGX_Parameter_SetF(pInParams, NVSDK_NGX_Parameter_Sharpness, pInDlresolveEvalParams->InSharpness);
+
+    return NVSDK_NGX_VULKAN_EvaluateFeature_C(InCmdList, pInHandle, pInParams, NULL);
+}
+
+#endif // NVSDK_NGX_HELPERS_VK_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_params.h

@@ -0,0 +1,116 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2019-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+
+#ifndef NVSDK_NGX_PARAMS_H
+#define NVSDK_NGX_PARAMS_H
+
+#include "nvsdk_ngx_defs.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+typedef struct ID3D11Resource ID3D11Resource;
+typedef struct ID3D12Resource ID3D12Resource;
+
+typedef struct NVSDK_NGX_Feature_Create_Params
+{
+    unsigned int InWidth;
+    unsigned int InHeight;
+    unsigned int InTargetWidth;
+    unsigned int InTargetHeight;
+    /*** OPTIONAL ***/
+    NVSDK_NGX_PerfQuality_Value InPerfQualityValue;
+} NVSDK_NGX_Feature_Create_Params;
+
+typedef struct NVSDK_NGX_DLSS_Create_Params
+{
+    NVSDK_NGX_Feature_Create_Params Feature;
+    /*** OPTIONAL ***/
+    int     InFeatureCreateFlags;
+    bool    InEnableOutputSubrects;
+} NVSDK_NGX_DLSS_Create_Params;
+
+typedef struct NVSDK_NGX_DLDenoise_Create_Params
+{
+    NVSDK_NGX_Feature_Create_Params Feature;
+    /*** OPTIONAL ***/
+    int InFeatureCreateFlags;
+} NVSDK_NGX_DLDenoise_Create_Params;
+
+#ifdef __cplusplus
+typedef struct NVSDK_NGX_Parameter
+{
+    virtual void Set(const char * InName, unsigned long long InValue) = 0;
+    virtual void Set(const char * InName, float InValue) = 0;
+    virtual void Set(const char * InName, double InValue) = 0;
+    virtual void Set(const char * InName, unsigned int InValue) = 0;
+    virtual void Set(const char * InName, int InValue) = 0;    
+    virtual void Set(const char * InName, ID3D11Resource *InValue) = 0;
+    virtual void Set(const char * InName, ID3D12Resource *InValue) = 0;
+    virtual void Set(const char * InName, void *InValue) = 0;
+
+    virtual NVSDK_NGX_Result Get(const char * InName, unsigned long long *OutValue) const = 0;
+    virtual NVSDK_NGX_Result Get(const char * InName, float *OutValue) const = 0;
+    virtual NVSDK_NGX_Result Get(const char * InName, double *OutValue) const = 0;
+    virtual NVSDK_NGX_Result Get(const char * InName, unsigned int *OutValue) const = 0;
+    virtual NVSDK_NGX_Result Get(const char * InName, int *OutValue) const = 0;
+    virtual NVSDK_NGX_Result Get(const char * InName, ID3D11Resource **OutValue) const = 0;
+    virtual NVSDK_NGX_Result Get(const char * InName, ID3D12Resource **OutValue) const = 0;
+    virtual NVSDK_NGX_Result Get(const char * InName, void **OutValue) const = 0;
+    
+    virtual void Reset() = 0;
+} NVSDK_NGX_Parameter;
+#else
+typedef struct NVSDK_NGX_Parameter NVSDK_NGX_Parameter;
+#endif // _cplusplus
+
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetULL)(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned long long InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetULL(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned long long InValue);
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetF)(NVSDK_NGX_Parameter *InParameter, const char * InName, float InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetF(NVSDK_NGX_Parameter *InParameter, const char * InName, float InValue);
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetD)(NVSDK_NGX_Parameter *InParameter, const char * InName, double InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetD(NVSDK_NGX_Parameter *InParameter, const char * InName, double InValue);
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetUI)(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned int InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetUI(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned int InValue);
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetI)(NVSDK_NGX_Parameter *InParameter, const char * InName, int InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetI(NVSDK_NGX_Parameter *InParameter, const char * InName, int InValue);
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetD3d11Resource)(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D11Resource *InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetD3d11Resource(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D11Resource *InValue);
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetD3d12Resource)(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D12Resource *InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetD3d12Resource(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D12Resource *InValue);
+typedef void             (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_SetVoidPointer)(NVSDK_NGX_Parameter *InParameter, const char * InName, void *InValue);
+NVSDK_NGX_API void        NVSDK_CONV      NVSDK_NGX_Parameter_SetVoidPointer(NVSDK_NGX_Parameter *InParameter, const char * InName, void *InValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetULL)(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned long long *OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetULL(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned long long *OutValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetF)(NVSDK_NGX_Parameter *InParameter, const char * InName, float *OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetF(NVSDK_NGX_Parameter *InParameter, const char * InName, float *OutValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetD)(NVSDK_NGX_Parameter *InParameter, const char * InName, double *OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetD(NVSDK_NGX_Parameter *InParameter, const char * InName, double *OutValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetUI)(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned int *OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetUI(NVSDK_NGX_Parameter *InParameter, const char * InName, unsigned int *OutValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetI)(NVSDK_NGX_Parameter *InParameter, const char * InName, int *OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetI(NVSDK_NGX_Parameter *InParameter, const char * InName, int *OutValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetD3d11Resource)(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D11Resource **OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetD3d11Resource(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D11Resource **OutValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetD3d12Resource)(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D12Resource **OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetD3d12Resource(NVSDK_NGX_Parameter *InParameter, const char * InName, ID3D12Resource **OutValue);
+typedef NVSDK_NGX_Result (NVSDK_CONV *PFN_NVSDK_NGX_Parameter_GetVoidPointer)(NVSDK_NGX_Parameter *InParameter, const char * InName, void **OutValue);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_Parameter_GetVoidPointer(NVSDK_NGX_Parameter *InParameter, const char * InName, void **OutValue);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // #define NVSDK_NGX_PARAMS_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_params_dlssd.h

@@ -0,0 +1,36 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+
+#ifndef NVSDK_NGX_PARAMS_DLSSD_H
+#define NVSDK_NGX_PARAMS_DLSSD_H
+
+#include "nvsdk_ngx_defs_dlssd.h"
+
+typedef struct NVSDK_NGX_DLSSD_Create_Params
+{
+    NVSDK_NGX_DLSS_Denoise_Mode InDenoiseMode;
+    NVSDK_NGX_DLSS_Roughness_Mode InRoughnessMode;
+    NVSDK_NGX_DLSS_Depth_Type InUseHWDepth;
+
+    unsigned int InWidth;
+    unsigned int InHeight;
+    unsigned int InTargetWidth;
+    unsigned int InTargetHeight;
+    /*** OPTIONAL ***/
+    NVSDK_NGX_PerfQuality_Value InPerfQualityValue;
+    int     InFeatureCreateFlags;
+    bool    InEnableOutputSubrects;
+} NVSDK_NGX_DLSSD_Create_Params;
+
+
+#endif // #define NVSDK_NGX_PARAMS_DLSSD_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Include/nvsdk_ngx_vk.h

@@ -0,0 +1,553 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2019-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+/*
+*  HOW TO USE:
+*
+*  IMPORTANT: Methods in this library are NOT thread safe. It is up to the
+*  client to ensure that thread safety is enforced as needed.
+*  
+*  1) Call NVSDK_CONV NVSDK_NGX_D3D11/D3D12/CUDA_Init and pass your app Id
+*     and other parameters. This will initialize SDK or return an error code
+*     if SDK cannot run on target machine. Depending on error user might
+*     need to update drivers. Please note that application Id is provided
+*     by NVIDIA so if you do not have one please contact us.
+* 
+*  2) Call NVSDK_NGX_D3D11/D3D12/CUDA_GetParameters to obtain pointer to 
+*     interface used to pass parameters to SDK. Interface instance is 
+*     allocated and released by SDK so there is no need to do any memory 
+*     management on client side.
+*    
+*  3) Set key parameters for the feature you want to use. For example, 
+*     width and height are required for all features and they can be
+*     set like this: 
+*         Params->Set(NVSDK_NGX_Parameter_Width,MY_WIDTH);
+*         Params->Set(NVSDK_NGX_Parameter_Height,MY_HEIGHT);
+*
+*     You can also provide hints like NVSDK_NGX_Parameter_Hint_HDR to tell
+*     SDK that it should expect HDR color space is needed. Please refer to 
+*     samples since different features need different parameters and hints.
+*
+*  4) Call NVSDK_NGX_D3D11/D3D12/CUDA_GetScratchBufferSize to obtain size of
+*     the scratch buffer needed by specific feature. This D3D or CUDA buffer
+*     should be allocated by client and passed as:
+*        Params->Set(NVSDK_NGX_Parameter_Scratch,MY_SCRATCH_POINTER)
+*        Params->Set(NVSDK_NGX_Parameter_Scratch_SizeInBytes,MY_SCRATCH_SIZE_IN_BYTES)
+*     NOTE: Returned size can be 0 if feature does not use any scratch buffer.
+*     It is OK to use bigger buffer or reuse buffers across features as long
+*     as minimum size requirement is met.
+*
+*  5) Call NVSDK_NGX_D3D11/D3D12/CUDA_CreateFeature to create feature you need.
+*     On success SDK will return a handle which must be used in any successive 
+*     calls to SDK which require feature handle. SDK will use all parameters
+*     and hints provided by client to generate feature. If feature with the same
+*     parameters already exists and error code will be returned.
+*
+*  6) Call NVSDK_NGX_D3D11/D3D12/CUDA_EvaluateFeature to invoke execution of
+*     specific feature. Before feature can be evaluated input parameters must
+*     be specified (like for example color/albedo buffer, motion vectors etc)
+* 
+*  6) Call NVSDK_NGX_D3D11/D3D12/CUDA_ReleaseFeature when feature is no longer
+*     needed. After this call feature handle becomes invalid and cannot be used.
+* 
+*  7) Call NVSDK_NGX_D3D11/D3D12/CUDA_Shutdown when SDK is no longer needed to
+*     release all resources.
+
+*  Contact: ngxsupport@nvidia.com
+*/
+
+
+#ifndef NVSDK_NGX_VK_H
+#define NVSDK_NGX_VK_H
+
+#include "nvsdk_ngx_defs.h"
+#include "nvsdk_ngx_params.h"
+#ifndef __cplusplus
+#include <stdbool.h> 
+#include <wchar.h> 
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_ImageViewInfo_VK [Vulkan only]
+// Contains ImageView-specific metadata.
+// ImageView:
+//    The VkImageView resource.
+//
+// Image:
+//    The VkImage associated to this VkImageView.
+//
+// SubresourceRange:
+//    The VkImageSubresourceRange associated to this VkImageView.
+//
+//  Format:
+//    The format of the resource.
+//
+//  Width:
+//     The width of the resource.
+// 
+//  Height:
+//     The height of the resource.
+//
+typedef struct NVSDK_NGX_ImageViewInfo_VK {
+    VkImageView ImageView;
+    VkImage Image;
+    VkImageSubresourceRange SubresourceRange;
+    VkFormat Format;
+    unsigned int Width;
+    unsigned int Height;
+} NVSDK_NGX_ImageViewInfo_VK;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_BufferInfo_VK [Vulkan only]
+// Contains Buffer-specific metadata.
+// Buffer
+//    The VkBuffer resource.
+//
+// SizeInBytes:
+//    The size of the resource (in bytes).
+//
+typedef struct NVSDK_NGX_BufferInfo_VK {
+    VkBuffer Buffer;
+    unsigned int SizeInBytes;
+} NVSDK_NGX_BufferInfo_VK;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Resource_VK [Vulkan only]
+//
+// ImageViewInfo:
+//    The VkImageView resource, and VkImageView-specific metadata. A NVSDK_NGX_Resource_VK can only have one of ImageViewInfo or BufferInfo.
+//
+// BufferInfo:
+//    The VkBuffer Resource, and VkBuffer-specific metadata. A NVSDK_NGX_Resource_VK can only have one of ImageViewInfo or BufferInfo.
+// 
+//  Type:
+//    Whether or this resource is a VkImageView or a VkBuffer.
+// 
+//  ReadWrite:
+//     True if the resource is available for read and write access.
+//          For VkBuffer resources: VkBufferUsageFlags includes VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+//          For VkImage resources: VkImageUsageFlags for associated VkImage includes VK_IMAGE_USAGE_STORAGE_BIT
+//
+typedef struct NVSDK_NGX_Resource_VK {
+    union {
+        NVSDK_NGX_ImageViewInfo_VK ImageViewInfo;
+        NVSDK_NGX_BufferInfo_VK BufferInfo;
+    } Resource;
+    NVSDK_NGX_Resource_VK_Type Type;
+    bool ReadWrite;
+} NVSDK_NGX_Resource_VK;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// DEPRECATED, use NVSDK_NGX_VULKAN_GetFeatureInstanceExtensionRequirements() and NVSDK_NGX_VULKAN_GetFeatureRequirements() instead
+// NVSDK_NGX_RequiredExtensions [Vulkan only]
+//
+// OutInstanceExtCount:
+//   Returns the number of instance extensions NGX requires
+// 
+// OutInstanceExts:
+//   Returns a pointer to *OutInstanceExtCount strings of instance extensions
+// 
+// OutDeviceExtCount:
+//   Returns the number of device extensions NGX requires
+// 
+// OutDeviceExts:
+//   Returns a pointer to *OutDeviceExtCount strings of device extensions
+//
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_VULKAN_RequiredExtensions(unsigned int *OutInstanceExtCount, const char ***OutInstanceExts, unsigned int *OutDeviceExtCount, const char ***OutDeviceExts);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Init
+// -------------------------------------
+// 
+// InApplicationId:
+//      Unique Id provided by NVIDIA
+//
+// InApplicationDataPath:
+//      Folder to store logs and other temporary files (write access required),
+//      Normally this would be a location in Documents or ProgramData.
+//
+// InInstance/InPD/InDevice: [vk only]
+//      Vulkan Instance, PhysicalDevice, and Device to use
+//
+// InGIPA/InGDPA: [vk only]
+//      Optional Vulkan function pointers to vkGetInstanceProcAddr and vkGetDeviceProcAddr
+//
+// DESCRIPTION:
+//      Initializes new SDK instance.
+//
+#ifdef __cplusplus
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_VULKAN_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, VkInstance InInstance, VkPhysicalDevice InPD, VkDevice InDevice, PFN_vkGetInstanceProcAddr InGIPA = nullptr, PFN_vkGetDeviceProcAddr InGDPA = nullptr, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+#else
+NVSDK_NGX_API NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_VULKAN_Init(unsigned long long InApplicationId, const wchar_t *InApplicationDataPath, VkInstance InInstance, VkPhysicalDevice InPD, VkDevice InDevice, PFN_vkGetInstanceProcAddr InGIPA, PFN_vkGetDeviceProcAddr InGDPA, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Init_with_ProjectID
+// -------------------------------------
+// 
+// InParojectId:
+//      Unique Id provided by the rendering engine used
+//
+// InEngineType:
+//      Rendering engine used by the application / plugin.
+//      Use NVSDK_NGX_ENGINE_TYPE_CUSTOM if the specific engine type is not supported explicitly
+//
+// InEngineVersion:
+//      Version number of the rendering engine used by the application / plugin.
+//
+// InApplicationDataPath:
+//      Folder to store logs and other temporary files (write access required),
+//      Normally this would be a location in Documents or ProgramData.
+//
+// InInstance/InPD/InDevice: [vk only]
+//      Vulkan Instance, PhysicalDevice, and Device to use
+//
+// InGIPA/InGDPA: [vk only]
+//      Optional Vulkan function pointers to vkGetInstanceProcAddr and vkGetDeviceProcAddr
+//
+// InFeatureInfo:
+//      Contains information common to all features, presently only a list of all paths 
+//      feature dlls can be located in, other than the default path - application directory.
+//
+// DESCRIPTION:
+//      Initializes new SDK instance.
+//
+#ifdef __cplusplus
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_VULKAN_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, VkInstance InInstance, VkPhysicalDevice InPD, VkDevice InDevice, PFN_vkGetInstanceProcAddr InGIPA = nullptr, PFN_vkGetDeviceProcAddr InGDPA = nullptr, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo = nullptr, NVSDK_NGX_Version InSDKVersion = NVSDK_NGX_Version_API);
+#else
+NVSDK_NGX_Result  NVSDK_CONV NVSDK_NGX_VULKAN_Init_with_ProjectID(const char *InProjectId, NVSDK_NGX_EngineType InEngineType, const char *InEngineVersion, const wchar_t *InApplicationDataPath, VkInstance InInstance, VkPhysicalDevice InPD, VkDevice InDevice, PFN_vkGetInstanceProcAddr InGIPA, PFN_vkGetDeviceProcAddr InGDPA, const NVSDK_NGX_FeatureCommonInfo *InFeatureInfo, NVSDK_NGX_Version InSDKVersion);
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Shutdown
+// -------------------------------------
+// 
+// DESCRIPTION:
+//      Shuts down the current SDK instance and releases all resources.
+//      Shutdown1(Device) only affects specified device
+//      Shutdown1(nullptr) = Shutdown() and shuts down all devices
+//
+#ifdef NGX_ENABLE_DEPRECATED_SHUTDOWN
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_Shutdown(void);
+#endif
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_Shutdown1(VkDevice InDevice);
+
+#ifdef NGX_ENABLE_DEPRECATED_GET_PARAMETERS
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetParameters
+// ----------------------------------------------------------
+//
+// OutParameters:
+//      Parameters interface used to set any parameter needed by the SDK
+//
+// DESCRIPTION:
+//      This interface allows simple parameter setup using named fields.
+//      For example one can set width by calling Set(NVSDK_NGX_Parameter_Denoiser_Width,100) or
+//      provide CUDA buffer pointer by calling Set(NVSDK_NGX_Parameter_Denoiser_Color,cudaBuffer)
+//      For more details please see sample code. Please note that allocated memory
+//      will be freed by NGX so free/delete operator should NOT be called.
+//      Parameter maps output by NVSDK_NGX_GetParameters are also pre-populated
+//      with NGX capabilities and available features.
+//      Unlike with NVSDK_NGX_AllocateParameters, parameter maps output by NVSDK_NGX_GetParameters
+//      have their lifetimes managed by NGX, and must not
+//      be destroyed by the app using NVSDK_NGX_DestroyParameters.
+//      NVSDK_NGX_GetParameters is deprecated and apps should move to using
+//      NVSDK_NGX_AllocateParameters and NVSDK_NGX_GetCapabilityParameters when possible.
+//      Nevertheless, due to the possibility that the user will be using an older driver version,
+//      NVSDK_NGX_GetParameters may still be used as a fallback if NVSDK_NGX_AllocateParameters
+//      or NVSDK_NGX_GetCapabilityParameters return NVSDK_NGX_Result_FAIL_OutOfDate.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_GetParameters(NVSDK_NGX_Parameter **OutParameters);
+#endif // NGX_ENABLE_DEPRECATED_GET_PARAMETERS
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_AllocateParameters
+// ----------------------------------------------------------
+//
+// OutParameters:
+//      Parameters interface used to set any parameter needed by the SDK
+//
+// DESCRIPTION:
+//      This interface allows allocating a simple parameter setup using named fields, whose
+//      lifetime the app must manage.
+//      For example one can set width by calling Set(NVSDK_NGX_Parameter_Denoiser_Width,100) or
+//      provide CUDA buffer pointer by calling Set(NVSDK_NGX_Parameter_Denoiser_Color,cudaBuffer)
+//      For more details please see sample code.
+//      Parameter maps output by NVSDK_NGX_AllocateParameters must NOT be freed using
+//      the free/delete operator; to free a parameter map 
+//      output by NVSDK_NGX_AllocateParameters, NVSDK_NGX_DestroyParameters should be used.
+//      Unlike with NVSDK_NGX_GetParameters, parameter maps allocated with NVSDK_NGX_AllocateParameters
+//      must be destroyed by the app using NVSDK_NGX_DestroyParameters.
+//      Also unlike with NVSDK_NGX_GetParameters, parameter maps output by NVSDK_NGX_AllocateParameters
+//      do not come pre-populated with NGX capabilities and available features.
+//      To create a new parameter map pre-populated with such information, NVSDK_NGX_GetCapabilityParameters
+//      should be used.
+//      This function may return NVSDK_NGX_Result_FAIL_OutOfDate if an older driver, which
+//      does not support this API call is being used. In such a case, NVSDK_NGX_GetParameters
+//      may be used as a fallback.
+//      This function may only be called after a successful call into NVSDK_NGX_Init.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_AllocateParameters(NVSDK_NGX_Parameter** OutParameters);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetCapabilityParameters
+// ----------------------------------------------------------
+//
+// OutParameters:
+//      The parameters interface populated with NGX and feature capabilities
+//
+// DESCRIPTION:
+//      This interface allows the app to create a new parameter map
+//      pre-populated with NGX capabilities and available features.
+//      The output parameter map can also be used for any purpose
+//      parameter maps output by NVSDK_NGX_AllocateParameters can be used for
+//      but it is not recommended to use NVSDK_NGX_GetCapabilityParameters
+//      unless querying NGX capabilities and available features
+//      due to the overhead associated with pre-populating the parameter map.
+//      Parameter maps output by NVSDK_NGX_GetCapabilityParameters must NOT be freed using
+//      the free/delete operator; to free a parameter map
+//      output by NVSDK_NGX_GetCapabilityParameters, NVSDK_NGX_DestroyParameters should be used.
+//      Unlike with NVSDK_NGX_GetParameters, parameter maps allocated with NVSDK_NGX_GetCapabilityParameters
+//      must be destroyed by the app using NVSDK_NGX_DestroyParameters.
+//      This function may return NVSDK_NGX_Result_FAIL_OutOfDate if an older driver, which
+//      does not support this API call is being used. This function may only be called
+//      after a successful call into NVSDK_NGX_Init.
+//      If NVSDK_NGX_GetCapabilityParameters fails with NVSDK_NGX_Result_FAIL_OutOfDate,
+//      NVSDK_NGX_GetParameters may be used as a fallback, to get a parameter map pre-populated
+//      with NGX capabilities and available features.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_GetCapabilityParameters(NVSDK_NGX_Parameter** OutParameters);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_DestroyParameters
+// ----------------------------------------------------------
+//
+// InParameters:
+//      The parameters interface to be destroyed
+//
+// DESCRIPTION:
+//      This interface allows the app to destroy the parameter map passed in. Once
+//      NVSDK_NGX_DestroyParameters is called on a parameter map, it
+//      must not be used again.
+//      NVSDK_NGX_DestroyParameters must not be called on any parameter map returned
+//      by NVSDK_NGX_GetParameters; NGX will manage the lifetime of those
+//      parameter maps.
+//      This function may return NVSDK_NGX_Result_FAIL_OutOfDate if an older driver, which
+//      does not support this API call is being used. This function may only be called
+//      after a successful call into NVSDK_NGX_Init.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_DestroyParameters(NVSDK_NGX_Parameter* InParameters);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetScratchBufferSize
+// ----------------------------------------------------------
+//
+// InFeatureId:
+//      AI feature in question
+//
+// InParameters:
+//      Parameters used by the feature to help estimate scratch buffer size
+//
+// OutSizeInBytes:
+//      Number of bytes needed for the scratch buffer for the specified feature.
+//
+// DESCRIPTION:
+//      SDK needs a buffer of a certain size provided by the client in
+//      order to initialize AI feature. Once feature is no longer
+//      needed buffer can be released. It is safe to reuse the same
+//      scratch buffer for different features as long as minimum size
+//      requirement is met for all features. Please note that some
+//      features might not need a scratch buffer so return size of 0
+//      is completely valid.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_GetScratchBufferSize(NVSDK_NGX_Feature InFeatureId, const NVSDK_NGX_Parameter *InParameters, size_t *OutSizeInBytes);
+
+/////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_CreateFeature
+// -------------------------------------
+//
+// InCmdBuffer:
+//      Command buffer to use to execute GPU commands. Must be:
+//      - Open and recording 
+
+// InFeatureID:
+//      AI feature to initialize
+//
+// InParameters:
+//      List of parameters 
+// 
+// OutHandle:
+//      Handle which uniquely identifies the feature. If feature with
+//      provided parameters already exists the "already exists" error code is returned.
+//
+// DESCRIPTION:
+//      Each feature needs to be created before it can be used. 
+//      Refer to the sample code to find out which input parameters
+//      are needed to create specific feature.
+//      CreateFeature() creates feature on single existing Device
+//      CreateFeature1() creates feature on the specified Device
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_CreateFeature(VkCommandBuffer InCmdBuffer, NVSDK_NGX_Feature InFeatureID, NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_CreateFeature1(VkDevice InDevice, VkCommandBuffer InCmdList, NVSDK_NGX_Feature InFeatureID, NVSDK_NGX_Parameter *InParameters, NVSDK_NGX_Handle **OutHandle);
+
+/////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_Release
+// -------------------------------------
+// 
+// InHandle:
+//      Handle to feature to be released
+//
+// DESCRIPTION:
+//      Releases feature with a given handle.
+//      Handles are not reference counted so
+//      after this call it is invalid to use provided handle.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_ReleaseFeature(NVSDK_NGX_Handle *InHandle);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_GetFeatureRequirements
+// -------------------------------------
+// Instance:
+//      VkInstance
+//
+// InPhysicalDevice:
+//      VkPhysicalDevice
+//
+// FeatureDiscoveryInfo:
+//      Contains information common to all NGX Features - required for Feature discovery, Initialization and Logging.
+//
+// DESCRIPTION:
+//      Utility function used to identify system requirements to support a given NGX Feature
+//      on a system given its display device subsytem adapter information that will be subsequently used for creating the graphics device.
+//      The output parameter OutSupported will be populated with requirements and are valid  if and only if NVSDK_NGX_Result_Success is returned:
+//          OutSupported::FeatureSupported: bitfield of bit shifted values specified in NVSDK_NGX_Feature_Support_Result. 0 if Feature is Supported.
+//          OutSupported::MinHWArchitecture: Returned HW Architecture value corresponding to NV_GPU_ARCHITECTURE_ID values defined in NvAPI GPU Framework.
+//          OutSupported::MinOSVersion: Value corresponding to minimum OS version required for NGX Feature Support
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_GetFeatureRequirements(const VkInstance Instance,
+                                                                                  const VkPhysicalDevice PhysicalDevice,
+                                                                                  const NVSDK_NGX_FeatureDiscoveryInfo *FeatureDiscoveryInfo,
+                                                                                  NVSDK_NGX_FeatureRequirement *OutSupported);
+ 
+ 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// GetFeatureInstanceExtensionRequirements
+// --------------------------------------------
+//
+// FeatureDiscoveryInfo:
+//      Contains information common to all NGX Features - required for Feature discovery, Initialization and Logging.
+//
+// OutExtensionCount:
+//      A pointer to an integer related to the number of extension properties required or queried, as described below.
+//
+// OutExtensionProperties:
+//      Either NULL or a pointer to a pointer to an array of VkExtensionProperties structures.
+//
+// DESCRIPTION:
+//      Utility function used to identify Vulkan Instance Extensions required for NGX Feature support identified by its FeatureID.
+//
+//      OutExtensionCount will be populated with the number of extensions
+//      required by the NGX Feature specified in FeatureID.
+//      OutExtensionProperties will be populated with a pointer to a
+//      OutExtensionCount sized array of VkExtensionProperties structures.
+//
+//      The returned extension list is valid if NVSDK_NGX_Result_Success is returned.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_GetFeatureInstanceExtensionRequirements(const NVSDK_NGX_FeatureDiscoveryInfo *FeatureDiscoveryInfo,
+                                                                                                   uint32_t *OutExtensionCount,
+                                                                                                   VkExtensionProperties **OutExtensionProperties);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// GetFeatureDeviceExtensionRequirements
+// --------------------------------------
+// Instance:
+//      VkInstance
+//
+// InPhysicalDevice:
+//      VkPhysicalDevice
+//
+// FeatureDiscoveryInfo:
+//      Contains information common to all NGX Features - required for Feature discovery, Initialization and Logging.
+//
+// OutExtensionCount:
+//      A pointer to an integer related to the number of extension properties required or queried, as described below.
+//
+// OutExtensionProperties:
+//      Either NULL or a pointer to a pointer to an array of VkExtensionProperties structures.
+//
+// DESCRIPTION:
+//      Utility function used to identify Vulkan Device Extensions required for NGX Feature support identified by its FeatureID,
+//      VkInstance, and VkPhysicalDevice.
+//
+//      OutExtensionCount will be populated with the number of extensions
+//      required by the NGX Feature specified in FeatureID.
+//      OutExtensionProperties will be populated with a pointer to a
+//      OutExtensionCount sized array of VkExtensionProperties structures.
+//
+//      The returned extension list is valid if NVSDK_NGX_Result_Success is returned.
+//
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_GetFeatureDeviceExtensionRequirements(VkInstance Instance,
+                                                                                                 VkPhysicalDevice PhysicalDevice,
+                                                                                                 const NVSDK_NGX_FeatureDiscoveryInfo *FeatureDiscoveryInfo,
+                                                                                                 uint32_t *OutExtensionCount,
+                                                                                                 VkExtensionProperties **OutExtensionProperties);
+
+/////////////////////////////////////////////////////////////////////////
+// NVSDK_NGX_EvaluateFeature
+// -------------------------------------
+//
+// InCmdList:[d3d12 only]
+//      Command list to use to execute GPU commands. Must be:
+//      - Open and recording 
+//      - With node mask including the device provided in NVSDK_NGX_D3D12_Init
+//      - Execute on non-copy command queue.
+// InDevCtx: [d3d11 only]
+//      Device context to use to execute GPU commands
+//
+// InFeatureHandle:
+//      Handle representing feature to be evaluated
+// 
+// InParameters:
+//      List of parameters required to evaluate feature
+//
+// InCallback:
+//      Optional callback for features which might take longer
+//      to execture. If specified SDK will call it with progress
+//      values in range 0.0f - 1.0f
+//
+// DESCRIPTION:
+//      Evaluates given feature using the provided parameters and
+//      pre-trained NN. Please note that for most features
+//      it can be benefitials to pass as many input buffers and parameters
+//      as possible (for example provide all render targets like color, albedo, normals, depth etc)
+//
+
+#ifdef __cplusplus
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_ProgressCallback)(float InCurrentProgress, bool &OutShouldCancel);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_EvaluateFeature(VkCommandBuffer InCmdList, const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback InCallback = NULL);
+#endif
+typedef void (NVSDK_CONV *PFN_NVSDK_NGX_ProgressCallback_C)(float InCurrentProgress, bool *OutShouldCancel);
+NVSDK_NGX_API NVSDK_NGX_Result NVSDK_CONV NVSDK_NGX_VULKAN_EvaluateFeature_C(VkCommandBuffer InCmdList, const NVSDK_NGX_Handle *InFeatureHandle, const NVSDK_NGX_Parameter *InParameters, PFN_NVSDK_NGX_ProgressCallback_C InCallback);
+
+// NGX return-code conversion-to-string utility only as a helper for debugging/logging - not for official use.
+const wchar_t* NVSDK_CONV GetNGXResultAsString(NVSDK_NGX_Result InNGXResult);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // #define NVSDK_NGX_VK_H

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/LICENSE.txt

@@ -0,0 +1,107 @@
+NVIDIA RTX SDKs LICENSE
+
+This license is a legal agreement between you and NVIDIA Corporation ("NVIDIA") and governs the use of the NVIDIA RTX software development kits, including the DLSS SDK, NGX SDK, RTXGI SDK, RTXDI SDK, RTX Video SDK, RTX Dynamic Vibrance SDK and/or NRD SDK, if and when made available to you under this license (in each case, the “SDK”).
+This license can be accepted only by an adult of legal age of majority in the country in which the SDK is used. If you are under the legal age of majority, you must ask your parent or legal guardian to consent to this license. If you are entering this license on behalf of a company or other legal entity, you represent that you have legal authority and “you” will mean the entity you represent. 
+By using the SDK, you affirm that you have reached the legal age of majority, you accept the terms of this license, and you take legal and financial responsibility for the actions of your permitted users. 
+
+You agree to use the SDK only for purposes that are permitted by (a) this license, and (b) any applicable law, regulation or generally accepted practices or guidelines in the relevant jurisdictions.
+
+1. LICENSE. Subject to the terms of this license and the terms in the supplement attached, NVIDIA hereby grants you a non-exclusive, non-transferable license, without the right to sublicense (except as expressly provided in this license) to: 
+a. Install and use the SDK,
+b. Modify and create derivative works of sample source code delivered in the SDK, and
+c. Distribute any software and materials within the SDK, other than developer tools provided for your internal use, as incorporated in object code format into a software application subject to the distribution requirements indicated in this license.
+
+2. DISTRIBUTION REQUIREMENTS. These are the distribution requirements for you to exercise the grants above:
+a.	An application must have material additional functionality, beyond the included portions of the SDK. 
+b.	The following notice shall be included in modifications and derivative works of source code distributed: “This software contains source code provided by NVIDIA Corporation.” 
+c.	You agree to distribute the SDK subject to the terms at least as protective as the terms of this license, including (without limitation) terms relating to the license grant, license restrictions and protection of NVIDIA’s intellectual property rights. Additionally, you agree that you will protect the privacy, security and legal rights of your application users. 
+d.	You agree to notify NVIDIA in writing of any known or suspected distribution or use of the SDK not in compliance with the requirements of this license, and to enforce the terms of your agreements with respect to the distributed portions of the SDK. 
+
+3. AUTHORIZED USERS. You may allow employees and contractors of your entity or of your subsidiary(ies) to access and use the SDK from your secure network to perform work on your behalf. If you are an academic institution you may allow users enrolled or employed by the academic institution to access and use the SDK from your secure network. You are responsible for the compliance with the terms of this license by your authorized users. 
+
+4. LIMITATIONS. Your license to use the SDK is restricted as follows:
+a.	You may not reverse engineer, decompile or disassemble, or remove copyright or other proprietary notices from any portion of the SDK or copies of the SDK. 
+b.	Except as expressly provided in this license, you may not copy, sell, rent, sublicense, transfer, distribute, modify, or create derivative works of any portion of the SDK. For clarity, you may not distribute or sublicense the SDK as a stand-alone product.
+c.	 Unless you have an agreement with NVIDIA for this purpose, you may not indicate that an application created with the SDK is sponsored or endorsed by NVIDIA.
+d.	 You may not bypass, disable, or circumvent any technical limitation, encryption, security, digital rights management or authentication mechanism in the SDK.  
+e.	You may not use the SDK in any manner that would cause it to become subject to an open source software license. As examples, licenses that require as a condition of use, modification, and/or distribution that the SDK be: (i) disclosed or distributed in source code form; (ii) licensed for the purpose of making derivative works; or (iii) redistributable at no charge.
+f.	 Unless you have an agreement with NVIDIA for this purpose, you may not use the SDK with any system or application where the use or failure of the system or application can reasonably be expected to threaten or result in personal injury, death, or catastrophic loss. Examples include use in avionics, navigation, military, medical, life support or other life critical applications. NVIDIA does not design, test or manufacture the SDK for these critical uses and NVIDIA shall not be liable to you or any third party, in whole or in part, for any claims or damages arising from such uses. 
+g.	You agree to defend, indemnify and hold harmless NVIDIA and its affiliates, and their respective employees, contractors, agents, officers and directors, from and against any and all claims, damages, obligations, losses, liabilities, costs or debt, fines, restitutions and expenses (including but not limited to attorney’s fees and costs incident to establishing the right of indemnification) arising out of or related to your use of the SDK outside of the scope of this license, or not in compliance with its terms. 
+
+5. UPDATES. NVIDIA may, at its option, make available patches, workarounds or other updates to this SDK. Unless the updates are provided with their separate governing terms, they are deemed part of the SDK licensed to you as provided in this license. Further, NVIDIA may, at its option, automatically update the SDK or other software in the system, except for those updates that you may opt-out via the SDK API. You agree that the form and content of the SDK that NVIDIA provides may change without prior notice to you. While NVIDIA generally maintains compatibility between versions, NVIDIA may in some cases make changes that introduce incompatibilities in future versions of the SDK.
+
+6. PRE-RELEASE VERSIONS. SDK versions identified as alpha, beta, preview, early access or otherwise as pre-release may not be fully functional, may contain errors or design flaws, and may have reduced or different security, privacy, availability, and reliability standards relative to commercial versions of NVIDIA software and materials. You may use a pre-release SDK version at your own risk, understanding that these versions are not intended for use in production or business-critical systems. NVIDIA may choose not to make available a commercial version of any pre-release SDK. NVIDIA may also choose to abandon development and terminate the availability of a pre-release SDK at any time without liability.
+
+7. THIRD-PARTY COMPONENTS. The SDK may include third-party components with separate legal notices or terms as may be described in proprietary notices accompanying the SDK. If and to the extent there is a conflict between the terms in this license and the third-party license terms, the third-party terms control only to the extent necessary to resolve the conflict. 
+
+8. OWNERSHIP. 
+
+8.1 NVIDIA reserves all rights, title and interest in and to the SDK not expressly granted to you under this license. NVIDIA and its suppliers hold all rights, title and interest in and to the SDK, including their respective intellectual property rights. The SDK is copyrighted and protected by the laws of the United States and other countries, and international treaty provisions.
+
+8.2 Subject to the rights of NVIDIA and its suppliers in the SDK, you hold all rights, title and interest in and to your applications and your derivative works of the sample source code delivered in the SDK including their respective intellectual property rights. 
+ 
+9. FEEDBACK. You may, but are not obligated to, provide Feedback to NVIDIA. “Feedback” means all suggestions, fixes, modifications, feature requests or other feedback regarding the SDK. Feedback, even if designated as confidential by you, shall not create any confidentiality obligation for NVIDIA. If you provide Feedback, you hereby grant NVIDIA, its affiliates and its designees a non-exclusive, perpetual, irrevocable, sublicensable, worldwide, royalty-free, fully paid-up and transferable license, under your intellectual property rights, to publicly perform, publicly display, reproduce, use, make, have made, sell, offer for sale, distribute (through multiple tiers of distribution), import, create derivative works of and otherwise commercialize and exploit the Feedback at NVIDIA’s discretion. You will not give Feedback (i) that you have reason to believe is subject to any restriction that impairs the exercise of the grant stated in this section, such as third-party intellectual property rights or (ii) subject to license terms which seek to require any product incorporating or developed using such Feedback, or other intellectual property of NVIDIA or its affiliates, to be licensed to or otherwise shared with any third party. 
+
+10. NO WARRANTIES. THE SDK IS PROVIDED AS-IS. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW NVIDIA AND ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, USAGE OF TRADE AND COURSE OF DEALING. NVIDIA DOES NOT WARRANT THAT THE SDK WILL MEET YOUR REQUIREMENTS OR THAT THE OPERATION THEREOF WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ALL ERRORS WILL BE CORRECTED. 
+
+11. LIMITATIONS OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW NVIDIA AND ITS AFFILIATES SHALL NOT BE LIABLE FOR ANY (I) SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR FOR DAMAGES FOR  (A) ANY LOST PROFITS, PROJECT DELAYS, LOSS OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR (B) THE COSTS OF PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION WITH THIS LICENSE OR THE USE OR PERFORMANCE OF THE SDK, WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF LIABILITY, EVEN IF NVIDIA HAS PREVIOUSLY BEEN ADVISED OF, OR COULD REASONABLY HAVE FORESEEN, THE POSSIBILITY OF SUCH DAMAGES. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS LICENSE EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS LIMIT. 
+
+12. TERMINATION. Your rights under this license will terminate automatically without notice from NVIDIA if you fail to comply with any term and condition of this license or if you commence or participate in any legal proceeding against NVIDIA with respect to the SDK. NVIDIA may terminate this license with advance written notice to you, if NVIDIA decides to no longer provide the SDK in a country or, in NVIDIA’s sole discretion, the continued use of it is no longer commercially viable. Upon any termination of this license, you agree to promptly discontinue use of the SDK and destroy all copies in your possession or control. Your prior distributions in accordance with this license are not affected by the termination of this license. All provisions of this license will survive termination, except for the license granted to you. 
+
+13. APPLICABLE LAW. This license will be governed in all respects by the laws of the United States and of the State of Delaware, without regard to the conflicts of laws principles. The United Nations Convention on Contracts for the International Sale of Goods is specifically disclaimed. You agree to all terms of this license in the English language. The state or federal courts residing in Santa Clara County, California shall have exclusive jurisdiction over any dispute or claim arising out of this license. Notwithstanding this, you agree that NVIDIA shall still be allowed to apply for injunctive remedies or urgent legal relief in any jurisdiction. 
+
+14. NO ASSIGNMENT. This license and your rights and obligations thereunder may not be assigned by you by any means or operation of law without NVIDIA’s permission. Any attempted assignment not approved by NVIDIA in writing shall be void and of no effect. NVIDIA may assign, delegate or transfer this license and its rights and obligations, and if to a non-affiliate you will be notified.
+ 
+15. EXPORT. The SDK is subject to United States export laws and regulations. You agree to comply with all applicable U.S. and international export laws, including the Export Administration Regulations (EAR) administered by the U.S. Department of Commerce and economic sanctions administered by the U.S. Department of Treasury’s Office of Foreign Assets Control (OFAC). These laws include restrictions on destinations, end-users and end-use. By accepting this license, you confirm that you are not currently residing in a country or region currently embargoed by the U.S. and that you are not otherwise prohibited from receiving the SDK.
+
+16. GOVERNMENT USE. The SDK, documentation and technology (“Protected Items”) are “Commercial products” as this term is defined at 48 C.F.R. 2.101, consisting of “commercial computer software” and “commercial computer software documentation” as such terms are used in, respectively, 48 C.F.R. 12.212 and 48 C.F.R. 227.7202 & 252.227-7014(a)(1). Before any Protected Items are supplied to the U.S. Government, you will (i) inform the U.S. Government in writing that the Protected Items are and must be treated as commercial computer software and commercial computer software documentation developed at private expense; (ii) inform the U.S. Government that the Protected Items are provided subject to the terms of the Agreement; and (iii) mark the Protected Items as commercial computer software and commercial computer software documentation developed at private expense. In no event will you permit the U.S. Government to acquire rights in Protected Items beyond those specified in 48 C.F.R. 52.227-19(b)(1)-(2) or 252.227-7013(c) except as expressly approved by NVIDIA in writing.
+
+17. NOTICES. You agree that any notices that NVIDIA sends you electronically, such as via email, will satisfy any legal communication requirements. Please direct your legal notices or other correspondence to NVIDIA Corporation, 2788 San Tomas Expressway, Santa Clara, California 95051, United States of America, Attention: Legal Department.
+
+18. ENTIRE AGREEMENT. This license is the final, complete and exclusive agreement between the parties relating to the subject matter of this license and supersedes all prior or contemporaneous understandings and agreements relating to this subject matter, whether oral or written. If any court of competent jurisdiction determines that any provision of this license is illegal, invalid or unenforceable, the remaining provisions will remain in full force and effect. Any amendment or waiver under this license shall be in writing and signed by representatives of both parties.
+
+19. LICENSING. If the distribution terms in this license are not suitable for your organization, or for any questions regarding this license, please contact NVIDIA at nvidia-rtx-license-questions@nvidia.com.
+(v. March 14, 2024)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
+
+NVIDIA RTX SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS
+The terms in this supplement govern your use of the NVIDIA RTX SDKs, including the DLSS SDK, NGX SDK, RTXGI SDK, RTXDI SDK, RTX Video SDK, RTX Dynamic Vibrance SDK and/or NRD SDK, if and when made available to you (in each case, the “SDK”) under the terms of your license agreement (“Agreement”) as modified by this supplement. Capitalized terms used but not defined below have the meaning assigned to them in the Agreement.
+This supplement is an exhibit to the Agreement and is incorporated as an integral part of the Agreement. In the event of conflict between the terms in this supplement and the terms in the Agreement, the terms in this supplement govern.  
+
+1. Interoperability. Your applications that incorporate, or are based on, the SDK must be fully interoperable with compatible GPU hardware products designed by NVIDIA or its affiliates. Further, the DLSS SDK, NGX SDK and RTX Dynamic Vibrance SDK are licensed for you to develop applications only for their use in systems with NVIDIA GPUs.
+
+2. Game License. You may, but are not obligated to, provide your game or related content (“Game Content”) to NVIDIA. If you provide Game Content, you hereby grant NVIDIA, its affiliates and its designees a non-exclusive, perpetual, irrevocable, worldwide, royalty-free, fully paid-up license, to use the Game Content to improve NVIDIA DLSS SDK and DLSS Model Training. 
+
+3. Limitations for the DLSS SDK, NGX SDK,RTX Video SDK and RTX Dynamic Vibrance SDK. Your applications that incorporate, or are based on, the DLSS SDK, NGX SDK, RTX Video SDK or RTX Dynamic Vibrance SDK may be deployed in a cloud service that runs on systems that consume NVIDIA vGPU software, and any other cloud service use of such SDKs or their functionality is outside of the scope of the Agreement. For the purpose of this section, cloud services include application service providers or service bureaus, operators of hosted/virtual system environments, or hosting, time sharing or providing any other type of service to others. 
+
+4. Notification for the DLSS SDK, NGX SDK and RTX Dynamic Vibrance SDK. You are required to notify NVIDIA prior to commercial release of an application (including a plug-in to a commercial application) that incorporates, or is based on, the DLSS SDK, NGX SDK or RTX Dynamic Vibrance SDK. Please send notifications to: https://developer.nvidia.com/sw-notification and provide the following information in the email: company name, publisher and developer name, NVIDIA SDK used, application name, platform (i.e. PC, Linux), scheduled ship date, and weblink to product/video. 
+
+5. Audio and Video Encoders and Decoders. You acknowledge and agree that it is your sole responsibility to obtain any additional third-party licenses required to make, have made, use, have used, sell, import, and offer for sale your products or services that include or incorporate any third-party software and content relating to audio and/or video encoders and decoders from, including but not limited to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A., MPEG-LA, and Coding Technologies. NVIDIA does not grant to you under this Agreement any necessary patent or other rights with respect to any audio and/or video encoders and decoders. 
+
+6. SDK Terms. 
+6.1 Over the Air Updates. By installing or using the SDK you agree that NVIDIA can make over-the-air updates of the SDK in systems that have the SDK installed, including (without limitation) for quality, stability or performance improvements or to support new hardware. 
+
+6.2 SDK Integration. If you publicly release a DLSS integration in an end user game or application that presents material stability, performance, image quality, or other technical issues impacting the user experience, you will work to quickly address the integration issues. In the case issues are not addressed, NVIDIA reserves the right, as a last resort, to temporarily disable the DLSS integration until the issues can be fixed.
+
+7. Marketing.
+7.1 Marketing Activities. Your license to the SDK(s) under the Agreement is subject to your compliance with the following marketing terms:
+(a)  Identification by You in the DLSS SDK, NGX SDK, RTX Video SDK or Dynamic Vibrance SDK.  During the term of the Agreement, NVIDIA agrees that you may identify NVIDIA on your websites, printed collateral, trade-show displays and other retail packaging materials, as the supplier of the DLSS SDK,  NGX SDK, RTX Video SDK or Dynamic Vibrance SDK for the applications that were developed with use of such SDKs, provided that all such references to NVIDIA will be subject to NVIDIA's prior review and written approval, which will not be unreasonably withheld or delayed. 
+(b)  NVIDIA Trademark Placement in Applications with the DLSS SDK, NGX SDK, or RTX Video SDK.  For applications that incorporate the DLSS SDK or NGX SDK or portions thereof, you must attribute the use of the applicable SDK and include the NVIDIA Marks on splash screens, in the about box of the application (if present), and in credits for game applications.
+(c) NVIDIA Trademark Placement in Applications with a licensed SDK, other than the DLSS SDK, RTX Video SDK or NGX SDK. For applications that incorporates and/or makes use of a licensed SDK, other than the DLSS SDK, RTX Video SDK or NGX SDK, you must attribute the use of the applicable SDK and include the NVIDIA Marks on the credit screen for applications that have such credit screen, or where a credit screen is not present prominently in end user documentation for the application. 
+(d) Identification by NVIDIA in the DLSS SDK, NGX SDK, RTX Video SDK or Dynamic Vibrance SDK.  You agree that NVIDIA may identify you on NVIDIA's websites, printed collateral, trade-show displays, and other retail packaging materials as an individual or entity that produces products and services which incorporate the DLSS SDK, NGX SDK, RTX Video SDK or Dynamic Vibrance SDK as applicable. To the extent that you provide NVIDIA with input or usage requests with regard to the use of your logo or materials, NVIDIA will use commercially reasonable efforts to comply with such requests.  For the avoidance of doubt, NVIDIA’s rights pursuant to this section shall survive any expiration or termination of the Agreement with respect to existing applications which incorporate the DLSS SDK, RTX Video SDK or NGX SDK.
+(e) Applications Marketing Material in the DLSS SDK, NGX SDK, RTX Video SDK or Dynamic Vibrance SDK. You may provide NVIDIA with screenshots, imagery, and video footage of applications representative of your use of the NVIDIA DLSS SDK or NGX SDKs in your application (collectively, “Assets”). You hereby grant to NVIDIA the right to create and display self-promotional demo materials using the Assets, and after release of the application to the public to distribute, sub-license, and use the Assets to promote and market the NVIDIA RTX SDKs.  To the extent you provide NVIDIA with input or usage requests with regard to the use of your logo or materials, NVIDIA will use commercially reasonable efforts to comply with such requests.  For the avoidance of doubt, NVIDIA’s rights pursuant to this section shall survive any termination of the Agreement with respect to applications which incorporate the NVIDIA RTX SDK.
+
+7.2 Trademark Ownership and Licenses. Trademarks are owned and licenses as follows:
+(a)	Ownership of Trademarks.  Each party owns the trademarks, logos, and trade names (collectively "Marks") for their respective products or services, including without limitation in applications, and the NVIDIA RTX SDKs. Each party agrees to use the Marks of the other only as permitted in this exhibit.
+
+(b)	Trademark License to NVIDIA.  You grant to NVIDIA a non-exclusive, non-sub licensable, non-transferable (except as set forth in the assignment provision of the Agreement), worldwide license to refer to you and your applications, and to use your Marks on NVIDIA's marketing materials and on NVIDIA's website (subject to any reasonable conditions of you) solely for NVIDIA’s marketing activities set forth in this exhibit Sections 7 (d)-(e) above.  NVIDIA will follow your specifications for your Marks as to style, color, and typeface as reasonably provided to NVIDIA.
+
+(c)	Trademark License to You.  NVIDIA grants to you a non-exclusive, non-sub licensable, non-transferable (except as set forth in the assignment provision of the Agreement), worldwide license, subject to the terms of this exhibit and the Agreement, to use NVIDIA RTX™, NVIDIA GeForce RTX™ in combination with GeForce products, and/or NVIDIA Quadro RTX™  in combination with Quadro products (collectively, the “NVIDIA Marks”) on your marketing materials and on your website (subject to any reasonable conditions of NVIDIA) solely for your marketing activities set forth in this exhibit Sections 7.1 (a)-(c) above.  For the avoidance of doubt, you will not and will not permit others to use any NVIDIA Mark for any other goods or services, or in a way that tarnishes, degrades, disparages or reflects adversely any of the NVIDIA Marks or NVIDIA’s business or reputation, or that dilutes or otherwise harms the value, reputation or distinctiveness of or NVIDIA’s goodwill in any NVIDIA Mark. In addition to the termination rights set forth in the Agreement, NVIDIA may terminate this trademark license at any time upon written notice to you. You will follow NVIDIA's use guidelines and specifications for NVIDIA's Marks as to style, color and typeface as provided in NVIDIA Marks and submit a sample of each proposed use of NVIDIA's Marks at least two (2) weeks prior to the desired implementation of such use to obtain NVIDIA's prior written approval (which approval will not be unreasonably withheld or delayed).  If NVIDIA does not respond within ten (10) business days of your submission of such sample, the sample will be deemed unapproved. All goodwill associated with use of NVIDIA Marks will inure to the sole benefit of NVIDIA. For the RTX Video SDK, contact NVIDIA at nvidia-rtx-video-sdk-license-questions@nvidia.com.
+
+7.3 Use Guidelines. Use of the NVIDIA Marks is subject to the following guidelines:
+(a)	Business Practices.  You covenant that you will: (a)  conduct business with respect to NVIDIA’s products in a manner that reflects favorably at all times on the good name, goodwill and reputation of such products; (b) avoid deceptive, misleading or unethical practices that are detrimental to NVIDIA, its customers, or end users; (c) make no false or misleading representations with regard to NVIDIA or its products; and (d) not publish or employ or cooperate in the publication or employment of any misleading or deceptive advertising or promotional materials.
+
+(b)	No Combination Marks or Similar Marks.  You agree not to (a) combine NVIDIA Marks with any other content without NVIDIA’s prior written approval, or (b) use any other trademark, trade name, or other designation of source which creates a likelihood of confusion with NVIDIA Marks.
+
+(v. March 14, 2024)
+

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/NGX.Build.cs

@@ -0,0 +1,104 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using EpicGames.Core;
+using UnrealBuildTool;
+using System.IO;
+
+public class NGX : ModuleRules
+{
+
+	protected virtual bool IsSupportedWindowsPlatform(ReadOnlyTargetRules Target)
+	{
+		return Target.Platform.IsInGroup(UnrealPlatformGroup.Windows);
+	}
+
+	public NGX (ReadOnlyTargetRules Target) : base(Target)
+	{
+		Type = ModuleType.External;
+
+		if (IsSupportedWindowsPlatform(Target))
+		{
+            string NGXPath = ModuleDirectory + "/";
+            
+            PublicSystemIncludePaths.Add(NGXPath + "Include/");
+
+            if ((Target.Configuration == UnrealTargetConfiguration.Debug) && Target.bDebugBuildsActuallyUseDebugCRT)
+            {
+                if (Target.bUseStaticCRT)
+                {
+                    PublicAdditionalLibraries.Add(NGXPath + "Lib/x64/" + "nvsdk_ngx_s_dbg.lib");
+                }
+                else
+                {
+                    PublicAdditionalLibraries.Add(NGXPath + "Lib/x64/" + "nvsdk_ngx_d_dbg.lib");
+                }
+            }
+			else
+            { 
+				if (Target.bUseStaticCRT)
+				{
+					PublicAdditionalLibraries.Add(NGXPath + "Lib/x64/" + "nvsdk_ngx_s.lib");
+				}
+				else
+				{
+					PublicAdditionalLibraries.Add(NGXPath + "Lib/x64/" + "nvsdk_ngx_d.lib");
+				}
+            }
+
+            string[] NGXSnippetDLLs = 
+            {
+                "nvngx_dlss.dll",
+				"nvngx_dlssd.dll"
+            };
+
+			PublicDefinitions.Add("NGX_DLSS_BINARY_NAME=TEXT(\"" + NGXSnippetDLLs[0] + "\")");
+
+			foreach (string NGXSnippetDLL in NGXSnippetDLLs)
+			{
+				bool bHasProjectBinary = false;
+				if (Target.ProjectFile != null)
+				{
+					string ProjectDLLPath = DirectoryReference.Combine(Target.ProjectFile.Directory, "Binaries/ThirdParty/NVIDIA/NGX/Win64", NGXSnippetDLL).FullName;
+					if (File.Exists(ProjectDLLPath))
+					{
+						bHasProjectBinary = true;
+						//Log.TraceInformation("NGX project specific production DLSS binary found at {0}.", ProjectDLLPath);
+						RuntimeDependencies.Add(ProjectDLLPath, StagedFileType.NonUFS);
+					}
+				}
+
+				string SnippetBasePath = Path.Combine(PluginDirectory, "Binaries/ThirdParty/Win64");
+
+				// useful to have both plugin and project specific binary during testing, but if we have a project specific binary, then we want to ship with only that
+				if (!bHasProjectBinary || Target.Configuration != UnrealTargetConfiguration.Shipping)
+				{
+					bool bProdSnippetExists = File.Exists(Path.Combine(SnippetBasePath, NGXSnippetDLL));
+					if (bProdSnippetExists)
+					{
+						RuntimeDependencies.Add("$(PluginDir)/Binaries/ThirdParty/Win64/" + NGXSnippetDLL, StagedFileType.NonUFS);
+					}
+				}
+
+				// useful to have debug overlay during testing, but we don't want to ship with that
+				if (Target.Configuration != UnrealTargetConfiguration.Shipping)
+				{
+					bool bDevSnippetExists = File.Exists(Path.Combine(SnippetBasePath, "Development", NGXSnippetDLL));
+					if (bDevSnippetExists)
+					{
+						RuntimeDependencies.Add("$(PluginDir)/Binaries/ThirdParty/Win64/Development/" + NGXSnippetDLL, StagedFileType.DebugNonUFS);
+					}
+				}
+			}
+		}
+	}
+}
+

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/NGX.tps

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<TpsData xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <Name>NGX</Name>
+  <Location>/Engine/Source/ThirdParty/NVIDIA/NGX</Location>
+  <Function>NGX</Function>
+  <Justification>SDK for DLSS and other NVIDIA DeepLearning technologies</Justification>
+</TpsData>

Plugins/Marketplace/DLSS/Source/ThirdParty/NGX/Utils/DLSS_Debug_Jitter_Configs.txt

@@ -0,0 +1,87 @@
+Jitter Offset Configurations
+
+To assist in debugging issues with sub-pixel jitter, the DLSS SDK library can optionally adjust the jitter offset components using the CTRL+ALT+F9 hotkey. The configurations are listed below and pressing the hotkey cycles through them in order.
+
+To exchange (ie swap) the X and Y offsets, use the CTRL+ALT+F10 hotkey.
+
+
+// By default, jitter offsets are used as sent from the engine 
+Config 0: OFF 
+
+
+// Combinations halving and negating both vector components
+Config 1:
+	JitterOffsetX *= 0.5f;
+	JitterOffsetY *= 0.5f;
+
+Config 2:
+	JitterOffsetX *= 0.5f;
+	JitterOffsetY *= -0.5f;
+	
+Config 3:
+	JitterOffsetX *= -0.5f;
+	JitterOffsetY *= 0.5f;
+	
+Config 4:
+	JitterOffsetX *= -0.5f;
+	JitterOffsetY *= -0.5f;
+	
+
+// Combinations doubling and negating both vector components
+Config 5:
+	JitterOffsetX *= 2.0f;
+	JitterOffsetY *= 2.0f;
+	
+Config 6:
+	JitterOffsetX *= 2.0f;
+	JitterOffsetY *= -2.0f;
+	
+Config 7:
+	JitterOffsetX *= -2.0f;
+	JitterOffsetY *= 2.0f;
+	
+Config 8:
+	JitterOffsetX *= -2.0f;
+	JitterOffsetY *= -2.0f;
+
+
+// Combinations negating one or both vector components 
+Config 9:
+	JitterOffsetX *= 1.0f;
+	JitterOffsetY *= -1.0f;
+	
+Config 10:
+	JitterOffsetX *= -1.0f;
+	JitterOffsetY *= 1.0f;
+	
+Config 11:
+	JitterOffsetX *= -1.0f;
+	JitterOffsetY *= -1.0f;
+
+
+// Combinations halving and negating individual vector components 
+Config 12:
+	JitterOffsetX *= 0.5f;
+	
+Config 13:
+	JitterOffsetY *= 0.5f;
+	
+Config 14:
+	JitterOffsetX *= -0.5f;
+	
+Config 15:
+	JitterOffsetY *= -0.5f;
+
+	
+// Combinations doubling and negating individual vector components 
+Config 16:
+	JitterOffsetX *= 2.0f;
+	
+Config 17:
+	JitterOffsetY *= 2.0f;
+	
+Config 18:
+	JitterOffsetX *= -2.0f;
+	
+Config 19:
+	JitterOffsetY *= -2.0f;

Plugins/Marketplace/DLSSMoviePipelineSupport/DLSSMoviePipelineSupport.uplugin

@@ -0,0 +1,36 @@
+{
+	"FileVersion": 3,
+	"Version": 24,
+	"VersionName": "4.0.0",
+	"FriendlyName": "Movie Render Queue DLSS/DLAA Support",
+	"Description": "Plugin that adds DLSS/DLAA support to Movie Render Queue.",
+	"Category": "Rendering",
+	"CreatedBy": "NVIDIA",
+	"CreatedByURL": "https://developer.nvidia.com/dlss",
+	"DocsURL": "",
+	"MarketplaceURL": "https://www.unrealengine.com/marketplace/en-US/product/nvidia-dlss",
+	"SupportURL": "mailto:DLSS-Support@nvidia.com",
+	"EngineVersion": "5.5.0",
+	"CanContainContent": true,
+	"Installed": true,
+	"Modules": [
+		{
+			"Name": "DLSSMoviePipelineSupport",
+			"Type": "Runtime",
+			"LoadingPhase": "PostEngineInit",
+			"PlatformAllowList": [
+				"Win64"
+			]
+		}
+	],
+	"Plugins": [
+		{
+			"Name": "MovieRenderPipeline",
+			"Enabled": true
+		},
+		{
+			"Name": "DLSS",
+			"Enabled": true
+		}
+	]
+}

Plugins/Marketplace/DLSSMoviePipelineSupport/Source/DLSSMoviePipelineSupport/DLSSMoviePipelineSupport.Build.cs

@@ -0,0 +1,33 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+
+public class DLSSMoviePipelineSupport : ModuleRules
+{
+	public DLSSMoviePipelineSupport(ReadOnlyTargetRules Target) : base(Target)
+	{
+		ShortName = "DLSSMPS";
+
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"DLSS",
+				"DLSSBlueprint",
+				"Engine",
+				"MovieRenderPipelineCore",
+				"MovieRenderPipelineRenderPasses",
+			}
+		);
+	}
+}

Plugins/Marketplace/DLSSMoviePipelineSupport/Source/DLSSMoviePipelineSupport/Private/DLSSMoviePipelineSupportModule.cpp

@@ -0,0 +1,14 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_MODULE(FDefaultModuleImpl, DLSSMoviePipelineSupport)

Plugins/Marketplace/DLSSMoviePipelineSupport/Source/DLSSMoviePipelineSupport/Private/MoviePipelineDLSSSetting.cpp

@@ -0,0 +1,110 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "MoviePipelineDLSSSetting.h"
+
+#include "DLSS.h"
+#include "DLSSLibrary.h"
+#include "MovieRenderPipelineDataTypes.h"
+#include "SceneView.h"
+
+#define LOCTEXT_NAMESPACE "MoviePipelineDLSSSetting"
+
+namespace MRQHelpers
+{
+	UDLSSMode EMoviePipelineDLSSQualityToUDLSSMode(EMoviePipelineDLSSQuality InDLSSQuality)
+	{
+		// Offset our quality to be consistent with UDLSSMode enum.
+		uint8 OffsetDlssQuality = static_cast<uint8>(InDLSSQuality) + static_cast<uint8>(UDLSSMode::DLAA);
+		return static_cast<UDLSSMode>(OffsetDlssQuality);
+	}
+}
+
+UMoviePipelineDLSSSetting::UMoviePipelineDLSSSetting()
+	: DLSSQuality(EMoviePipelineDLSSQuality::EMoviePipelineDLSSQuality_Performance)
+{
+}
+
+void UMoviePipelineDLSSSetting::SetupViewFamily(FSceneViewFamily& ViewFamily)
+{
+	bool bIsSupported = false;
+	if (ViewFamily.ViewMode == EViewModeIndex::VMI_Lit)
+	{
+		float OptimalScreenPercentage;
+		{
+			// find optimal screen percentage for quality mode
+			FVector2D DummyScreenRes{};
+			bool bDummyFixed;
+			float DummyMin, DummyMax, DummySharpness;
+			UDLSSLibrary::GetDLSSModeInformation(MRQHelpers::EMoviePipelineDLSSQualityToUDLSSMode(DLSSQuality), DummyScreenRes,
+				bIsSupported,
+				OptimalScreenPercentage,
+				bDummyFixed, DummyMin, DummyMax, DummySharpness);
+		}
+
+		if (bIsSupported)
+		{
+			// set screen percentage
+			static IConsoleVariable* CVarScreenPercentage = IConsoleManager::Get().FindConsoleVariable(TEXT("r.ScreenPercentage"));
+			if (CVarScreenPercentage != nullptr)
+			{
+				EConsoleVariableFlags Priority = static_cast<EConsoleVariableFlags>(CVarScreenPercentage->GetFlags() & ECVF_SetByMask);
+				CVarScreenPercentage->Set(OptimalScreenPercentage, Priority);
+			}
+
+			// setup view extension
+			IDLSSModuleInterface* DLSSModule = &FModuleManager::LoadModuleChecked<IDLSSModuleInterface>("DLSS");
+			TSharedPtr<ISceneViewExtension> DLSSViewExt = DLSSModule->GetDLSSUpscalerViewExtension();
+			if (DLSSViewExt.IsValid() && !ViewFamily.ViewExtensions.Contains(DLSSViewExt))
+			{
+				ViewFamily.ViewExtensions.Add(DLSSViewExt.ToSharedRef());
+			}
+		}
+	}
+	UDLSSLibrary::EnableDLSS(bIsSupported);
+}
+
+void UMoviePipelineDLSSSetting::GetFormatArguments(FMoviePipelineFormatArgs& InOutFormatArgs) const
+{
+	Super::GetFormatArguments(InOutFormatArgs);
+
+	bool bIsCurrentModeSupported = UDLSSLibrary::IsDLSSModeSupported(MRQHelpers::EMoviePipelineDLSSQualityToUDLSSMode(DLSSQuality));
+	// Only embed meta data if the quality mode is supported.
+	if (bIsCurrentModeSupported)
+	{
+		InOutFormatArgs.FileMetadata.Add(TEXT("unreal/dlssQuality"), StaticEnum<EMoviePipelineDLSSQuality>()->GetDisplayNameTextByIndex((int64)DLSSQuality).ToString());
+		InOutFormatArgs.FilenameArguments.Add(TEXT("dlss_quality"), StaticEnum<EMoviePipelineDLSSQuality>()->GetDisplayNameTextByIndex((int64)DLSSQuality).ToString());
+	}
+	else
+	{
+		InOutFormatArgs.FileMetadata.Add(TEXT("unreal/dlssQuality"), "Unsupported");
+		InOutFormatArgs.FilenameArguments.Add(TEXT("dlss_quality"), "Unsupported");
+	}
+}
+
+void UMoviePipelineDLSSSetting::ValidateStateImpl()
+{
+	Super::ValidateStateImpl();
+
+	if (!UDLSSLibrary::IsDLSSSupported())
+	{
+
+		ValidationResults.Add(FText::Format(LOCTEXT("DLSS_Unsupported", "DLSS is not supported due to \"{0}\"."), StaticEnum<UDLSSSupport>()->GetDisplayNameTextByValue(int64(UDLSSLibrary::QueryDLSSSupport()))));
+		ValidationState = EMoviePipelineValidationState::Warnings;
+
+	}
+	else if (!UDLSSLibrary::IsDLSSModeSupported(MRQHelpers::EMoviePipelineDLSSQualityToUDLSSMode(DLSSQuality)))
+	{
+		ValidationResults.Add(FText::Format(LOCTEXT("DLSS_Mode_Unsupported", "\"{0}\" Mode is not supported. Please try a lower quality setting."), StaticEnum<EMoviePipelineDLSSQuality>()->GetDisplayNameTextByIndex((int64)DLSSQuality)));
+		ValidationState = EMoviePipelineValidationState::Warnings;
+	}
+
+}

Plugins/Marketplace/DLSSMoviePipelineSupport/Source/DLSSMoviePipelineSupport/Public/MoviePipelineDLSSSetting.h

@@ -0,0 +1,53 @@
+/*
+* Copyright (c) 2020 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "MoviePipelineViewFamilySetting.h"
+#include "MoviePipelineDLSSSetting.generated.h"
+
+class FSceneViewFamily;
+
+UENUM(BlueprintType)
+enum class EMoviePipelineDLSSQuality : uint8
+{
+	EMoviePipelineDLSSQuality_DLAA					UMETA(DisplayName = "DLAA"),
+	EMoviePipelineDLSSQuality_UltraQuality			UMETA(DisplayName = "Ultra Quality"),
+	EMoviePipelineDLSSQuality_Quality				UMETA(DisplayName = "Quality"),
+	EMoviePipelineDLSSQuality_Balanced				UMETA(DisplayName = "Balanced"),
+	EMoviePipelineDLSSQuality_Performance			UMETA(DisplayName = "Performance"),
+	EMoviePipelineDLSSQuality_UltraPerformance		UMETA(DisplayName = "Ultra Performance"),
+};
+
+UCLASS(BlueprintType)
+class DLSSMOVIEPIPELINESUPPORT_API UMoviePipelineDLSSSetting : public UMoviePipelineViewFamilySetting
+{
+	GENERATED_BODY()
+public:
+	UMoviePipelineDLSSSetting();
+
+public:
+#if WITH_EDITOR
+	virtual FText GetDisplayText() const override { return NSLOCTEXT("MovieRenderPipeline", "DlssSettingDisplayName", "DLSS/DLAA"); }
+#endif
+
+	/** This method is run right before rendering starts which forwards all required info to DLSS plugin. */
+	virtual void SetupViewFamily(FSceneViewFamily& ViewFamily) override;
+
+	/** For the purposes of embedding DLSS quality setting. */
+	virtual void GetFormatArguments(FMoviePipelineFormatArgs& InOutFormatArgs) const override;
+
+	virtual void ValidateStateImpl() override;
+	
+	/** DLSS/DLAA quality setting */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DLSS/DLAA settings", DisplayName = "DLSS Quality")
+	EMoviePipelineDLSSQuality DLSSQuality;
+};

Plugins/Marketplace/NIS/Config/FilterPlugin.ini

@@ -0,0 +1,11 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll
+
+/Config/...
+

Plugins/Marketplace/NIS/NIS.uplugin

@@ -0,0 +1,33 @@
+{
+	"FileVersion": 3,
+	"Version": 5,
+	"VersionName": "4.0.0",
+	"FriendlyName": "NVIDIA Image Scaling (NIS)",
+	"Description": "NVIDIA Image Scaling boosts frame rates using GPU scaling and sharpening.",
+	"Category": "Rendering",
+	"CreatedBy": "NVIDIA",
+	"CreatedByURL": "https://developer.nvidia.com/image-scaling",
+	"DocsURL": "",
+	"MarketplaceURL": "https://www.unrealengine.com/marketplace/en-US/product/nvidia-dlss",
+	"SupportURL": "mailto:DLSS-Support@nvidia.com",
+	"EngineVersion": "5.5.0",
+	"CanContainContent": false,
+	"Installed": true,
+	"Modules": [
+		{
+			"Name": "NISCore",
+			"Type": "Runtime",
+			"LoadingPhase": "PostEngineInit"
+		},
+		{
+			"Name": "NISShaders",
+			"Type": "Runtime",
+			"LoadingPhase": "PostConfigInit"
+		},
+		{
+			"Name": "NISBlueprint",
+			"Type": "Runtime",
+			"LoadingPhase": "PostConfigInit"
+		}
+	]
+}

Plugins/Marketplace/NIS/Shaders/Private/NISUpscaler.usf

@@ -0,0 +1,103 @@
+// The MIT License(MIT)
+// 
+// Copyright(c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files(the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions :
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#include "/Engine/Public/Platform.ush"
+
+#define NIS_HLSL 1
+#define NIS_GLSL 0
+#define NIS_UNROLL UNROLL
+
+#ifndef NIS_SCALER
+#define NIS_SCALER 1
+#endif
+
+#ifndef NIS_DXC
+#define NIS_DXC 0
+#endif
+
+#if NIS_DXC
+#define NIS_PUSH_CONSTANT    [[vk::push_constant]]
+#define NIS_BINDING(bindingIndex) [[vk::binding(bindingIndex, 0)]]
+#else
+#define NIS_PUSH_CONSTANT
+#define NIS_BINDING(bindingIndex)
+#endif
+
+
+//NIS_BINDING(0) cbuffer cb : register(b0)
+//{
+	float kDetectRatio;
+	float kDetectThres;
+	float kMinContrastRatio;
+	float kRatioNorm;
+
+	float kContrastBoost;
+	float kEps;
+	float kSharpStartY;
+	float kSharpScaleY;
+
+	float kSharpStrengthMin;
+	float kSharpStrengthScale;
+	float kSharpLimitMin;
+	float kSharpLimitScale;
+
+	float kScaleX;
+	float kScaleY;
+
+	float kDstNormX;
+	float kDstNormY;
+	float kSrcNormX;
+	float kSrcNormY;
+
+	uint kInputViewportOriginX;
+	uint kInputViewportOriginY;
+	uint kInputViewportWidth;
+	uint kInputViewportHeight;
+
+	uint kOutputViewportOriginX;
+	uint kOutputViewportOriginY;
+	uint kOutputViewportWidth;
+	uint kOutputViewportHeight;
+
+	float reserved0;
+	float reserved1;
+//};
+
+NIS_BINDING(1) SamplerState samplerLinearClamp/* : register(s0)*/;
+NIS_BINDING(2) Texture2D in_texture /*: register(t0)*/;
+NIS_BINDING(3) RWTexture2D<float4> out_texture /*: register(u0)*/;
+#if NIS_SCALER
+NIS_BINDING(4) Texture2D coef_scaler /*: register(t1)*/;
+NIS_BINDING(5) Texture2D coef_usm /*: register(t2)*/;
+#endif
+
+
+#include "/ThirdParty/Plugin/NIS/NIS_Scaler.h"
+
+[numthreads(NIS_THREAD_GROUP_SIZE, 1, 1)]
+void main(uint3 blockIdx : SV_GroupID, uint3 threadIdx : SV_GroupThreadID)
+{
+#if NIS_SCALER
+	NVScaler(blockIdx.xy, threadIdx.x);
+#else
+	NVSharpen(blockIdx.xy, threadIdx.x);
+#endif
+}

Plugins/Marketplace/NIS/Shaders/ThirdParty/NIS_Main.glsl

@@ -0,0 +1,99 @@
+// The MIT License(MIT)
+//
+// Copyright(c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files(the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+//---------------------------------------------------------------------------------
+// NVIDIA Image Scaling SDK  - v1.0.3
+//---------------------------------------------------------------------------------
+// GLSL main example
+//---------------------------------------------------------------------------------
+
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+#extension GL_GOOGLE_include_directive : enable
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+
+#define NIS_GLSL 1
+
+#ifndef NIS_SCALER
+#define NIS_SCALER 1
+#endif
+
+layout(set=0,binding=0) uniform const_buffer
+{
+    float kDetectRatio;
+    float kDetectThres;
+    float kMinContrastRatio;
+    float kRatioNorm;
+
+    float kContrastBoost;
+    float kEps;
+    float kSharpStartY;
+    float kSharpScaleY;
+
+    float kSharpStrengthMin;
+    float kSharpStrengthScale;
+    float kSharpLimitMin;
+    float kSharpLimitScale;
+
+    float kScaleX;
+    float kScaleY;
+
+    float kDstNormX;
+    float kDstNormY;
+    float kSrcNormX;
+    float kSrcNormY;
+
+    uint kInputViewportOriginX;
+    uint kInputViewportOriginY;
+    uint kInputViewportWidth;
+    uint kInputViewportHeight;
+
+    uint kOutputViewportOriginX;
+    uint kOutputViewportOriginY;
+    uint kOutputViewportWidth;
+    uint kOutputViewportHeight;
+
+    float reserved0;
+    float reserved1;
+};
+
+layout(set=0,binding=1) uniform sampler samplerLinearClamp;
+layout(set=0,binding=2) uniform texture2D in_texture;
+layout(set=0,binding=3) uniform writeonly image2D out_texture;
+
+#if NIS_SCALER
+layout(set=0,binding=4) uniform texture2D coef_scaler;
+layout(set=0,binding=5) uniform texture2D coef_usm;
+#endif
+
+#include "NIS_Scaler.h"
+
+layout(local_size_x=NIS_THREAD_GROUP_SIZE) in;
+void main()
+{
+    #if NIS_SCALER
+        NVScaler(gl_WorkGroupID.xy, gl_LocalInvocationID.x);
+    #else
+        NVSharpen(gl_WorkGroupID.xy, gl_LocalInvocationID.x);
+    #endif
+}

Plugins/Marketplace/NIS/Shaders/ThirdParty/NIS_Main.hlsl

@@ -0,0 +1,111 @@
+// The MIT License(MIT)
+//
+// Copyright(c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files(the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+//---------------------------------------------------------------------------------
+// NVIDIA Image Scaling SDK  - v1.0.3
+//---------------------------------------------------------------------------------
+// HLSL main example
+//---------------------------------------------------------------------------------
+
+#define NIS_HLSL 1
+
+#ifndef NIS_SCALER
+#define NIS_SCALER 1
+#endif
+
+#ifndef NIS_DXC
+#define NIS_DXC 0
+#endif
+
+#if NIS_DXC
+#define NIS_PUSH_CONSTANT    [[vk::push_constant]]
+#define NIS_BINDING(bindingIndex) [[vk::binding(bindingIndex, 0)]]
+#else
+#define NIS_PUSH_CONSTANT
+#define NIS_BINDING(bindingIndex)
+#endif
+
+
+NIS_BINDING(0) cbuffer cb : register(b0)
+{
+    float kDetectRatio;
+    float kDetectThres;
+    float kMinContrastRatio;
+    float kRatioNorm;
+
+    float kContrastBoost;
+    float kEps;
+    float kSharpStartY;
+    float kSharpScaleY;
+
+    float kSharpStrengthMin;
+    float kSharpStrengthScale;
+    float kSharpLimitMin;
+    float kSharpLimitScale;
+
+    float kScaleX;
+    float kScaleY;
+
+    float kDstNormX;
+    float kDstNormY;
+    float kSrcNormX;
+    float kSrcNormY;
+
+    uint kInputViewportOriginX;
+    uint kInputViewportOriginY;
+    uint kInputViewportWidth;
+    uint kInputViewportHeight;
+
+    uint kOutputViewportOriginX;
+    uint kOutputViewportOriginY;
+    uint kOutputViewportWidth;
+    uint kOutputViewportHeight;
+
+    float reserved0;
+    float reserved1;
+};
+
+NIS_BINDING(1) SamplerState samplerLinearClamp : register(s0);
+#if NIS_NV12_SUPPORT
+NIS_BINDING(2) Texture2D<float> in_texture_y   : register(t0);
+NIS_BINDING(2) Texture2D<float2> in_texture_uv : register(t3);
+#else
+NIS_BINDING(2) Texture2D in_texture            : register(t0);
+#endif
+NIS_BINDING(3) RWTexture2D<float4> out_texture : register(u0);
+#if NIS_SCALER
+NIS_BINDING(4) Texture2D coef_scaler           : register(t1);
+NIS_BINDING(5) Texture2D coef_usm              : register(t2);
+#endif
+
+
+
+#include "NIS_Scaler.h"
+
+[numthreads(NIS_THREAD_GROUP_SIZE, 1, 1)]
+void main(uint3 blockIdx : SV_GroupID, uint3 threadIdx : SV_GroupThreadID)
+{
+#if NIS_SCALER
+    NVScaler(blockIdx.xy, threadIdx.x);
+#else
+    NVSharpen(blockIdx.xy, threadIdx.x);
+#endif
+}

Plugins/Marketplace/NIS/Source/NISBlueprint/NISBlueprint.Build.cs

@@ -0,0 +1,57 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+using System.IO;
+
+public class NISBlueprint : ModuleRules
+{
+
+	public NISBlueprint(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"Engine",
+				"RenderCore",
+				"Renderer",
+				"Projects",
+			}
+		);
+
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				//"Core",
+				//"RenderCore",
+				//"Renderer",
+				"NISShaders",
+				"RHI",
+			}
+		);
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				EngineDirectory + "/Source/Runtime/Renderer/Private",
+				// ... add other private include paths required here ...
+			}
+			);
+
+		
+	}
+
+
+}
+

Plugins/Marketplace/NIS/Source/NISBlueprint/Private/NISLibrary.cpp

@@ -0,0 +1,231 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "NISLibrary.h"
+#include "NISShaders.h"
+#include "Modules/ModuleManager.h"
+#include "Interfaces/IPluginManager.h"
+#include "ShaderCore.h"
+#include "PostProcess/TemporalAA.h"
+
+#include "Runtime/Launch/Resources/Version.h"
+
+#define LOCTEXT_NAMESPACE "FNISBlueprintModule"
+DEFINE_LOG_CATEGORY_STATIC(LogNISBlueprint, Log, All);
+
+static const FName SetNISModeInvalidEnumValueError= FName("SetNISModeInvalidEnumValueError");
+static const FName IsNISModeSupportedInvalidEnumValueError = FName("IsNISModeSupportedInvalidEnumValueError");
+
+UNISSupport UNISLibrary::NISSupport = UNISSupport::Supported;
+
+FNISUpscaler* UNISLibrary::NISUpscaler = nullptr;
+
+float UNISLibrary::SavedCustomScreenPercentage = 100.0f;
+
+bool UNISLibrary::bIsCustomMode = false;
+
+
+static TAutoConsoleVariable<int32> CVarNISUpscalingAutomaticMipMapLODBias(
+	TEXT("r.NIS.Upscaling.AutomaticMipMapLODBias"),
+	1,
+	TEXT("Enable automatic setting of r.MipMapLODBias based on the effective NIS screen percentage (default=1)\n")
+	TEXT("NOTE: This is only applied when using the UNISLibrary::SetNISMode blueprint function."),
+	ECVF_RenderThreadSafe);
+
+static TAutoConsoleVariable<float> CVarNISUpscalingAutomaticMipMapLODBiasOffset(
+	TEXT("r.NIS.Upscaling.AutomaticMipMapLODBias.Offset"),
+	-0.3f,
+	TEXT("Allows offsetting the automatic resolution dependent mip map LOD bias by this amount (default=0)\n")
+	TEXT("NOTE: This is only applied when using the UNISLibrary::SetNISMode blueprint function."),
+	ECVF_RenderThreadSafe);
+
+bool UNISLibrary::IsNISModeSupported(UNISMode NISMode)
+{
+	return true;
+}
+
+void UNISLibrary::GetNISScreenPercentageRange(float& MinScreenPercentage, float& MaxScreenPercentage)
+{
+	if (IsNISSupported())
+	{
+		MinScreenPercentage = 100.0f * 0.5f;
+		MaxScreenPercentage = 100.0f * 1.0f;
+	}
+	else
+	{
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+		MinScreenPercentage = 100.0f * ISceneViewFamilyScreenPercentage::kMinTAAUpsampleResolutionFraction;
+		MaxScreenPercentage = 100.0f * ISceneViewFamilyScreenPercentage::kMaxTAAUpsampleResolutionFraction;
+#else
+		MinScreenPercentage = 100.0f * ITemporalUpscaler::GetDefaultTemporalUpscaler()->GetMinUpsampleResolutionFraction();
+		MaxScreenPercentage = 100.0f * ITemporalUpscaler::GetDefaultTemporalUpscaler()->GetMaxUpsampleResolutionFraction();
+#endif
+	}
+}
+
+TArray<UNISMode> UNISLibrary::GetSupportedNISModes()
+{
+	TArray<UNISMode> SupportedQualityModes;
+	{
+		const UEnum* Enum = StaticEnum<UNISMode>();
+		for (int32 EnumIndex = 0; EnumIndex < Enum->NumEnums(); ++EnumIndex)
+		{
+			const int64 EnumValue = Enum->GetValueByIndex(EnumIndex);
+			if (EnumValue != Enum->GetMaxEnumValue())
+			{
+				const UNISMode QualityMode = UNISMode(EnumValue);
+				if (IsNISModeSupported(QualityMode))
+				{
+					SupportedQualityModes.Add(QualityMode);
+				}
+			}
+		}
+	}
+	return SupportedQualityModes;
+}
+
+bool UNISLibrary::IsNISSupported()
+{
+	return  GMaxRHIFeatureLevel >= GetNISMinRequiredFeatureLevel();
+}
+
+
+float UNISLibrary::GetNISRecommendedScreenPercentage(UNISMode NISMode)
+{
+	switch (NISMode)
+	{
+	default:
+		checkf(false, TEXT("dear NIS plugin NVIDIA developer, please update this code to handle the new enum values"));
+	case UNISMode::Off:
+		return 1.0f;
+	case UNISMode::UltraQuality:
+		return 77.0f;
+	case UNISMode::Quality:
+		return 66.667f;
+	case UNISMode::Balanced:
+		return 59.0f;
+	case UNISMode::Performance:
+		return 50.0;
+	case UNISMode::Custom:
+		return SavedCustomScreenPercentage;
+		break;
+	}
+}
+
+void UNISLibrary::SetNISMode(UNISMode NISMode)
+{
+	const UEnum* Enum = StaticEnum<UNISMode>();
+
+	// UEnums are strongly typed, but then one can also cast a byte to an UEnum ...
+	if(Enum->IsValidEnumValue(int64(NISMode)) && (Enum->GetMaxEnumValue() != int64(NISMode)))
+	{
+		static auto CVarNISEnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Enable"));
+		static auto CVarNISUpscalingEnable = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Upscaling"));
+		
+		// Save whether we're in custom mode so we can do the right thing when custom screen percentage changes
+		bIsCustomMode = UNISMode::Custom == NISMode;
+
+		// r.NIS.Enable might be set to 0 via a hotfix so set r.NIS.Enable to 0 too (in case it might come from saved settings)
+		const bool bNISEnabled = CVarNISEnable && CVarNISEnable->GetInt();
+
+		if (ensure(CVarNISUpscalingEnable) && ensure(CVarNISEnable))
+		{
+			const bool bNISUpscalingEnabled = bNISEnabled && ( NISMode != UNISMode::Off);
+			CVarNISUpscalingEnable->Set(bNISUpscalingEnabled ? 1 : 0, ECVF_SetByCommandline);
+
+			if(bNISUpscalingEnabled)
+			{
+				// Temporal upscalers such as DLSS might set this to 1, but we need r.TemporalAA.Upscaler to be 0 for NIS to work.
+				static const auto CVarTemporalAAUpscaler = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TemporalAA.Upscaler"));
+				CVarTemporalAAUpscaler->SetWithCurrentPriority(bNISUpscalingEnabled ? 0 : 1);
+
+				static const auto CVarTemporalAAUpsampling = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TemporalAA.Upsampling"));
+				CVarTemporalAAUpsampling->SetWithCurrentPriority(bNISUpscalingEnabled ? 0 : 1);
+
+				static auto CVarScreenPercentage = IConsoleManager::Get().FindConsoleVariable(TEXT("r.ScreenPercentage"));
+				if (ensure(CVarScreenPercentage))
+				{
+					const float ScreenPercentage = GetNISRecommendedScreenPercentage(NISMode);
+					CVarScreenPercentage->SetWithCurrentPriority(ScreenPercentage);
+
+					if (CVarNISUpscalingAutomaticMipMapLODBias.GetValueOnAnyThread())
+					{
+						static auto CVarMipMapLodBias = IConsoleManager::Get().FindConsoleVariable(TEXT("r.MipMapLODBias"));
+						if (ensure(CVarMipMapLodBias))
+						{
+							const float EffectivePrimaryResolutionFraction = ScreenPercentage * 0.01f;
+							const float MipBias = FMath::Log2(EffectivePrimaryResolutionFraction) + CVarNISUpscalingAutomaticMipMapLODBiasOffset.GetValueOnAnyThread();
+							CVarMipMapLodBias->SetWithCurrentPriority(MipBias);
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+#if !UE_BUILD_SHIPPING
+		FFrame::KismetExecutionMessage(*FString::Printf(
+			TEXT("SetNISMode should not be called with an invalid NISMode enum value (%d) \"%s\""), 
+			int64(NISMode), *StaticEnum<UNISMode>()->GetDisplayNameTextByValue(int64(NISMode)).ToString()),
+			ELogVerbosity::Error, SetNISModeInvalidEnumValueError);
+#endif 
+	}
+}
+
+void UNISLibrary::SetNISCustomScreenPercentage(float CustomScreenPercentage)
+{
+	SavedCustomScreenPercentage = CustomScreenPercentage;
+
+	// Custom screen percentage has changed, so if we're in Custom mode we should run the set mode logic again
+	if (bIsCustomMode)
+	{
+		SetNISMode(UNISMode::Custom);
+	}
+}
+
+void UNISLibrary::SetNISSharpness(float Sharpness)
+{
+	static const auto CVarNISharpness = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Sharpness"));
+	
+	if (CVarNISharpness)
+	{
+		// Quantize here so we can have sharpness snap to 0, which downstream is used to turn off sharpening
+		// CVarNISharpness->Set(Sharpness, ECVF_SetByCommandline)  internally uses	Set(*FString::Printf(TEXT("%g"), InValue), SetBy);
+		CVarNISharpness->Set(*FString::Printf(TEXT("%2.2f"), Sharpness), ECVF_SetByCommandline);
+	}
+}
+
+UNISMode UNISLibrary::GetDefaultNISMode()
+{
+	if (UNISLibrary::IsNISSupported())
+	{
+		return UNISMode::UltraQuality;
+	}
+	else
+	{
+		return UNISMode::Off;
+	}
+}
+
+void FNISBlueprintModule::StartupModule()
+{
+}
+
+void FNISBlueprintModule::ShutdownModule()
+{
+}
+
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FNISBlueprintModule, NISBlueprint)
+

Plugins/Marketplace/NIS/Source/NISBlueprint/Public/NISLibrary.h

@@ -0,0 +1,105 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+#include "UObject/ObjectMacros.h"
+#include "UObject/Object.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Misc/CoreDelegates.h"
+
+#include "NISLibrary.generated.h"
+
+class FNISUpscaler;
+class FDelegateHandle;
+
+
+UENUM(BlueprintType)
+enum class UNISSupport : uint8
+{
+	Supported UMETA(DisplayName = "Supported"),
+	NotSupported UMETA(DisplayName = "Not Supported due to insufficient RHI Feature Level"),
+};
+
+
+UENUM(BlueprintType)
+enum class UNISMode : uint8
+{
+	Off              UMETA(DisplayName = "Off"),
+	UltraQuality     UMETA(DisplayName = "Ultra Quality"),
+	Quality          UMETA(DisplayName = "Quality"),
+	Balanced         UMETA(DisplayName = "Balanced"),
+	Performance      UMETA(DisplayName = "Performance"),
+	Custom           UMETA(DisplayName = "Custom")
+};
+
+UCLASS(MinimalAPI)
+class  UNISLibrary : public UBlueprintFunctionLibrary
+{
+	friend class FNISBlueprintModule;
+	GENERATED_BODY()
+public:
+
+	/** Checks whether NIS is supported by the current GPU. Further details can be retrieved via QueryNISSupport*/
+	UFUNCTION(BlueprintPure, Category = "NIS", meta = (DisplayName = "Is NVIDIA NIS Supported"))
+	static NISBLUEPRINT_API bool IsNISSupported();
+
+	/** Checks whether a NIS mode is supported */
+	UFUNCTION(BlueprintPure, Category = "NIS", meta = (DisplayName = "Is NIS Mode Supported"))
+	static NISBLUEPRINT_API bool IsNISModeSupported(UNISMode NISMode);
+
+	/** Retrieves all supported NIS modes. Can be used to populate UI */
+	UFUNCTION(BlueprintPure, Category = "NIS", meta = (DisplayName = "Get Supported NIS Modes"))
+	static NISBLUEPRINT_API TArray<UNISMode> GetSupportedNISModes();
+
+	/** Returns the recommended screen percentage for a given NIS mode. Returns CustomScreenPercentage if NISMode is UNISMode::Custom */
+	UFUNCTION(BlueprintPure, Category = "NIS", meta = (DisplayName = "Get NIS Recommended Screen Percentage"))
+	static NISBLUEPRINT_API float GetNISRecommendedScreenPercentage(UNISMode NISMode);
+
+	/** The global screen percentage range that NIS supports. */
+	UFUNCTION(BlueprintPure, Category = "NIS", meta = (DisplayName = "Get NIS Screen Percentage Range"))
+	static NISBLUEPRINT_API void GetNISScreenPercentageRange(float& MinScreenPercentage, float& MaxScreenPercentage);
+
+	/** Sets the console variables to enable/disable NIS (r.NIS.Enable, r.NIS.Upscaling, r.ScreenPercentage, r.TemporalAA.Upsampling, r.TemporalAA.Upscaler)*/
+	UFUNCTION(BlueprintCallable, Category = "NIS", meta = (DisplayName = "Set NIS Mode"))
+	static NISBLUEPRINT_API void SetNISMode(UNISMode NISMode);
+
+	/** Set the screen percentage used for Custom mode (100% by default) */
+	UFUNCTION(BlueprintCallable, Category = "NIS", meta = (DisplayName = "Set NIS Custom Screen Percentage"))
+	static NISBLUEPRINT_API void SetNISCustomScreenPercentage(float CustomScreenPercentage = 100.0f);
+
+	/* Sets the console variables to enable additional NIS sharpening. Set to 0 to disable (r.NGX.NIS.Sharpness) */
+	UFUNCTION(BlueprintCallable, Category = "NIS", meta = (DisplayName = "Set NIS Sharpness"))
+	static NISBLUEPRINT_API void SetNISSharpness(float Sharpness);
+	
+	///* Find a reasonable default NIS mode based on current hardware */
+	UFUNCTION(BlueprintPure, Category = "NIS", meta = (DisplayName = "Get Default NIS Mode"))
+	static NISBLUEPRINT_API UNISMode GetDefaultNISMode();
+
+
+private:
+	static UNISSupport NISSupport;
+	static FNISUpscaler* NISUpscaler;
+	static float SavedCustomScreenPercentage;
+	static bool bIsCustomMode;
+};
+
+class FNISBlueprintModule final : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+
+private:
+};

Plugins/Marketplace/NIS/Source/NISCore/NISCore.Build.cs

@@ -0,0 +1,53 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+using System.IO;
+
+public class NISCore : ModuleRules
+{
+	public NISCore(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				Path.Combine(EngineDirectory,"Source/Runtime/Renderer/Private"),
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"RenderCore",
+				"Renderer",
+				"NISShaders",
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Engine",
+					"RHI",
+					"Projects"
+			}
+			);
+	}
+}

Plugins/Marketplace/NIS/Source/NISCore/Private/NISCore.cpp

@@ -0,0 +1,67 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+#include "NISCore.h"
+#include "CoreMinimal.h"
+#include "NISShaders.h"
+#include "NISUpscaler.h"
+
+#include "Modules/ModuleManager.h"
+#include "Interfaces/IPluginManager.h"
+
+#include "GeneralProjectSettings.h"
+
+#include "SceneViewExtension.h"
+#include "SceneView.h"
+#include "Misc/MessageDialog.h"
+
+
+#define LOCTEXT_NAMESPACE "FNISModule"
+
+DEFINE_LOG_CATEGORY(LogNIS);
+
+
+
+
+void FNISCoreModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+	UE_LOG(LogNIS, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+
+	FNVImageUpscaler::RegisterOnScreenMessageHandler();
+	{
+		NISViewExtension = FSceneViewExtensions::NewExtension<FNISViewExtension>();
+	}
+
+
+	UE_LOG(LogNIS, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+
+void FNISCoreModule::ShutdownModule()
+{
+	UE_LOG(LogNIS, Log, TEXT("%s Enter"), ANSI_TO_TCHAR(__FUNCTION__));
+
+
+
+	{
+		NISViewExtension = nullptr;
+	}
+	FNVImageUpscaler::RemoveOnScreenMessageHandler();
+
+	UE_LOG(LogNIS, Log, TEXT("%s Leave"), ANSI_TO_TCHAR(__FUNCTION__));
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FNISCoreModule, NISCore)
+	
+
+

Plugins/Marketplace/NIS/Source/NISCore/Private/NISUpscaler.cpp

@@ -0,0 +1,278 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#include "NISUpscaler.h"
+#include "DynamicResolutionState.h"
+#include "LegacyScreenPercentageDriver.h"
+#include "Runtime/Launch/Resources/Version.h"
+
+#include "NISShaders.h"
+
+#define LOCTEXT_NAMESPACE "FNISModule"
+
+static TAutoConsoleVariable<int32> CVarNISEnable(
+	TEXT("r.NIS.Enable"),
+	1,
+	TEXT("Enable/disable NIS upscaling and/or sharpening"),
+	ECVF_RenderThreadSafe);
+
+static TAutoConsoleVariable<int32> CVarNISUpscaling(
+	TEXT("r.NIS.Upscaling"),
+	1,
+	TEXT("Enable NIS Upscaling. Also requires r.TemporalAA.Upscaler 0"),
+	ECVF_RenderThreadSafe);
+
+FNVImageUpscaler::FNISErrorState FNVImageUpscaler::ErrorState;
+
+
+FNISViewExtension::FNISViewExtension(const FAutoRegister& AutoRegister) : FSceneViewExtensionBase(AutoRegister)
+{
+	FSceneViewExtensionIsActiveFunctor IsActiveFunctor;
+
+	IsActiveFunctor.IsActiveFunction = [](const ISceneViewExtension* SceneViewExtension, const FSceneViewExtensionContext& Context)
+	{
+		return true;
+	};
+
+	IsActiveThisFrameFunctions.Add(IsActiveFunctor);
+}
+
+void FNISViewExtension::SetupViewFamily(FSceneViewFamily& InViewFamily) 
+{
+}
+
+void FNISViewExtension::SetupView(FSceneViewFamily& InViewFamily, FSceneView& InView)
+{
+}
+
+void FNISViewExtension::SetupViewPoint(APlayerController* Player, FMinimalViewInfo& InViewInfo) 
+{
+}
+
+void FNISViewExtension::BeginRenderViewFamily(FSceneViewFamily& InViewFamily)
+{
+	const bool bIsNISSupported = InViewFamily.GetFeatureLevel() >= GetNISMinRequiredFeatureLevel();
+	const bool bIsNISEnabled = CVarNISEnable.GetValueOnAnyThread() != 0;
+	const bool bIsNISUpscalingEnabled = CVarNISUpscaling.GetValueOnAnyThread() != 0;
+
+	static const auto CVarNISSharpness = IConsoleManager::Get().FindConsoleVariable(TEXT("r.NIS.Sharpness"));
+	const bool bIsNISSharpeningEnabled = (CVarNISSharpness ? CVarNISSharpness->GetFloat() : 0.0f) != 0.0f;
+
+	if (bIsNISSupported && bIsNISEnabled && (bIsNISUpscalingEnabled || bIsNISSharpeningEnabled))
+	{
+		/*	
+			FViewFamily::SetPrimarySpatialUpscalerInterface asserts if a plugin tries
+			to set spatial upscaler interfaces when another plugin already set it before.
+
+			Ideally the developer has only one spatial upscaler plugin active at run time,
+			based on UI setting, gameplay logic and such. However NIS and other spatial 
+			upscaler plugins tend to have their respective upscalers set to be active by default, 
+			which makes sense overall.
+				
+			We don't know whether we are gonna be the "first" or "second" (or maybe 3rd in the future ;) )
+			in the call order to get a chance to set the spatial upscaler interfaces.
+				
+			If we are not the first, then we can avoid the assert by not activating NIS, and instead 
+			showing an on screen error message (for non shipping builds), alerting the developer on how 
+			to avoid the assert/crash in the future, without taking down the app. E.g. they could change 
+			cvars to turn off other spatial upscaler plugins.
+
+			Empirical testing though revealed that NIS might get called first, thus potentially causing at least
+			one known 3rd party spatial upscaler plugin to trigger the engine side assert in 
+			FViewFamily::SetPrimarySpatialUpscalerInterface, which is not great.
+		
+			Thus we explicitly check whether any known spatial upscaler plugins are active for the current 
+			viewfamily/frame and turn off NIS as to not enable other plugins to take down the engine :)
+
+			After all "unreal engine spatial upscaler plugins crash each other" makes for catchy headlines, 
+			but is actually not great in practice.  =)
+		*/
+
+		struct FConsoleVariableReference
+		{
+			const TCHAR* Name = nullptr;
+			IConsoleVariable* CVar = nullptr;
+			bool bInitialized = false;
+		};
+
+		static FConsoleVariableReference KnownUpscalerCVars[]
+		{
+			{TEXT("r.FidelityFX.FSR.Enabled")}
+		};
+
+		
+		FNVImageUpscaler::ErrorState.IncompatibleUpscalerCVarNames = TEXT("");
+		bool bAnyKnownUpscalerActive = false;
+		for (auto& UpscalerCVar : KnownUpscalerCVars)
+		{
+			if (!UpscalerCVar.bInitialized)
+			{
+				UpscalerCVar.CVar = IConsoleManager::Get().FindConsoleVariable(UpscalerCVar.Name);
+				UpscalerCVar.bInitialized = true;
+			}
+
+			if (UpscalerCVar.CVar && UpscalerCVar.CVar->GetInt() != 0)
+			{
+				FNVImageUpscaler::ErrorState.IncompatibleUpscalerCVarNames.Append(UpscalerCVar.Name);
+				bAnyKnownUpscalerActive = true;
+			}
+		}
+
+		const bool bAnyOtherSpatialUpscalerActive =  bAnyKnownUpscalerActive || InViewFamily.GetPrimarySpatialUpscalerInterface() != nullptr || InViewFamily.GetSecondarySpatialUpscalerInterface() != nullptr;
+		FNVImageUpscaler::ErrorState.bOtherSpatialUpscalerActive = bAnyOtherSpatialUpscalerActive;
+		
+
+		bool bIsSpatialPrimaryUpscaling = false;
+		bool bIsTemporalPrimaryUpscaling = false;
+
+		for (const auto& View : InViewFamily.Views)
+		{
+			if (View)
+			{
+				if (View->PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::SpatialUpscale)
+				{
+					bIsSpatialPrimaryUpscaling = true;
+				}
+				if (View->PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::TemporalUpscale)
+				{
+					bIsTemporalPrimaryUpscaling = true;
+				}
+			}
+		}
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1
+		DynamicRenderScaling::TMap<float> UpperBounds = InViewFamily.GetScreenPercentageInterface()->GetResolutionFractionsUpperBound();
+		float PrimaryResolutionFraction = UpperBounds[GDynamicPrimaryResolutionFraction];
+#else
+		float PrimaryResolutionFraction = InViewFamily.GetPrimaryResolutionFractionUpperBound();
+#endif
+		const float MAX_UPSCALE_FRACTION = 1.0f;
+		const float MIN_UPSCALE_FRACTION = 0.5f;
+		const bool bIsActuallyPrimaryUpscaling = PrimaryResolutionFraction < MAX_UPSCALE_FRACTION && PrimaryResolutionFraction >= MIN_UPSCALE_FRACTION;
+		const bool bIsActuallySecondaryUpscaling = InViewFamily.SecondaryViewFraction < MAX_UPSCALE_FRACTION && InViewFamily.SecondaryViewFraction >= MIN_UPSCALE_FRACTION;
+
+		FNVImageUpscaler::ErrorState.bPrimaryAndSecondarySpatialUpscaling = bIsSpatialPrimaryUpscaling && bIsActuallyPrimaryUpscaling && bIsActuallySecondaryUpscaling;
+
+		if (!bAnyOtherSpatialUpscalerActive)
+		{
+			if (bIsNISUpscalingEnabled && bIsSpatialPrimaryUpscaling && bIsActuallyPrimaryUpscaling)
+			{
+				InViewFamily.SetPrimarySpatialUpscalerInterface(new FNVImageUpscaler());
+			}
+			// when running with DLSS (or TAAU/TSR) we do either secondary upscaling or just NIS sharpening
+			else if(bIsNISSharpeningEnabled || (bIsTemporalPrimaryUpscaling && bIsActuallyPrimaryUpscaling && bIsActuallySecondaryUpscaling))
+			{
+				InViewFamily.SetSecondarySpatialUpscalerInterface(new FNVImageUpscaler());
+			}
+		}
+	}
+}
+
+
+FNVImageUpscaler::FNVImageUpscaler()
+{
+
+}
+
+
+FNVImageUpscaler::~FNVImageUpscaler()
+{
+
+}
+
+const TCHAR* FNVImageUpscaler::GetDebugName() const
+{
+	return TEXT("NVIDIA Image Upscaler");
+}
+
+ISpatialUpscaler* FNVImageUpscaler::Fork_GameThread(const FSceneViewFamily& ViewFamily) const
+{
+	check(IsInGameThread());
+	return new FNVImageUpscaler();
+}
+
+
+FScreenPassTexture FNVImageUpscaler::AddPasses(FRDGBuilder& GraphBuilder, const FViewInfo& View, const ISpatialUpscaler::FInputs& PassInputs) const
+{
+	return  AddSharpenOrUpscalePass(GraphBuilder, View, PassInputs);
+}
+
+static bool ShowNISDebugOnScreenMessages()
+{
+	return true;
+	// TODO do we need project settings for this?
+	//if (GetDefault<UDLSSOverrideSettings>()->ShowDLSSSDebugOnScreenMessages == EDLSSSettingOverride::UseProjectSettings)
+	//{
+	//	return GetDefault<UDLSSSettings>()->bShowDLSSSDebugOnScreenMessages;
+	//}
+	//else
+	//{
+	//	return GetDefault<UDLSSOverrideSettings>()->ShowDLSSSDebugOnScreenMessages == EDLSSSettingOverride::Enabled;
+	//}
+}
+
+
+#if !UE_BUILD_SHIPPING
+
+FDelegateHandle FNVImageUpscaler::OnScreenMessagesDelegateHandle;
+void FNVImageUpscaler::GetOnScreenMessages(TMultiMap<FCoreDelegates::EOnScreenMessageSeverity, FText>& OutMessages)
+{
+	check(IsInGameThread());
+
+	if (ShowNISDebugOnScreenMessages())
+	{
+		if (ErrorState.bOtherSpatialUpscalerActive)
+		{
+			const FTextFormat Format(LOCTEXT("NISOtherUpscalerActive",
+				"NIS Error: Disabling NVIDIA NIS as the spatial upscaler since another spatial upscaler plugin is already active for this view family.\n"
+				"           To enable NIS, please disable other primary spatial upscalers in the UI/application logic or via console variables {0} {1}. And vice versa"));
+			const FText Message = FText::Format(Format, 
+				FText::FromString(!ErrorState.IncompatibleUpscalerCVarNames.IsEmpty() ? TEXT("such as") : TEXT("")), 
+				FText::FromString(ErrorState.IncompatibleUpscalerCVarNames)
+			);
+			OutMessages.Add(FCoreDelegates::EOnScreenMessageSeverity::Error, Message);
+		}
+
+		if (ErrorState.bPrimaryAndSecondarySpatialUpscaling)
+		{
+			const FTextFormat Format(LOCTEXT("NISOtherUpscalerActive",
+				"NIS Warning: NIS is used as a primary spatial upscaler, followed by the engine built-in secondary spatial upscaler, which is not optimal.\n"
+				"             Consider disabling the secondary screen percentage (via r.SecondaryScreenPercentage.GameViewport or Editor.OverrideDPIBasedEditorViewportScaling) in order to have NIS upscale directly to the output resolution."));
+			const FText Message = FText::Format(Format,
+				FText::FromString(!ErrorState.IncompatibleUpscalerCVarNames.IsEmpty() ? TEXT("such as") : TEXT("")),
+				FText::FromString(ErrorState.IncompatibleUpscalerCVarNames)
+			);
+			OutMessages.Add(FCoreDelegates::EOnScreenMessageSeverity::Warning, Message);
+		}
+	}
+}
+#endif
+
+
+void FNVImageUpscaler::RegisterOnScreenMessageHandler()
+{
+#if !UE_BUILD_SHIPPING
+	OnScreenMessagesDelegateHandle = FCoreDelegates::OnGetOnScreenMessages.AddStatic(&GetOnScreenMessages);
+#endif
+}
+
+void FNVImageUpscaler::RemoveOnScreenMessageHandler()
+{
+#if !UE_BUILD_SHIPPING
+	if (OnScreenMessagesDelegateHandle.IsValid())
+	{
+		FCoreDelegates::OnGetOnScreenMessages.Remove(OnScreenMessagesDelegateHandle);
+		OnScreenMessagesDelegateHandle.Reset();
+	}
+#endif
+}
+
+#undef LOCTEXT_NAMESPACE

Plugins/Marketplace/NIS/Source/NISCore/Private/NISUpscaler.h

@@ -0,0 +1,74 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Misc/CoreDelegates.h"
+#include "RendererInterface.h"
+#include "PostProcess/PostProcessUpscale.h"
+#include "SceneViewExtension.h"
+#include "NISShaders.h"
+
+class FSceneTextureParameters;
+class FRHITexture;
+class FNISViewExtension final : public FSceneViewExtensionBase
+{
+public:
+	FNISViewExtension(const FAutoRegister& AutoRegister);
+
+	virtual void SetupViewFamily(FSceneViewFamily& InViewFamily) override;
+	virtual void SetupView(FSceneViewFamily& InViewFamily, FSceneView& InView) override;
+	virtual void SetupViewPoint(APlayerController* Player, FMinimalViewInfo& InViewInfo) override;
+	virtual void BeginRenderViewFamily(FSceneViewFamily& InViewFamily) override;
+
+	virtual void PreRenderView_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneView& InView) final override {}
+	virtual void PreRenderViewFamily_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneViewFamily& InViewFamily) final override {}
+};
+
+
+
+class NISCORE_API FNVImageUpscaler final : public ISpatialUpscaler
+{
+	friend class FNISModule;
+public:
+	FNVImageUpscaler();
+	virtual ~FNVImageUpscaler();
+
+
+	virtual const TCHAR* GetDebugName() const override;
+
+	/** Create a new ISpatialUpscaler interface for a new view family. */
+	virtual ISpatialUpscaler* Fork_GameThread(const class FSceneViewFamily& ViewFamily) const override;
+
+
+	// Inherited via ISpatialUpscaler
+	virtual FScreenPassTexture AddPasses(
+		FRDGBuilder& GraphBuilder,
+		const FViewInfo& View,
+		const FInputs& PassInputs) const override;
+
+	struct FNISErrorState
+	{
+		bool bOtherSpatialUpscalerActive = false;
+		FString IncompatibleUpscalerCVarNames;
+
+		bool bPrimaryAndSecondarySpatialUpscaling = false;
+	};
+
+#if !UE_BUILD_SHIPPING
+	static void GetOnScreenMessages(TMultiMap<FCoreDelegates::EOnScreenMessageSeverity, FText>& OutMessages);
+	static FDelegateHandle OnScreenMessagesDelegateHandle;
+#endif
+	static void RegisterOnScreenMessageHandler();
+	static void RemoveOnScreenMessageHandler();
+	static FNISErrorState ErrorState;
+};

Plugins/Marketplace/NIS/Source/NISCore/Public/NISCore.h

@@ -0,0 +1,30 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+class FNISViewExtension;
+class FNVImageUpscaler;
+
+class FNISCoreModule final: public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule();
+	virtual void ShutdownModule();
+
+private:
+	TSharedPtr< FNISViewExtension , ESPMode::ThreadSafe> NISViewExtension;
+	TUniquePtr<FNVImageUpscaler> NISUpscaler;
+};

Plugins/Marketplace/NIS/Source/NISShaders/NISShaders.Build.cs

@@ -0,0 +1,53 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+using UnrealBuildTool;
+using System.IO;
+
+public class NISShaders: ModuleRules
+{
+	public NISShaders(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+			);
+
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				Path.Combine(EngineDirectory,"Source/Runtime/Renderer/Private"),
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"RenderCore",
+				"Renderer",
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+					"Engine",
+					"RHI",
+					"Projects",
+					"Renderer",
+			}
+			);
+	}
+}

Plugins/Marketplace/NIS/Source/NISShaders/Private/NISShaders.cpp

@@ -0,0 +1,687 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+#include "NISShaders.h"
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+#include "Interfaces/IPluginManager.h"
+#include "RenderTargetPool.h"
+#include "GeneralProjectSettings.h"
+#include "SceneViewExtension.h"
+#include "SceneView.h"
+#include "ShaderCompilerCore.h"
+#include "PostProcess/PostProcessTonemap.h"
+#include "Runtime/Launch/Resources/Version.h"
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 2
+#include "DataDrivenShaderPlatformInfo.h"
+#endif
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+#include "SceneRendering.h"
+#endif
+
+// we don't pass NISConfigs as constant buffers into the shaders so we don't need the alignment
+// however we also have static_asserts that make sure that FNISConfigParameters matches NISConfig
+#define NIS_ALIGNED(x)
+#include "NIS_Config.h"
+
+#define LOCTEXT_NAMESPACE "FNISImageScalingShadersModule"
+
+
+void FNISShadersModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+
+	// Get the base directory of this plugin
+	FString PluginShaderDir = FPaths::Combine(IPluginManager::Get().FindPlugin(TEXT("NIS"))->GetBaseDir(), TEXT("Shaders"));
+	AddShaderSourceDirectoryMapping(TEXT("/Plugin/NIS"), PluginShaderDir);
+
+	FString ThirdPartyShaderDir = FPaths::Combine(IPluginManager::Get().FindPlugin(TEXT("NIS"))->GetBaseDir(), TEXT("Shaders"), TEXT("ThirdParty"));
+	AddShaderSourceDirectoryMapping(TEXT("/ThirdParty/Plugin/NIS"), ThirdPartyShaderDir);
+}
+
+void FNISShadersModule::ShutdownModule()
+{
+
+}
+
+static TAutoConsoleVariable<float> CVarNISSharpness(
+	TEXT("r.NIS.Sharpness"),
+	0.0f,
+	TEXT("0.0 to 1.0: Sharpening to apply to either primary NIS pass or the secondary NIS pass. If 0.0 the secondary NIS sharpening pass will not be executed (default: 0.0f)"),
+	ECVF_RenderThreadSafe);
+
+
+static TAutoConsoleVariable <int> CVarNISHalfPrecision(
+	TEXT("r.NIS.HalfPrecision"),
+	-1,
+	TEXT("Enable/disable half precision in the NIS shaders and selects which permutation is used (default:-1)\n")
+	TEXT("-1: automatic. Pick the appropriate FP16 permutation based on shader model and RHI\n")
+	TEXT(" 0: Float32,       disable half precision\n")
+	TEXT(" 1: Min16Float,    half precision, intended for UE4 DX11 SM5\n")
+	TEXT(" 2: Min16FloatDXC, half precision, intended for UE4 DX12 SM5\n")
+	TEXT(" 3: Float16DXC,    half precision, intended for UE5 DX12 SM6\n"),
+	ECVF_RenderThreadSafe);
+
+static TAutoConsoleVariable<int> CVarNISHDRMode(
+	TEXT("r.NIS.HDRMode"),
+	-1,
+	TEXT("-1: Automatic. Determines the NIS HDR mode based on ETonemapperOutputDevice\n")
+	TEXT("0: None\n")
+	TEXT("1: Linear\n")
+	TEXT("2: PQ\n"),
+	ECVF_RenderThreadSafe);
+
+// this should match NISConfig
+BEGIN_SHADER_PARAMETER_STRUCT(FNISConfigParameters, )
+	SHADER_PARAMETER(float, kDetectRatio)
+	SHADER_PARAMETER(float, kDetectThres)
+	SHADER_PARAMETER(float, kMinContrastRatio)
+	SHADER_PARAMETER(float, kRatioNorm)
+
+	SHADER_PARAMETER(float, kContrastBoost)
+	SHADER_PARAMETER(float, kEps)
+	SHADER_PARAMETER(float, kSharpStartY)
+	SHADER_PARAMETER(float, kSharpScaleY)
+
+	SHADER_PARAMETER(float, kSharpStrengthMin)
+	SHADER_PARAMETER(float, kSharpStrengthScale)
+	SHADER_PARAMETER(float, kSharpLimitMin)
+	SHADER_PARAMETER(float, kSharpLimitScale)
+
+	SHADER_PARAMETER(float, kScaleX)
+	SHADER_PARAMETER(float, kScaleY)
+	SHADER_PARAMETER(float, kDstNormX)
+	SHADER_PARAMETER(float, kDstNormY)
+	SHADER_PARAMETER(float, kSrcNormX)
+	SHADER_PARAMETER(float, kSrcNormY)
+
+	SHADER_PARAMETER(uint32, kInputViewportOriginX)
+	SHADER_PARAMETER(uint32, kInputViewportOriginY)
+	SHADER_PARAMETER(uint32, kInputViewportWidth)
+	SHADER_PARAMETER(uint32, kInputViewportHeight)
+
+	SHADER_PARAMETER(uint32, kOutputViewportOriginX)
+	SHADER_PARAMETER(uint32, kOutputViewportOriginY)
+	SHADER_PARAMETER(uint32, kOutputViewportWidth)
+	SHADER_PARAMETER(uint32, kOutputViewportHeight)
+
+	SHADER_PARAMETER(float, reserved0)
+	SHADER_PARAMETER(float, reserved1)
+END_SHADER_PARAMETER_STRUCT()
+
+// not a complete guard against mismatches, but better than nothing
+static_assert(sizeof(NISConfig) == sizeof(FNISConfigParameters), "mistmatch between engine & NIS SDK side struct");
+static_assert(offsetof(NISConfig, kOutputViewportHeight) == offsetof(FNISConfigParameters, kOutputViewportHeight), "mistmatch between engine & NIS SDK side struct");
+
+class FNISScalerDim : SHADER_PERMUTATION_BOOL("NIS_SCALER");
+// SHADER_PERMUTATION_SPARSE_ENUM needs a ::MAX member, so we can't use the NIS enum directly, at least not without making a UE flavored copy of the type
+class FNISHdrModeDim : SHADER_PERMUTATION_SPARSE_INT("NIS_HDR_MODE", int32(NISHDRMode::None), int32(NISHDRMode::Linear), int32(NISHDRMode::PQ));
+
+// those need to be updated if GetOptimalBlockWidth etc return new values
+class FNISBlockWidthDim      : SHADER_PERMUTATION_SPARSE_INT("NIS_BLOCK_WIDTH", 32);
+class FNISBlockHeightDim     : SHADER_PERMUTATION_SPARSE_INT("NIS_BLOCK_HEIGHT", 32, 24);
+class FNISThreadGroupSizeDim : SHADER_PERMUTATION_SPARSE_INT("NIS_THREAD_GROUP_SIZE", 128, 256);
+class FNISViewportSupportDim : SHADER_PERMUTATION_BOOL("NIS_VIEWPORT_SUPPORT");
+
+// the shaders treat NIS_USE_HALF_PRECISION 1 and 2 as on so we can use this to have another permutation that we compile with DXC
+enum class ENISHalfPrecisionPermutation
+{
+	Float32,        // for everything else
+	Min16Float,     // for UE4 DX11 SM5
+	Min16FloatDXC,  // for UE4 DX12 SM5
+	Float16DXC,     // for UE5 DX12 SM6 
+	MAX
+};
+class FNISHalfPrecisionDim   : SHADER_PERMUTATION_ENUM_CLASS("NIS_USE_HALF_PRECISION", ENISHalfPrecisionPermutation);
+
+
+NISSHADERS_API ERHIFeatureLevel::Type GetNISMinRequiredFeatureLevel()
+{
+	return ERHIFeatureLevel::SM5;
+}
+
+class FNISUpscaleCS : public FGlobalShader
+{
+public:
+	static NISGPUArchitecture GetNISGPUArchitecture(const bool bHalfPrecision)
+	{
+		// those functions expect non-zero GRHIVendorId, but it's unclear how NDA platforms, such as consoles handle this...
+		if (GRHIVendorId && IsRHIDeviceAMD())
+		{
+			return NISGPUArchitecture::AMD_Generic;
+		}
+		else if (GRHIVendorId && IsRHIDeviceIntel())
+		{
+			return NISGPUArchitecture::Intel_Generic;
+		}
+		else if (GRHIVendorId && IsRHIDeviceNVIDIA())
+		{
+			return bHalfPrecision ? NISGPUArchitecture::NVIDIA_Generic_fp16 :  NISGPUArchitecture::NVIDIA_Generic;
+		}
+		else
+		{
+			return NISGPUArchitecture::NVIDIA_Generic;
+		}
+
+	}
+	static FIntPoint GetComputeTileSize(bool bIsUpscaling, const bool bHalfPrecision)
+	{
+		NISOptimizer Optimizer{ bIsUpscaling, GetNISGPUArchitecture(bHalfPrecision)} ;
+		return  FIntPoint(Optimizer.GetOptimalBlockWidth(), Optimizer.GetOptimalBlockHeight());
+	}
+
+	static int32 GetThreadGroupSize(bool bIsUpscaling, const bool bHalfPrecision)
+	{
+		NISOptimizer Optimizer{ bIsUpscaling, GetNISGPUArchitecture(bHalfPrecision) };
+		return Optimizer.GetOptimalThreadGroupSize();
+	}
+
+	static bool DoesPlatformSupportDXC(const FStaticShaderPlatform Platform)
+	{
+		return 
+#if ENGINE_MAJOR_VERSION == 5
+			FDataDrivenShaderPlatformInfo::GetSupportsDxc(Platform) ||
+#endif
+			(FDataDrivenShaderPlatformInfo::GetIsPC(Platform) && IsD3DPlatform(Platform));
+	}
+
+	static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
+	{
+		FPermutationDomain PermutationVector(Parameters.PermutationId);
+		
+		// UE4 doesn't support SM6 and float16t reliably....
+		if (PermutationVector.Get<FNISHalfPrecisionDim>() == ENISHalfPrecisionPermutation::Float16DXC)
+		{
+#if ENGINE_MAJOR_VERSION != 5
+			return false;
+#else
+			return 	DoesPlatformSupportDXC(Parameters.Platform) && IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM6);
+#endif
+		}
+
+		return 	IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);
+	}
+
+	static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
+	{
+		FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
+		OutEnvironment.CompilerFlags.Add(CFLAG_AllowTypedUAVLoads);
+		
+		// for DX12 we need to DXC to get min16float in the NIS shaders to have an effect
+		// NIS also supports SM6.2 explicit FP16, but in UE4 that's only supported for RT shaders.
+		FPermutationDomain PermutationVector(Parameters.PermutationId);
+
+	
+		if(DoesPlatformSupportDXC(Parameters.Platform))
+		{
+			if (PermutationVector.Get<FNISHalfPrecisionDim>() == ENISHalfPrecisionPermutation::Min16FloatDXC)
+			{
+				OutEnvironment.CompilerFlags.Add(CFLAG_ForceDXC);
+			}
+			// UE5 supports SM6.6 so we can use the explicit FP16 NIS permutation
+	#if ENGINE_MAJOR_VERSION == 5
+			if (PermutationVector.Get<FNISHalfPrecisionDim>() == ENISHalfPrecisionPermutation::Float16DXC)
+			{
+				OutEnvironment.CompilerFlags.Add(CFLAG_ForceDXC);
+				OutEnvironment.CompilerFlags.Add(CFLAG_AllowRealTypes);
+				OutEnvironment.SetDefine(TEXT("NIS_HLSL_6_2"), 1);
+			}
+	#endif
+		}
+	}
+
+	using FPermutationDomain = TShaderPermutationDomain<FNISScalerDim, FNISHdrModeDim, FNISHalfPrecisionDim,
+		FNISBlockWidthDim, FNISBlockHeightDim, FNISThreadGroupSizeDim, FNISViewportSupportDim>;
+
+	DECLARE_GLOBAL_SHADER(FNISUpscaleCS);
+	SHADER_USE_PARAMETER_STRUCT(FNISUpscaleCS, FGlobalShader);
+
+	BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
+		// Input images
+		SHADER_PARAMETER_SAMPLER(SamplerState, samplerLinearClamp)
+		SHADER_PARAMETER_RDG_TEXTURE(Texture2D, in_texture)
+		// Output images
+		SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D, out_texture)
+
+		SHADER_PARAMETER_STRUCT_INCLUDE(FNISConfigParameters, Config)
+		SHADER_PARAMETER_TEXTURE(Texture2D, coef_scaler)
+		SHADER_PARAMETER_TEXTURE(Texture2D, coef_usm)
+	
+		SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
+		END_SHADER_PARAMETER_STRUCT()
+};
+
+IMPLEMENT_GLOBAL_SHADER(FNISUpscaleCS, "/Plugin/NIS/Private/NISUpscaler.usf", "main", SF_Compute);
+
+struct FNISCoefficients : public FRenderResource
+{
+	FTexture2DRHIRef ScalerRHI = nullptr;
+	FTexture2DRHIRef UsmRHI = nullptr;
+
+	FTexture2DRHIRef ScalerHalfPrecisionRHI = nullptr;
+	FTexture2DRHIRef UsmHalfPrecisionRHI = nullptr;
+
+
+	class FNISCoefficientsResourceBulkData : public FResourceBulkDataInterface
+	{
+	public:
+		FNISCoefficientsResourceBulkData(const void* InData, uint32_t InDataSize)
+			: Data(InData)
+			, DataSize(InDataSize)
+		{ }
+
+	public:
+		virtual const void* GetResourceBulkData() const
+		{
+			return Data;
+		}
+
+		virtual uint32 GetResourceBulkDataSize() const
+		{
+			return DataSize;
+		}
+
+		virtual void Discard()
+		{ }
+
+	private:
+		const void* Data;
+		uint32_t    DataSize;
+	};
+
+	/**
+	 * Initializes the RHI resources used by this resource.
+	 * Called when entering the state where both the resource and the RHI have been initialized.
+	 * This is only called by the rendering thread.
+	 */
+
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 3
+	virtual void InitRHI(FRHICommandListBase& RHICmdList)
+#else
+	virtual void InitRHI() 
+#endif
+	{
+		// FP32
+		{
+			const uint32 CoefficientStride = kFilterSize * 4;
+			const uint32 CoefficientSize = CoefficientStride * kPhaseCount;
+
+			FNISCoefficientsResourceBulkData BulkData(coef_scale, CoefficientSize);
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1
+			FRHITextureCreateDesc ScalerDesc = FRHITextureCreateDesc::Create2D(TEXT("FNISCoefficients::Scaler"))
+				.SetExtent(kFilterSize / 4, kPhaseCount)
+				.SetFormat(PF_A32B32G32R32F)
+				.SetNumMips(1)
+				.SetNumSamples(1)
+				.SetFlags(TexCreate_None)
+				.SetBulkData(&BulkData);
+			ScalerRHI = RHICreateTexture(ScalerDesc);
+#else
+			FRHIResourceCreateInfo CreateInfo(TEXT("FNISCoefficients::Scaler"));
+			CreateInfo.BulkData = &BulkData;
+			ScalerRHI = RHICreateTexture2D(kFilterSize / 4, kPhaseCount, PF_A32B32G32R32F, 1, 1, TexCreate_None, CreateInfo);
+#endif
+		}
+
+		{
+			const uint32 CoefficientStride = kFilterSize * 4;
+			const uint32 CoefficientSize = CoefficientStride * kPhaseCount;
+
+			FNISCoefficientsResourceBulkData BulkData(coef_usm, CoefficientSize);
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1
+			FRHITextureCreateDesc UsmDesc = FRHITextureCreateDesc::Create2D(TEXT("FNISCoefficients::Usm"))
+				.SetExtent(kFilterSize / 4, kPhaseCount)
+				.SetFormat(PF_A32B32G32R32F)
+				.SetNumMips(1)
+				.SetNumSamples(1)
+				.SetFlags(TexCreate_None)
+				.SetBulkData(&BulkData);
+			UsmRHI = RHICreateTexture(UsmDesc);
+#else
+			FRHIResourceCreateInfo CreateInfo(TEXT("FNISCoefficients::Usm"));
+			CreateInfo.BulkData = &BulkData;
+			UsmRHI = RHICreateTexture2D(kFilterSize / 4, kPhaseCount, PF_A32B32G32R32F, 1, 1, TexCreate_None, CreateInfo);
+#endif
+		}
+
+		// FP16
+		{
+			const uint32 CoefficientStride = kFilterSize * 2;
+			const uint32 CoefficientSize = CoefficientStride * kPhaseCount;
+
+			FNISCoefficientsResourceBulkData BulkData(coef_scale_fp16, CoefficientSize);
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1
+			FRHITextureCreateDesc ScalerHalfDesc = FRHITextureCreateDesc::Create2D(TEXT("FNISCoefficients::ScalerHalfPrecision"))
+				.SetExtent(kFilterSize / 4, kPhaseCount)
+				.SetFormat(PF_FloatRGBA)
+				.SetNumMips(1)
+				.SetNumSamples(1)
+				.SetFlags(TexCreate_None)
+				.SetBulkData(&BulkData);
+			ScalerHalfPrecisionRHI = RHICreateTexture(ScalerHalfDesc);
+#else
+			FRHIResourceCreateInfo CreateInfo(TEXT("FNISCoefficients::ScalerHalfPrecision"));
+			CreateInfo.BulkData = &BulkData;
+			ScalerHalfPrecisionRHI = RHICreateTexture2D(kFilterSize / 4, kPhaseCount, PF_FloatRGBA, 1, 1, TexCreate_None, CreateInfo);
+#endif
+		}
+
+		{
+			const uint32 CoefficientStride = kFilterSize * 2;
+			const uint32 CoefficientSize = CoefficientStride * kPhaseCount;
+
+			FNISCoefficientsResourceBulkData BulkData(coef_usm_fp16, CoefficientSize);
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1
+			FRHITextureCreateDesc UsmHalfDesc = FRHITextureCreateDesc::Create2D(TEXT("FNISCoefficients::UsmHalfPrecision"))
+				.SetExtent(kFilterSize / 4, kPhaseCount)
+				.SetFormat(PF_FloatRGBA)
+				.SetNumMips(1)
+				.SetNumSamples(1)
+				.SetFlags(TexCreate_None)
+				.SetBulkData(&BulkData);
+			UsmHalfPrecisionRHI = RHICreateTexture(UsmHalfDesc);
+#else
+			FRHIResourceCreateInfo CreateInfo(TEXT("FNISCoefficients::UsmHalfPrecision"));
+			CreateInfo.BulkData = &BulkData;
+			UsmHalfPrecisionRHI = RHICreateTexture2D(kFilterSize / 4, kPhaseCount, PF_FloatRGBA, 1, 1, TexCreate_None, CreateInfo);
+#endif
+		}
+	}
+
+	/**
+	 * Releases the RHI resources used by this resource.
+	 * Called when leaving the state where both the resource and the RHI have been initialized.
+	 * This is only called by the rendering thread.
+	 */
+	virtual void ReleaseRHI() 
+	{
+		ScalerRHI.SafeRelease();
+		UsmRHI.SafeRelease();
+
+		ScalerHalfPrecisionRHI.SafeRelease();
+		UsmHalfPrecisionRHI.SafeRelease();
+
+	}
+
+};
+
+static TGlobalResource<FNISCoefficients> GNISCoefficients;
+
+static NISHDRMode GetNISHDRModeFromEngineToneMapperOrCVar(const FSceneViewFamily& InViewFamily)
+{
+	const int NISHDRModeCVarValue = CVarNISHDRMode.GetValueOnRenderThread();
+
+	if (NISHDRModeCVarValue == -1)
+	{
+		const FTonemapperOutputDeviceParameters ToneMapper = GetTonemapperOutputDeviceParameters(InViewFamily);
+		
+#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 1
+		switch (EDisplayOutputFormat(ToneMapper.OutputDevice))
+		{
+			case EDisplayOutputFormat::SDR_sRGB:
+			case EDisplayOutputFormat::SDR_Rec709:
+			case EDisplayOutputFormat::SDR_ExplicitGammaMapping:
+				return NISHDRMode::None;
+			case EDisplayOutputFormat::HDR_ACES_1000nit_ST2084:
+			case EDisplayOutputFormat::HDR_ACES_2000nit_ST2084:
+				return NISHDRMode::PQ;
+			case EDisplayOutputFormat::HDR_ACES_1000nit_ScRGB:
+			case EDisplayOutputFormat::HDR_ACES_2000nit_ScRGB:
+				return NISHDRMode::Linear;
+			case EDisplayOutputFormat::HDR_LinearEXR:
+			case EDisplayOutputFormat::HDR_LinearNoToneCurve:
+			case EDisplayOutputFormat::HDR_LinearWithToneCurve:
+				return NISHDRMode::Linear;
+			case EDisplayOutputFormat::MAX:
+			default:
+				checkf(false, TEXT("invalid EDisplayOutputFormat passed into GetNISHDRModeFromEngineToneMapper "));
+				return NISHDRMode::None;
+		}
+#else
+		switch (ETonemapperOutputDevice(ToneMapper.OutputDevice))
+		{
+			case ETonemapperOutputDevice::sRGB:
+			case ETonemapperOutputDevice::Rec709:
+			case ETonemapperOutputDevice::ExplicitGammaMapping:
+				return NISHDRMode::None;
+			case ETonemapperOutputDevice::ACES1000nitST2084:
+			case ETonemapperOutputDevice::ACES2000nitST2084:
+				return NISHDRMode::PQ;
+			case ETonemapperOutputDevice::ACES1000nitScRGB:
+			case ETonemapperOutputDevice::ACES2000nitScRGB:
+				return NISHDRMode::Linear;
+			case ETonemapperOutputDevice::LinearEXR:
+			case ETonemapperOutputDevice::LinearNoToneCurve:
+			case ETonemapperOutputDevice::LinearWithToneCurve:
+				return NISHDRMode::Linear;
+			case ETonemapperOutputDevice::MAX:
+			default:
+				checkf(false, TEXT("invalid ETonemapperOutputDevice passed into GetNISHDRModeFromEngineToneMapper "));
+				return NISHDRMode::None;
+		}
+#endif
+	}
+	else
+	{
+		return NISHDRMode(FMath::Clamp<int32>(NISHDRModeCVarValue, int32(NISHDRMode::None), int32(NISHDRMode::PQ)));
+	}
+}
+
+FScreenPassTexture AddSharpenOrUpscalePass(
+	FRDGBuilder& GraphBuilder,
+	const FViewInfo& View,
+	const ISpatialUpscaler::FInputs& Inputs
+)
+{
+	check(Inputs.SceneColor.IsValid());
+	check(Inputs.Stage != EUpscaleStage::MAX);
+
+	FScreenPassRenderTarget Output = Inputs.OverrideOutput;
+
+	if (!Output.IsValid())
+	{
+		FRDGTextureDesc OutputDesc = Inputs.SceneColor.Texture->Desc;
+		OutputDesc.Reset();
+
+		if (Inputs.Stage == EUpscaleStage::PrimaryToSecondary)
+		{
+			const FIntPoint SecondaryViewRectSize = View.GetSecondaryViewRectSize();
+			QuantizeSceneBufferSize(SecondaryViewRectSize, OutputDesc.Extent);
+			Output.ViewRect.Min = FIntPoint::ZeroValue;
+			Output.ViewRect.Max = SecondaryViewRectSize;
+		}
+		else
+		{
+			OutputDesc.Extent = View.UnscaledViewRect.Max;
+			Output.ViewRect = View.UnscaledViewRect;
+		}
+
+		// We can't call OutputDesc.Flags |= GFastVRamConfig.Upscale this due to not being exported, so paraphrasing from SceneRendering.cpp:
+		static const auto CVarFastVRamUpscale = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.FastVRam.Upscale"));
+		const int32 FastVRamUpscaleValue = CVarFastVRamUpscale ? CVarFastVRamUpscale->GetValueOnRenderThread() : 0;
+
+		if (FastVRamUpscaleValue == 1)
+		{
+			EnumAddFlags(OutputDesc.Flags, TexCreate_FastVRAM);
+		}
+		else if (FastVRamUpscaleValue == 2)
+		{
+			EnumAddFlags(OutputDesc.Flags, TexCreate_FastVRAM | TexCreate_FastVRAMPartialAlloc);
+		}
+
+		Output.Texture = GraphBuilder.CreateTexture(OutputDesc, TEXT("NISSharpen"));
+		Output.LoadAction = ERenderTargetLoadAction::EClear;
+	}
+	FRDGTextureRef OutputOrIntermediateTexture = Output.Texture;
+
+	const FIntRect SrcRect = Inputs.SceneColor.ViewRect;
+	FIntRect IntermediateDestRect = Output.ViewRect;
+	const FIntRect OutputDestRect = Output.ViewRect;
+
+	const bool bNeedIntermediateOutput = !EnumHasAnyFlags(Output.Texture->Desc.Flags, TexCreate_UAV);
+	const bool bIsUpscaling = SrcRect.Size() != IntermediateDestRect.Size();
+	
+	// move the intermediate upscaled rect to the top left corner and allocate a smaller intermediate rendertarget
+	if (bNeedIntermediateOutput)
+	{
+		FRDGTextureDesc IntermediateOutputDesc = Output.Texture->Desc;
+		IntermediateOutputDesc.Reset();
+
+		EnumAddFlags(IntermediateOutputDesc.Flags, TexCreate_UAV);
+		EnumRemoveFlags(IntermediateOutputDesc.Flags, TexCreate_RenderTargetable | TexCreate_Presentable | TexCreate_ShaderResource);
+
+		const FIntPoint InterMediateViewRectSize = IntermediateDestRect.Size();
+		QuantizeSceneBufferSize(InterMediateViewRectSize, IntermediateOutputDesc.Extent);
+		IntermediateDestRect.Min = FIntPoint::ZeroValue;
+		IntermediateDestRect.Max = FIntPoint(InterMediateViewRectSize.X, InterMediateViewRectSize.Y);
+		OutputOrIntermediateTexture = GraphBuilder.CreateTexture(IntermediateOutputDesc, bIsUpscaling ? TEXT("NISUpscaleIntermediateUAV") : TEXT("NISSharpenIntermediateUAV"));
+	}
+
+	const bool bNeedsViewportSupport = SrcRect != FIntRect(FIntPoint::ZeroValue, Inputs.SceneColor.Texture->Desc.Extent) ||
+		IntermediateDestRect != FIntRect(FIntPoint::ZeroValue, OutputOrIntermediateTexture->Desc.Extent);
+
+	FNISUpscaleCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FNISUpscaleCS::FParameters>();
+
+	const float Sharpness = FMath::Clamp(CVarNISSharpness.GetValueOnRenderThread(), 0.0f, 1.0f);
+	
+	const NISHDRMode HdrMode = GetNISHDRModeFromEngineToneMapperOrCVar(*View.Family);
+
+	const int32 bHalfPrecisionMode = CVarNISHalfPrecision.GetValueOnRenderThread();
+
+	ENISHalfPrecisionPermutation HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Float32;
+	if (bHalfPrecisionMode == -1)
+	{
+#if PLATFORM_WINDOWS
+		static const bool bIsDx12 = FCString::Strcmp(GDynamicRHI->GetName(), TEXT("D3D12")) == 0;
+#else
+		static const bool bIsDx12 = false;
+#endif
+		if (bIsDx12)
+		{
+#if ENGINE_MAJOR_VERSION == 5
+			if (View.GetFeatureLevel() == ERHIFeatureLevel::SM6)
+			{
+				HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Float16DXC;
+			}
+			else
+#endif
+			{
+				HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Min16FloatDXC;
+			}
+		}
+		else
+		{
+			HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Min16Float;
+		}
+	}
+	else if (bHalfPrecisionMode == 0)
+	{
+		HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Float32;
+	}
+	else if (bHalfPrecisionMode == 1)
+	{
+		HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Min16Float;
+	}
+	else if (bHalfPrecisionMode == 2)
+	{
+		HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Min16FloatDXC;
+	}
+#if ENGINE_MAJOR_VERSION == 5
+	// we can only compile this one for SM6
+	else if (bHalfPrecisionMode == 3 && View.GetFeatureLevel() == ERHIFeatureLevel::SM6)
+	{
+		HalfPrecisionPermutation = ENISHalfPrecisionPermutation::Float16DXC;
+	}
+#endif
+	const bool bIsAnyHalfPrecisionPermutation = HalfPrecisionPermutation != ENISHalfPrecisionPermutation::Float32;
+	
+	
+	NISConfig Config;
+	FMemory::Memzero(Config);
+	ensureMsgf(NVScalerUpdateConfig(
+		Config, 
+		Sharpness,
+		SrcRect.Min.X, SrcRect.Min.Y,
+		SrcRect.Width(), SrcRect.Height(),
+		Inputs.SceneColor.Texture->Desc.Extent.X, Inputs.SceneColor.Texture->Desc.Extent.Y,
+
+		IntermediateDestRect.Min.X, IntermediateDestRect.Min.Y,
+		IntermediateDestRect.Width(), IntermediateDestRect.Height(),
+		OutputOrIntermediateTexture->Desc.Extent.X, OutputOrIntermediateTexture->Desc.Extent.Y,
+		HdrMode), TEXT("NVScalerUpdateConfig was called with invalid arguments. Please step into NVScalerUpdateConfig and put breakpoints on the return false statements to debug."));
+	
+	// TODO make this less sketchy 🤐
+	static_assert(sizeof(NISConfig) == sizeof(FNISConfigParameters), "mistmatch between engine & NIS SDK side struct");
+	static_assert(offsetof(NISConfig, kOutputViewportHeight) == offsetof(FNISConfigParameters, kOutputViewportHeight), "mistmatch between engine & NIS SDK side struct");
+	FMemory::Memcpy(&PassParameters->Config, &Config, sizeof(NISConfig));
+	
+	PassParameters->coef_scaler = bIsAnyHalfPrecisionPermutation ? GNISCoefficients.ScalerHalfPrecisionRHI : GNISCoefficients.ScalerRHI;
+	PassParameters->coef_usm = bIsAnyHalfPrecisionPermutation ? GNISCoefficients.UsmHalfPrecisionRHI : GNISCoefficients.UsmRHI;
+	
+	PassParameters->samplerLinearClamp = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
+	PassParameters->in_texture = Inputs.SceneColor.Texture;
+	PassParameters->out_texture = GraphBuilder.CreateUAV(OutputOrIntermediateTexture);
+
+	PassParameters->View = View.ViewUniformBuffer;
+	FNISUpscaleCS::FPermutationDomain PermutationVector;
+
+	PermutationVector.Set<FNISScalerDim>(bIsUpscaling);
+	PermutationVector.Set<FNISHdrModeDim>(int32(HdrMode));
+	PermutationVector.Set<FNISHalfPrecisionDim>(HalfPrecisionPermutation);
+
+	PermutationVector.Set<FNISBlockWidthDim>(FNISUpscaleCS::GetComputeTileSize(bIsUpscaling, bIsAnyHalfPrecisionPermutation).X);
+	PermutationVector.Set<FNISBlockHeightDim>(FNISUpscaleCS::GetComputeTileSize(bIsUpscaling, bIsAnyHalfPrecisionPermutation).Y);
+	PermutationVector.Set<FNISThreadGroupSizeDim>(FNISUpscaleCS::GetThreadGroupSize(bIsUpscaling, bIsAnyHalfPrecisionPermutation));
+	PermutationVector.Set<FNISViewportSupportDim>(bNeedsViewportSupport);
+	
+	TShaderMapRef<FNISUpscaleCS> Shader(View.ShaderMap, PermutationVector);
+
+	const TCHAR* const StageNames[] = { TEXT("PrimaryToSecondary"), TEXT("PrimaryToOutput"), TEXT("SecondaryToOutput") };
+	static_assert(UE_ARRAY_COUNT(StageNames) == static_cast<uint32>(EUpscaleStage::MAX), "StageNames does not match EUpscaleStage");
+	const TCHAR* StageName = StageNames[static_cast<uint32>(Inputs.Stage)];
+
+	check(IntermediateDestRect.Size() == OutputDestRect.Size());
+
+	FComputeShaderUtils::AddPass(
+		GraphBuilder,
+		RDG_EVENT_NAME("NIS %s %s %s (%s) (%dx%d -> %dx%d) = [%d,%d - %d,%d] -> [%d,%d - %d,%d]",
+			bIsUpscaling ? TEXT("Upscaler") : TEXT("Sharpen"),
+			bNeedIntermediateOutput ? TEXT("WithIntermediate ") : TEXT(""),
+			bNeedsViewportSupport ? TEXT(" Viewport") : TEXT(""),
+			StageName,
+			SrcRect.Width(), SrcRect.Height(),
+			IntermediateDestRect.Width(), IntermediateDestRect.Height(),
+			SrcRect.Min.X, SrcRect.Min.Y,
+			SrcRect.Max.X, SrcRect.Max.Y,
+			IntermediateDestRect.Min.X, IntermediateDestRect.Min.Y,
+			IntermediateDestRect.Max.X, IntermediateDestRect.Max.Y
+		),
+		Shader,
+		PassParameters,
+		FComputeShaderUtils::GetGroupCount(Output.ViewRect.Size(), Shader->GetComputeTileSize(bIsUpscaling, bIsAnyHalfPrecisionPermutation))
+	);
+	
+	if (bNeedIntermediateOutput)
+	{
+		check(OutputOrIntermediateTexture != Output.Texture);
+		AddCopyTexturePass(GraphBuilder, OutputOrIntermediateTexture, Output.Texture, 
+			IntermediateDestRect.Min,
+			OutputDestRect.Min,
+			IntermediateDestRect.Size());
+	}
+	return MoveTemp(Output);
+}
+
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FNISShadersModule, NISShaders)
+	

Plugins/Marketplace/NIS/Source/NISShaders/Private/NIS_Config.h

@@ -0,0 +1,541 @@
+// The MIT License(MIT)
+//
+// Copyright(c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files(the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+//---------------------------------------------------------------------------------
+// NVIDIA Image Scaling SDK  - v1.0.3
+//---------------------------------------------------------------------------------
+// Configuration
+//---------------------------------------------------------------------------------
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+
+#ifndef NIS_ALIGNED
+#if defined(_MSC_VER)
+#define NIS_ALIGNED(x) __declspec(align(x))
+#else
+#if defined(__GNUC__)
+#define NIS_ALIGNED(x) __attribute__ ((aligned(x)))
+#endif
+#endif
+#endif
+
+
+struct NIS_ALIGNED(256) NISConfig
+{
+    float kDetectRatio;
+    float kDetectThres;
+    float kMinContrastRatio;
+    float kRatioNorm;
+
+    float kContrastBoost;
+    float kEps;
+    float kSharpStartY;
+    float kSharpScaleY;
+
+    float kSharpStrengthMin;
+    float kSharpStrengthScale;
+    float kSharpLimitMin;
+    float kSharpLimitScale;
+
+    float kScaleX;
+    float kScaleY;
+    float kDstNormX;
+    float kDstNormY;
+
+    float kSrcNormX;
+    float kSrcNormY;
+
+    uint32_t kInputViewportOriginX;
+    uint32_t kInputViewportOriginY;
+    uint32_t kInputViewportWidth;
+    uint32_t kInputViewportHeight;
+
+    uint32_t kOutputViewportOriginX;
+    uint32_t kOutputViewportOriginY;
+    uint32_t kOutputViewportWidth;
+    uint32_t kOutputViewportHeight;
+
+    float reserved0;
+    float reserved1;
+};
+
+enum class NISHDRMode : uint32_t
+{
+    None = 0,
+    Linear = 1,
+    PQ = 2
+};
+
+enum class NISGPUArchitecture : uint32_t
+{
+    NVIDIA_Generic = 0,
+    AMD_Generic = 1,
+    Intel_Generic = 2,
+    NVIDIA_Generic_fp16 = 3
+};
+
+struct NISOptimizer
+{
+    bool isUpscaling;
+    NISGPUArchitecture gpuArch;
+
+    constexpr NISOptimizer(bool isUpscaling = true, NISGPUArchitecture gpuArch = NISGPUArchitecture::NVIDIA_Generic)
+        : isUpscaling(isUpscaling)
+        , gpuArch(gpuArch)
+    {}
+
+    constexpr uint32_t GetOptimalBlockWidth()
+    {
+        switch (gpuArch) {
+        case NISGPUArchitecture::NVIDIA_Generic:
+            return 32;
+        case NISGPUArchitecture::NVIDIA_Generic_fp16:
+            return 32;
+        case NISGPUArchitecture::AMD_Generic:
+            return 32;
+        case NISGPUArchitecture::Intel_Generic:
+            return 32;
+        }
+        return 32;
+    }
+
+    constexpr uint32_t GetOptimalBlockHeight()
+    {
+        switch (gpuArch) {
+        case NISGPUArchitecture::NVIDIA_Generic:
+            return isUpscaling ? 24 : 32;
+        case NISGPUArchitecture::NVIDIA_Generic_fp16:
+            return isUpscaling ? 32 : 32;
+        case NISGPUArchitecture::AMD_Generic:
+            return isUpscaling ? 24 : 32;
+        case NISGPUArchitecture::Intel_Generic:
+            return isUpscaling ? 24 : 32;
+        }
+        return isUpscaling ? 24 : 32;
+    }
+
+    constexpr uint32_t GetOptimalThreadGroupSize()
+    {
+        switch (gpuArch) {
+        case NISGPUArchitecture::NVIDIA_Generic:
+            return 128;
+        case NISGPUArchitecture::NVIDIA_Generic_fp16:
+            return 128;
+        case NISGPUArchitecture::AMD_Generic:
+            return 256;
+        case NISGPUArchitecture::Intel_Generic:
+            return 256;
+        }
+        return 256;
+    }
+};
+
+
+inline bool NVScalerUpdateConfig(NISConfig& config, float sharpness,
+    uint32_t inputViewportOriginX, uint32_t inputViewportOriginY,
+    uint32_t inputViewportWidth, uint32_t inputViewportHeight,
+    uint32_t inputTextureWidth, uint32_t inputTextureHeight,
+    uint32_t outputViewportOriginX, uint32_t outputViewportOriginY,
+    uint32_t outputViewportWidth, uint32_t outputViewportHeight,
+    uint32_t outputTextureWidth, uint32_t outputTextureHeight,
+    NISHDRMode hdrMode = NISHDRMode::None)
+{
+    // adjust params based on value from sharpness slider
+    sharpness = std::max<float>(std::min<float>(1.f, sharpness), 0.f);
+    float sharpen_slider = sharpness - 0.5f;   // Map 0 to 1 to -0.5 to +0.5
+
+    // Different range for 0 to 50% vs 50% to 100%
+    // The idea is to make sure sharpness of 0% map to no-sharpening,
+    // while also ensuring that sharpness of 100% doesn't cause too much over-sharpening.
+    const float MaxScale = (sharpen_slider >= 0.0f) ? 1.25f : 1.75f;
+    const float MinScale = (sharpen_slider >= 0.0f) ? 1.25f : 1.0f;
+    const float LimitScale = (sharpen_slider >= 0.0f) ? 1.25f : 1.0f;
+
+    float kDetectRatio = 2 * 1127.f / 1024.f;
+
+    // Params for SDR
+    float kDetectThres = 64.0f / 1024.0f;
+    float kMinContrastRatio = 2.0f;
+    float kMaxContrastRatio = 10.0f;
+
+    float kSharpStartY = 0.45f;
+    float kSharpEndY = 0.9f;
+    float kSharpStrengthMin = std::max<float>(0.0f, 0.4f + sharpen_slider * MinScale * 1.2f);
+    float kSharpStrengthMax = 1.6f + sharpen_slider * MaxScale * 1.8f;
+    float kSharpLimitMin = std::max<float>(0.1f, 0.14f + sharpen_slider * LimitScale * 0.32f);
+    float kSharpLimitMax = 0.5f + sharpen_slider * LimitScale * 0.6f;
+
+    if (hdrMode == NISHDRMode::Linear || hdrMode == NISHDRMode::PQ)
+    {
+        kDetectThres = 32.0f / 1024.0f;
+
+        kMinContrastRatio = 1.5f;
+        kMaxContrastRatio = 5.0f;
+
+        kSharpStrengthMin = std::max<float>(0.0f, 0.4f + sharpen_slider * MinScale * 1.1f);
+        kSharpStrengthMax = 2.2f + sharpen_slider * MaxScale * 1.8f;
+        kSharpLimitMin = std::max<float>(0.06f, 0.10f + sharpen_slider * LimitScale * 0.28f);
+        kSharpLimitMax = 0.6f + sharpen_slider * LimitScale * 0.6f;
+
+        if (hdrMode == NISHDRMode::PQ)
+        {
+            kSharpStartY = 0.35f;
+            kSharpEndY = 0.55f;
+        }
+        else
+        {
+            kSharpStartY = 0.3f;
+            kSharpEndY = 0.5f;
+        }
+    }
+
+    float kRatioNorm = 1.0f / (kMaxContrastRatio - kMinContrastRatio);
+    float kSharpScaleY = 1.0f / (kSharpEndY - kSharpStartY);
+    float kSharpStrengthScale = kSharpStrengthMax - kSharpStrengthMin;
+    float kSharpLimitScale = kSharpLimitMax - kSharpLimitMin;
+
+    config.kInputViewportWidth = inputViewportWidth == 0 ? inputTextureWidth : inputViewportWidth;
+    config.kInputViewportHeight = inputViewportHeight == 0 ? inputTextureHeight : inputViewportHeight;
+    config.kOutputViewportWidth = outputViewportWidth == 0 ? outputTextureWidth : outputViewportWidth;
+    config.kOutputViewportHeight = outputViewportHeight == 0 ? outputTextureHeight : outputViewportHeight;
+    if (config.kInputViewportWidth == 0 || config.kInputViewportHeight == 0 ||
+        config.kOutputViewportWidth == 0 || config.kOutputViewportHeight == 0)
+        return false;
+
+    config.kInputViewportOriginX = inputViewportOriginX;
+    config.kInputViewportOriginY = inputViewportOriginY;
+    config.kOutputViewportOriginX = outputViewportOriginX;
+    config.kOutputViewportOriginY = outputViewportOriginY;
+
+    config.kSrcNormX = 1.f / inputTextureWidth;
+    config.kSrcNormY = 1.f / inputTextureHeight;
+    config.kDstNormX = 1.f / outputTextureWidth;
+    config.kDstNormY = 1.f / outputTextureHeight;
+    config.kScaleX = config.kInputViewportWidth / float(config.kOutputViewportWidth);
+    config.kScaleY = config.kInputViewportHeight / float(config.kOutputViewportHeight);
+    config.kDetectRatio = kDetectRatio;
+    config.kDetectThres = kDetectThres;
+    config.kMinContrastRatio = kMinContrastRatio;
+    config.kRatioNorm = kRatioNorm;
+    config.kContrastBoost = 1.0f;
+    config.kEps = 1.0f / 255.0f;
+    config.kSharpStartY = kSharpStartY;
+    config.kSharpScaleY = kSharpScaleY;
+    config.kSharpStrengthMin = kSharpStrengthMin;
+    config.kSharpStrengthScale = kSharpStrengthScale;
+    config.kSharpLimitMin = kSharpLimitMin;
+    config.kSharpLimitScale = kSharpLimitScale;
+
+    if (config.kScaleX < 0.5f || config.kScaleX > 1.f || config.kScaleY < 0.5f || config.kScaleY > 1.f)
+        return false;
+    return true;
+}
+
+
+inline bool NVSharpenUpdateConfig(NISConfig& config, float sharpness,
+    uint32_t inputViewportOriginX, uint32_t inputViewportOriginY,
+    uint32_t inputViewportWidth, uint32_t inputViewportHeight,
+    uint32_t inputTextureWidth, uint32_t inputTextureHeight,
+    uint32_t outputViewportOriginX, uint32_t outputViewportOriginY,
+    NISHDRMode hdrMode = NISHDRMode::None)
+{
+    return NVScalerUpdateConfig(config, sharpness,
+            inputViewportOriginX, inputViewportOriginY, inputViewportWidth, inputViewportHeight, inputTextureWidth, inputTextureHeight,
+            outputViewportOriginX, outputViewportOriginY, inputViewportWidth, inputViewportHeight, inputTextureWidth, inputTextureHeight,
+            hdrMode);
+}
+
+namespace {
+    constexpr size_t kPhaseCount = 64;
+    constexpr size_t kFilterSize = 8;
+
+    constexpr float coef_scale[kPhaseCount][kFilterSize] = {
+        {0.0f,     0.0f,    1.0000f, 0.0f,     0.0f,    0.0f, 0.0f, 0.0f},
+        {0.0029f, -0.0127f, 1.0000f, 0.0132f, -0.0034f, 0.0f, 0.0f, 0.0f},
+        {0.0063f, -0.0249f, 0.9985f, 0.0269f, -0.0068f, 0.0f, 0.0f, 0.0f},
+        {0.0088f, -0.0361f, 0.9956f, 0.0415f, -0.0103f, 0.0005f, 0.0f, 0.0f},
+        {0.0117f, -0.0474f, 0.9932f, 0.0562f, -0.0142f, 0.0005f, 0.0f, 0.0f},
+        {0.0142f, -0.0576f, 0.9897f, 0.0713f, -0.0181f, 0.0005f, 0.0f, 0.0f},
+        {0.0166f, -0.0674f, 0.9844f, 0.0874f, -0.0220f, 0.0010f, 0.0f, 0.0f},
+        {0.0186f, -0.0762f, 0.9785f, 0.1040f, -0.0264f, 0.0015f, 0.0f, 0.0f},
+        {0.0205f, -0.0850f, 0.9727f, 0.1206f, -0.0308f, 0.0020f, 0.0f, 0.0f},
+        {0.0225f, -0.0928f, 0.9648f, 0.1382f, -0.0352f, 0.0024f, 0.0f, 0.0f},
+        {0.0239f, -0.1006f, 0.9575f, 0.1558f, -0.0396f, 0.0029f, 0.0f, 0.0f},
+        {0.0254f, -0.1074f, 0.9487f, 0.1738f, -0.0439f, 0.0034f, 0.0f, 0.0f},
+        {0.0264f, -0.1138f, 0.9390f, 0.1929f, -0.0488f, 0.0044f, 0.0f, 0.0f},
+        {0.0278f, -0.1191f, 0.9282f, 0.2119f, -0.0537f, 0.0049f, 0.0f, 0.0f},
+        {0.0288f, -0.1245f, 0.9170f, 0.2310f, -0.0581f, 0.0059f, 0.0f, 0.0f},
+        {0.0293f, -0.1294f, 0.9058f, 0.2510f, -0.0630f, 0.0063f, 0.0f, 0.0f},
+        {0.0303f, -0.1333f, 0.8926f, 0.2710f, -0.0679f, 0.0073f, 0.0f, 0.0f},
+        {0.0308f, -0.1367f, 0.8789f, 0.2915f, -0.0728f, 0.0083f, 0.0f, 0.0f},
+        {0.0308f, -0.1401f, 0.8657f, 0.3120f, -0.0776f, 0.0093f, 0.0f, 0.0f},
+        {0.0313f, -0.1426f, 0.8506f, 0.3330f, -0.0825f, 0.0103f, 0.0f, 0.0f},
+        {0.0313f, -0.1445f, 0.8354f, 0.3540f, -0.0874f, 0.0112f, 0.0f, 0.0f},
+        {0.0313f, -0.1460f, 0.8193f, 0.3755f, -0.0923f, 0.0122f, 0.0f, 0.0f},
+        {0.0313f, -0.1470f, 0.8022f, 0.3965f, -0.0967f, 0.0137f, 0.0f, 0.0f},
+        {0.0308f, -0.1479f, 0.7856f, 0.4185f, -0.1016f, 0.0146f, 0.0f, 0.0f},
+        {0.0303f, -0.1479f, 0.7681f, 0.4399f, -0.1060f, 0.0156f, 0.0f, 0.0f},
+        {0.0298f, -0.1479f, 0.7505f, 0.4614f, -0.1104f, 0.0166f, 0.0f, 0.0f},
+        {0.0293f, -0.1470f, 0.7314f, 0.4829f, -0.1147f, 0.0181f, 0.0f, 0.0f},
+        {0.0288f, -0.1460f, 0.7119f, 0.5049f, -0.1187f, 0.0190f, 0.0f, 0.0f},
+        {0.0278f, -0.1445f, 0.6929f, 0.5264f, -0.1226f, 0.0200f, 0.0f, 0.0f},
+        {0.0273f, -0.1431f, 0.6724f, 0.5479f, -0.1260f, 0.0215f, 0.0f, 0.0f},
+        {0.0264f, -0.1411f, 0.6528f, 0.5693f, -0.1299f, 0.0225f, 0.0f, 0.0f},
+        {0.0254f, -0.1387f, 0.6323f, 0.5903f, -0.1328f, 0.0234f, 0.0f, 0.0f},
+        {0.0244f, -0.1357f, 0.6113f, 0.6113f, -0.1357f, 0.0244f, 0.0f, 0.0f},
+        {0.0234f, -0.1328f, 0.5903f, 0.6323f, -0.1387f, 0.0254f, 0.0f, 0.0f},
+        {0.0225f, -0.1299f, 0.5693f, 0.6528f, -0.1411f, 0.0264f, 0.0f, 0.0f},
+        {0.0215f, -0.1260f, 0.5479f, 0.6724f, -0.1431f, 0.0273f, 0.0f, 0.0f},
+        {0.0200f, -0.1226f, 0.5264f, 0.6929f, -0.1445f, 0.0278f, 0.0f, 0.0f},
+        {0.0190f, -0.1187f, 0.5049f, 0.7119f, -0.1460f, 0.0288f, 0.0f, 0.0f},
+        {0.0181f, -0.1147f, 0.4829f, 0.7314f, -0.1470f, 0.0293f, 0.0f, 0.0f},
+        {0.0166f, -0.1104f, 0.4614f, 0.7505f, -0.1479f, 0.0298f, 0.0f, 0.0f},
+        {0.0156f, -0.1060f, 0.4399f, 0.7681f, -0.1479f, 0.0303f, 0.0f, 0.0f},
+        {0.0146f, -0.1016f, 0.4185f, 0.7856f, -0.1479f, 0.0308f, 0.0f, 0.0f},
+        {0.0137f, -0.0967f, 0.3965f, 0.8022f, -0.1470f, 0.0313f, 0.0f, 0.0f},
+        {0.0122f, -0.0923f, 0.3755f, 0.8193f, -0.1460f, 0.0313f, 0.0f, 0.0f},
+        {0.0112f, -0.0874f, 0.3540f, 0.8354f, -0.1445f, 0.0313f, 0.0f, 0.0f},
+        {0.0103f, -0.0825f, 0.3330f, 0.8506f, -0.1426f, 0.0313f, 0.0f, 0.0f},
+        {0.0093f, -0.0776f, 0.3120f, 0.8657f, -0.1401f, 0.0308f, 0.0f, 0.0f},
+        {0.0083f, -0.0728f, 0.2915f, 0.8789f, -0.1367f, 0.0308f, 0.0f, 0.0f},
+        {0.0073f, -0.0679f, 0.2710f, 0.8926f, -0.1333f, 0.0303f, 0.0f, 0.0f},
+        {0.0063f, -0.0630f, 0.2510f, 0.9058f, -0.1294f, 0.0293f, 0.0f, 0.0f},
+        {0.0059f, -0.0581f, 0.2310f, 0.9170f, -0.1245f, 0.0288f, 0.0f, 0.0f},
+        {0.0049f, -0.0537f, 0.2119f, 0.9282f, -0.1191f, 0.0278f, 0.0f, 0.0f},
+        {0.0044f, -0.0488f, 0.1929f, 0.9390f, -0.1138f, 0.0264f, 0.0f, 0.0f},
+        {0.0034f, -0.0439f, 0.1738f, 0.9487f, -0.1074f, 0.0254f, 0.0f, 0.0f},
+        {0.0029f, -0.0396f, 0.1558f, 0.9575f, -0.1006f, 0.0239f, 0.0f, 0.0f},
+        {0.0024f, -0.0352f, 0.1382f, 0.9648f, -0.0928f, 0.0225f, 0.0f, 0.0f},
+        {0.0020f, -0.0308f, 0.1206f, 0.9727f, -0.0850f, 0.0205f, 0.0f, 0.0f},
+        {0.0015f, -0.0264f, 0.1040f, 0.9785f, -0.0762f, 0.0186f, 0.0f, 0.0f},
+        {0.0010f, -0.0220f, 0.0874f, 0.9844f, -0.0674f, 0.0166f, 0.0f, 0.0f},
+        {0.0005f, -0.0181f, 0.0713f, 0.9897f, -0.0576f, 0.0142f, 0.0f, 0.0f},
+        {0.0005f, -0.0142f, 0.0562f, 0.9932f, -0.0474f, 0.0117f, 0.0f, 0.0f},
+        {0.0005f, -0.0103f, 0.0415f, 0.9956f, -0.0361f, 0.0088f, 0.0f, 0.0f},
+        {0.0f, -0.0068f, 0.0269f, 0.9985f, -0.0249f, 0.0063f, 0.0f, 0.0f},
+        {0.0f, -0.0034f, 0.0132f, 1.0000f, -0.0127f, 0.0029f, 0.0f, 0.0f}
+    };
+
+    constexpr float coef_usm[kPhaseCount][kFilterSize] = {
+        {0.0f,      -0.6001f, 1.2002f, -0.6001f,  0.0f,  0.0f, 0.0f, 0.0f},
+        {0.0029f, -0.6084f, 1.1987f, -0.5903f, -0.0029f, 0.0f, 0.0f, 0.0f},
+        {0.0049f, -0.6147f, 1.1958f, -0.5791f, -0.0068f, 0.0005f, 0.0f, 0.0f},
+        {0.0073f, -0.6196f, 1.1890f, -0.5659f, -0.0103f, 0.0f, 0.0f, 0.0f},
+        {0.0093f, -0.6235f, 1.1802f, -0.5513f, -0.0151f, 0.0f, 0.0f, 0.0f},
+        {0.0112f, -0.6265f, 1.1699f, -0.5352f, -0.0195f, 0.0005f, 0.0f, 0.0f},
+        {0.0122f, -0.6270f, 1.1582f, -0.5181f, -0.0259f, 0.0005f, 0.0f, 0.0f},
+        {0.0142f, -0.6284f, 1.1455f, -0.5005f, -0.0317f, 0.0005f, 0.0f, 0.0f},
+        {0.0156f, -0.6265f, 1.1274f, -0.4790f, -0.0386f, 0.0005f, 0.0f, 0.0f},
+        {0.0166f, -0.6235f, 1.1089f, -0.4570f, -0.0454f, 0.0010f, 0.0f, 0.0f},
+        {0.0176f, -0.6187f, 1.0879f, -0.4346f, -0.0532f, 0.0010f, 0.0f, 0.0f},
+        {0.0181f, -0.6138f, 1.0659f, -0.4102f, -0.0615f, 0.0015f, 0.0f, 0.0f},
+        {0.0190f, -0.6069f, 1.0405f, -0.3843f, -0.0698f, 0.0015f, 0.0f, 0.0f},
+        {0.0195f, -0.6006f, 1.0161f, -0.3574f, -0.0796f, 0.0020f, 0.0f, 0.0f},
+        {0.0200f, -0.5928f, 0.9893f, -0.3286f, -0.0898f, 0.0024f, 0.0f, 0.0f},
+        {0.0200f, -0.5820f, 0.9580f, -0.2988f, -0.1001f, 0.0029f, 0.0f, 0.0f},
+        {0.0200f, -0.5728f, 0.9292f, -0.2690f, -0.1104f, 0.0034f, 0.0f, 0.0f},
+        {0.0200f, -0.5620f, 0.8975f, -0.2368f, -0.1226f, 0.0039f, 0.0f, 0.0f},
+        {0.0205f, -0.5498f, 0.8643f, -0.2046f, -0.1343f, 0.0044f, 0.0f, 0.0f},
+        {0.0200f, -0.5371f, 0.8301f, -0.1709f, -0.1465f, 0.0049f, 0.0f, 0.0f},
+        {0.0195f, -0.5239f, 0.7944f, -0.1367f, -0.1587f, 0.0054f, 0.0f, 0.0f},
+        {0.0195f, -0.5107f, 0.7598f, -0.1021f, -0.1724f, 0.0059f, 0.0f, 0.0f},
+        {0.0190f, -0.4966f, 0.7231f, -0.0649f, -0.1865f, 0.0063f, 0.0f, 0.0f},
+        {0.0186f, -0.4819f, 0.6846f, -0.0288f, -0.1997f, 0.0068f, 0.0f, 0.0f},
+        {0.0186f, -0.4668f, 0.6460f, 0.0093f, -0.2144f, 0.0073f, 0.0f, 0.0f},
+        {0.0176f, -0.4507f, 0.6055f, 0.0479f, -0.2290f, 0.0083f, 0.0f, 0.0f},
+        {0.0171f, -0.4370f, 0.5693f, 0.0859f, -0.2446f, 0.0088f, 0.0f, 0.0f},
+        {0.0161f, -0.4199f, 0.5283f, 0.1255f, -0.2598f, 0.0098f, 0.0f, 0.0f},
+        {0.0161f, -0.4048f, 0.4883f, 0.1655f, -0.2754f, 0.0103f, 0.0f, 0.0f},
+        {0.0151f, -0.3887f, 0.4497f, 0.2041f, -0.2910f, 0.0107f, 0.0f, 0.0f},
+        {0.0142f, -0.3711f, 0.4072f, 0.2446f, -0.3066f, 0.0117f, 0.0f, 0.0f},
+        {0.0137f, -0.3555f, 0.3672f, 0.2852f, -0.3228f, 0.0122f, 0.0f, 0.0f},
+        {0.0132f, -0.3394f, 0.3262f, 0.3262f, -0.3394f, 0.0132f, 0.0f, 0.0f},
+        {0.0122f, -0.3228f, 0.2852f, 0.3672f, -0.3555f, 0.0137f, 0.0f, 0.0f},
+        {0.0117f, -0.3066f, 0.2446f, 0.4072f, -0.3711f, 0.0142f, 0.0f, 0.0f},
+        {0.0107f, -0.2910f, 0.2041f, 0.4497f, -0.3887f, 0.0151f, 0.0f, 0.0f},
+        {0.0103f, -0.2754f, 0.1655f, 0.4883f, -0.4048f, 0.0161f, 0.0f, 0.0f},
+        {0.0098f, -0.2598f, 0.1255f, 0.5283f, -0.4199f, 0.0161f, 0.0f, 0.0f},
+        {0.0088f, -0.2446f, 0.0859f, 0.5693f, -0.4370f, 0.0171f, 0.0f, 0.0f},
+        {0.0083f, -0.2290f, 0.0479f, 0.6055f, -0.4507f, 0.0176f, 0.0f, 0.0f},
+        {0.0073f, -0.2144f, 0.0093f, 0.6460f, -0.4668f, 0.0186f, 0.0f, 0.0f},
+        {0.0068f, -0.1997f, -0.0288f, 0.6846f, -0.4819f, 0.0186f, 0.0f, 0.0f},
+        {0.0063f, -0.1865f, -0.0649f, 0.7231f, -0.4966f, 0.0190f, 0.0f, 0.0f},
+        {0.0059f, -0.1724f, -0.1021f, 0.7598f, -0.5107f, 0.0195f, 0.0f, 0.0f},
+        {0.0054f, -0.1587f, -0.1367f, 0.7944f, -0.5239f, 0.0195f, 0.0f, 0.0f},
+        {0.0049f, -0.1465f, -0.1709f, 0.8301f, -0.5371f, 0.0200f, 0.0f, 0.0f},
+        {0.0044f, -0.1343f, -0.2046f, 0.8643f, -0.5498f, 0.0205f, 0.0f, 0.0f},
+        {0.0039f, -0.1226f, -0.2368f, 0.8975f, -0.5620f, 0.0200f, 0.0f, 0.0f},
+        {0.0034f, -0.1104f, -0.2690f, 0.9292f, -0.5728f, 0.0200f, 0.0f, 0.0f},
+        {0.0029f, -0.1001f, -0.2988f, 0.9580f, -0.5820f, 0.0200f, 0.0f, 0.0f},
+        {0.0024f, -0.0898f, -0.3286f, 0.9893f, -0.5928f, 0.0200f, 0.0f, 0.0f},
+        {0.0020f, -0.0796f, -0.3574f, 1.0161f, -0.6006f, 0.0195f, 0.0f, 0.0f},
+        {0.0015f, -0.0698f, -0.3843f, 1.0405f, -0.6069f, 0.0190f, 0.0f, 0.0f},
+        {0.0015f, -0.0615f, -0.4102f, 1.0659f, -0.6138f, 0.0181f, 0.0f, 0.0f},
+        {0.0010f, -0.0532f, -0.4346f, 1.0879f, -0.6187f, 0.0176f, 0.0f, 0.0f},
+        {0.0010f, -0.0454f, -0.4570f, 1.1089f, -0.6235f, 0.0166f, 0.0f, 0.0f},
+        {0.0005f, -0.0386f, -0.4790f, 1.1274f, -0.6265f, 0.0156f, 0.0f, 0.0f},
+        {0.0005f, -0.0317f, -0.5005f, 1.1455f, -0.6284f, 0.0142f, 0.0f, 0.0f},
+        {0.0005f, -0.0259f, -0.5181f, 1.1582f, -0.6270f, 0.0122f, 0.0f, 0.0f},
+        {0.0005f, -0.0195f, -0.5352f, 1.1699f, -0.6265f, 0.0112f, 0.0f, 0.0f},
+        {0.0f, -0.0151f, -0.5513f, 1.1802f, -0.6235f, 0.0093f, 0.0f, 0.0f},
+        {0.0f, -0.0103f, -0.5659f, 1.1890f, -0.6196f, 0.0073f, 0.0f, 0.0f},
+        {0.0005f, -0.0068f, -0.5791f, 1.1958f, -0.6147f, 0.0049f, 0.0f, 0.0f},
+        {0.0f, -0.0029f, -0.5903f, 1.1987f, -0.6084f, 0.0029f, 0.0f, 0.0f}
+    };
+
+    constexpr uint16_t coef_scale_fp16[kPhaseCount][kFilterSize] = {
+       { 0, 0, 15360, 0, 0, 0, 0, 0 },
+       { 6640, 41601, 15360, 8898, 39671, 0, 0, 0 },
+       { 7796, 42592, 15357, 9955, 40695, 0, 0, 0 },
+       { 8321, 43167, 15351, 10576, 41286, 4121, 0, 0 },
+       { 8702, 43537, 15346, 11058, 41797, 4121, 0, 0 },
+       { 9029, 43871, 15339, 11408, 42146, 4121, 0, 0 },
+       { 9280, 44112, 15328, 11672, 42402, 5145, 0, 0 },
+       { 9411, 44256, 15316, 11944, 42690, 5669, 0, 0 },
+       { 9535, 44401, 15304, 12216, 42979, 6169, 0, 0 },
+       { 9667, 44528, 15288, 12396, 43137, 6378, 0, 0 },
+       { 9758, 44656, 15273, 12540, 43282, 6640, 0, 0 },
+       { 9857, 44768, 15255, 12688, 43423, 6903, 0, 0 },
+       { 9922, 44872, 15235, 12844, 43583, 7297, 0, 0 },
+       { 10014, 44959, 15213, 13000, 43744, 7429, 0, 0 },
+       { 10079, 45048, 15190, 13156, 43888, 7691, 0, 0 },
+       { 10112, 45092, 15167, 13316, 44040, 7796, 0, 0 },
+       { 10178, 45124, 15140, 13398, 44120, 8058, 0, 0 },
+       { 10211, 45152, 15112, 13482, 44201, 8256, 0, 0 },
+       { 10211, 45180, 15085, 13566, 44279, 8387, 0, 0 },
+       { 10242, 45200, 15054, 13652, 44360, 8518, 0, 0 },
+       { 10242, 45216, 15023, 13738, 44440, 8636, 0, 0 },
+       { 10242, 45228, 14990, 13826, 44520, 8767, 0, 0 },
+       { 10242, 45236, 14955, 13912, 44592, 8964, 0, 0 },
+       { 10211, 45244, 14921, 14002, 44673, 9082, 0, 0 },
+       { 10178, 45244, 14885, 14090, 44745, 9213, 0, 0 },
+       { 10145, 45244, 14849, 14178, 44817, 9280, 0, 0 },
+       { 10112, 45236, 14810, 14266, 44887, 9378, 0, 0 },
+       { 10079, 45228, 14770, 14346, 44953, 9437, 0, 0 },
+       { 10014, 45216, 14731, 14390, 45017, 9503, 0, 0 },
+       { 9981, 45204, 14689, 14434, 45064, 9601, 0, 0 },
+       { 9922, 45188, 14649, 14478, 45096, 9667, 0, 0 },
+       { 9857, 45168, 14607, 14521, 45120, 9726, 0, 0 },
+       { 9791, 45144, 14564, 14564, 45144, 9791, 0, 0 },
+       { 9726, 45120, 14521, 14607, 45168, 9857, 0, 0 },
+       { 9667, 45096, 14478, 14649, 45188, 9922, 0, 0 },
+       { 9601, 45064, 14434, 14689, 45204, 9981, 0, 0 },
+       { 9503, 45017, 14390, 14731, 45216, 10014, 0, 0 },
+       { 9437, 44953, 14346, 14770, 45228, 10079, 0, 0 },
+       { 9378, 44887, 14266, 14810, 45236, 10112, 0, 0 },
+       { 9280, 44817, 14178, 14849, 45244, 10145, 0, 0 },
+       { 9213, 44745, 14090, 14885, 45244, 10178, 0, 0 },
+       { 9082, 44673, 14002, 14921, 45244, 10211, 0, 0 },
+       { 8964, 44592, 13912, 14955, 45236, 10242, 0, 0 },
+       { 8767, 44520, 13826, 14990, 45228, 10242, 0, 0 },
+       { 8636, 44440, 13738, 15023, 45216, 10242, 0, 0 },
+       { 8518, 44360, 13652, 15054, 45200, 10242, 0, 0 },
+       { 8387, 44279, 13566, 15085, 45180, 10211, 0, 0 },
+       { 8256, 44201, 13482, 15112, 45152, 10211, 0, 0 },
+       { 8058, 44120, 13398, 15140, 45124, 10178, 0, 0 },
+       { 7796, 44040, 13316, 15167, 45092, 10112, 0, 0 },
+       { 7691, 43888, 13156, 15190, 45048, 10079, 0, 0 },
+       { 7429, 43744, 13000, 15213, 44959, 10014, 0, 0 },
+       { 7297, 43583, 12844, 15235, 44872, 9922, 0, 0 },
+       { 6903, 43423, 12688, 15255, 44768, 9857, 0, 0 },
+       { 6640, 43282, 12540, 15273, 44656, 9758, 0, 0 },
+       { 6378, 43137, 12396, 15288, 44528, 9667, 0, 0 },
+       { 6169, 42979, 12216, 15304, 44401, 9535, 0, 0 },
+       { 5669, 42690, 11944, 15316, 44256, 9411, 0, 0 },
+       { 5145, 42402, 11672, 15328, 44112, 9280, 0, 0 },
+       { 4121, 42146, 11408, 15339, 43871, 9029, 0, 0 },
+       { 4121, 41797, 11058, 15346, 43537, 8702, 0, 0 },
+       { 4121, 41286, 10576, 15351, 43167, 8321, 0, 0 },
+       { 0, 40695, 9955, 15357, 42592, 7796, 0, 0 },
+       { 0, 39671, 8898, 15360, 41601, 6640, 0, 0 },
+    };
+
+    constexpr uint16_t coef_usm_fp16[kPhaseCount][kFilterSize] = {
+        { 0, 47309, 15565, 47309, 0, 0, 0, 0 },
+        { 6640, 47326, 15563, 47289, 39408, 0, 0, 0 },
+        { 7429, 47339, 15560, 47266, 40695, 4121, 0, 0 },
+        { 8058, 47349, 15554, 47239, 41286, 0, 0, 0 },
+        { 8387, 47357, 15545, 47209, 41915, 0, 0, 0 },
+        { 8636, 47363, 15534, 47176, 42238, 4121, 0, 0 },
+        { 8767, 47364, 15522, 47141, 42657, 4121, 0, 0 },
+        { 9029, 47367, 15509, 47105, 43023, 4121, 0, 0 },
+        { 9213, 47363, 15490, 47018, 43249, 4121, 0, 0 },
+        { 9280, 47357, 15472, 46928, 43472, 5145, 0, 0 },
+        { 9345, 47347, 15450, 46836, 43727, 5145, 0, 0 },
+        { 9378, 47337, 15427, 46736, 43999, 5669, 0, 0 },
+        { 9437, 47323, 15401, 46630, 44152, 5669, 0, 0 },
+        { 9470, 47310, 15376, 46520, 44312, 6169, 0, 0 },
+        { 9503, 47294, 15338, 46402, 44479, 6378, 0, 0 },
+        { 9503, 47272, 15274, 46280, 44648, 6640, 0, 0 },
+        { 9503, 47253, 15215, 46158, 44817, 6903, 0, 0 },
+        { 9503, 47231, 15150, 45972, 45017, 7165, 0, 0 },
+        { 9535, 47206, 15082, 45708, 45132, 7297, 0, 0 },
+        { 9503, 47180, 15012, 45432, 45232, 7429, 0, 0 },
+        { 9470, 47153, 14939, 45152, 45332, 7560, 0, 0 },
+        { 9470, 47126, 14868, 44681, 45444, 7691, 0, 0 },
+        { 9437, 47090, 14793, 44071, 45560, 7796, 0, 0 },
+        { 9411, 47030, 14714, 42847, 45668, 7927, 0, 0 },
+        { 9411, 46968, 14635, 8387, 45788, 8058, 0, 0 },
+        { 9345, 46902, 14552, 10786, 45908, 8256, 0, 0 },
+        { 9313, 46846, 14478, 11647, 46036, 8321, 0, 0 },
+        { 9247, 46776, 14394, 12292, 46120, 8453, 0, 0 },
+        { 9247, 46714, 14288, 12620, 46184, 8518, 0, 0 },
+        { 9147, 46648, 14130, 12936, 46248, 8570, 0, 0 },
+        { 9029, 46576, 13956, 13268, 46312, 8702, 0, 0 },
+        { 8964, 46512, 13792, 13456, 46378, 8767, 0, 0 },
+        { 8898, 46446, 13624, 13624, 46446, 8898, 0, 0 },
+        { 8767, 46378, 13456, 13792, 46512, 8964, 0, 0 },
+        { 8702, 46312, 13268, 13956, 46576, 9029, 0, 0 },
+        { 8570, 46248, 12936, 14130, 46648, 9147, 0, 0 },
+        { 8518, 46184, 12620, 14288, 46714, 9247, 0, 0 },
+        { 8453, 46120, 12292, 14394, 46776, 9247, 0, 0 },
+        { 8321, 46036, 11647, 14478, 46846, 9313, 0, 0 },
+        { 8256, 45908, 10786, 14552, 46902, 9345, 0, 0 },
+        { 8058, 45788, 8387, 14635, 46968, 9411, 0, 0 },
+        { 7927, 45668, 42847, 14714, 47030, 9411, 0, 0 },
+        { 7796, 45560, 44071, 14793, 47090, 9437, 0, 0 },
+        { 7691, 45444, 44681, 14868, 47126, 9470, 0, 0 },
+        { 7560, 45332, 45152, 14939, 47153, 9470, 0, 0 },
+        { 7429, 45232, 45432, 15012, 47180, 9503, 0, 0 },
+        { 7297, 45132, 45708, 15082, 47206, 9535, 0, 0 },
+        { 7165, 45017, 45972, 15150, 47231, 9503, 0, 0 },
+        { 6903, 44817, 46158, 15215, 47253, 9503, 0, 0 },
+        { 6640, 44648, 46280, 15274, 47272, 9503, 0, 0 },
+        { 6378, 44479, 46402, 15338, 47294, 9503, 0, 0 },
+        { 6169, 44312, 46520, 15376, 47310, 9470, 0, 0 },
+        { 5669, 44152, 46630, 15401, 47323, 9437, 0, 0 },
+        { 5669, 43999, 46736, 15427, 47337, 9378, 0, 0 },
+        { 5145, 43727, 46836, 15450, 47347, 9345, 0, 0 },
+        { 5145, 43472, 46928, 15472, 47357, 9280, 0, 0 },
+        { 4121, 43249, 47018, 15490, 47363, 9213, 0, 0 },
+        { 4121, 43023, 47105, 15509, 47367, 9029, 0, 0 },
+        { 4121, 42657, 47141, 15522, 47364, 8767, 0, 0 },
+        { 4121, 42238, 47176, 15534, 47363, 8636, 0, 0 },
+        { 0, 41915, 47209, 15545, 47357, 8387, 0, 0 },
+        { 0, 41286, 47239, 15554, 47349, 8058, 0, 0 },
+        { 4121, 40695, 47266, 15560, 47339, 7429, 0, 0 },
+        { 0, 39408, 47289, 15563, 47326, 6640, 0, 0 },
+    };
+}

Plugins/Marketplace/NIS/Source/NISShaders/Public/NISShaders.h

@@ -0,0 +1,39 @@
+/*
+* Copyright (c) 2022 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+*
+* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+* property and proprietary rights in and to this material, related
+* documentation and any modifications thereto. Any use, reproduction,
+* disclosure or distribution of this material and related documentation
+* without an express license agreement from NVIDIA CORPORATION or
+* its affiliates is strictly prohibited.
+*/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+#include "PostProcess/PostProcessUpscale.h"
+class FNISViewExtension;
+
+DECLARE_LOG_CATEGORY_EXTERN(LogNIS, Log, All);
+
+class FNISShadersModule final: public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule();
+
+	virtual void ShutdownModule();
+
+private:
+};
+
+NISSHADERS_API ERHIFeatureLevel::Type GetNISMinRequiredFeatureLevel();
+
+NISSHADERS_API FScreenPassTexture AddSharpenOrUpscalePass(
+	FRDGBuilder& GraphBuilder,
+	const FViewInfo& View,
+	const ISpatialUpscaler::FInputs& Inputs
+);
+

Plugins/Marketplace/Streamline/Streamline.uplugin

@@ -0,0 +1,34 @@
+{
+	"FileVersion": 3,
+	"Version": 115,
+	"VersionName": "4.0.0-SL2.7.3",
+	"FriendlyName": "NVIDIA Streamline (deprecated)",
+	"Description": "For compatibility with projects using previous versions of the Streamline plugins",
+	"Category": "Rendering",
+	"CreatedBy": "NVIDIA",
+	"CreatedByURL": "https://developer.nvidia.com/rtx/streamline",
+	"DocsURL": "",
+	"MarketplaceURL": "https://www.unrealengine.com/marketplace/en-US/product/nvidia-dlss",
+	"SupportURL": "mailto:DLSS-Support@nvidia.com",
+	"EngineVersion": "5.5.0",
+	"CanContainContent": false,
+	"Installed": true,
+	"Plugins": [
+		{
+			"Name": "StreamlineCore",
+			"Enabled": true
+		},
+		{
+			"Name": "StreamlineDLSSG",
+			"Enabled": true
+		},
+		{
+			"Name": "StreamlineDeepDVC",
+			"Enabled": true
+		},
+		{
+			"Name": "StreamlineReflex",
+			"Enabled": true
+		}
+	]
+}

Plugins/Marketplace/Streamline/This_plugin_has_moved_to_StreamlineCore.md

@@ -0,0 +1,3 @@
+# NVIDIA Streamline 1.3.3 Legacy Compatibility plugin
+
+This NVIDIA Streamline 1.3.3 Legacy Compatibility plugin doesn't contain any code and only enables a few plugins to allow projects developed against the 1.x.x family of plugins to continue to work. Please refer to the documentation there about upgrading existing projects.

Plugins/Marketplace/StreamlineCore/Config/BaseStreamlineCore.ini

@@ -0,0 +1,8 @@
+[CoreRedirects]
++ClassRedirects=(OldName="/Script/StreamlineBlueprint.StreamlineLibraryDLSSG",NewName="/Script/StreamlineDLSSGBlueprint.StreamlineLibraryDLSSG")
++ClassRedirects=(OldName="/Script/StreamlineBlueprint.StreamlineLibraryReflex",NewName="/Script/StreamlineReflexBlueprint.StreamlineLibraryReflex")
+
++EnumRedirects=(OldName="UStreamlineFeature",NewName="EStreamlineFeature")
++EnumRedirects=(OldName="UStreamlineFeatureSupport",NewName="EStreamlineFeatureSupport")
++EnumRedirects=(OldName="UStreamlineFeatureRequirementsFlags",NewName="EStreamlineFeatureRequirementsFlags")
+

Plugins/Marketplace/StreamlineCore/Config/FilterPlugin.ini

@@ -0,0 +1,14 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll
+
+
+/Config/...
+/Docs/*.md
+/Docs/media/*.png
+

Plugins/Marketplace/StreamlineCore/Docs/APIChangesAndImprovements.md

@@ -0,0 +1,118 @@
+# Improvements and API changes in SL 1.5 and SL 2.0
+
+> **NOTE**:
+> This document contains the high level breakdown of changes introduced in SL 1.5/2.0 and how they compare to previous SL versions. For more details please read the full [programming guide](./ProgrammingGuide.md)
+
+## SL 1.5
+
+### RESOURCE STATE TRACKING
+
+* SL no longer tracks resource states, host is responsible for providing correct states when tagging resources.
+
+### COMMAND LIST STATE TRACKING
+
+* SL by default disables any command list (CL) tracking, host is responsible for restoring CL state after each `slEvaluateFeature` call.
+
+### DISABLING OF THE INTERPOSER
+
+* SL disables interposer (DXGI/D3D proxies) unless they are **explicitly requested by at least one supported plugin**
+
+### VERIFYING SL DLLs
+
+* SL now includes `sl_security.h` header as part of the main SDK (no longer needed to download the SL sample SDK)
+
+### OS VERSION DETECTION
+
+* Switched to obtaining the **correct** version from the `kernel32.dll` product description instead of using various MS APIs which return different/incorrect versions
+* Flag `PreferenceFlags::eBypassOSVersionCheck` in `sl::Preferences` can be used to opt-out from the OS detection (off by default and **highly discouraged to use**)
+
+### OTA OPT-IN
+
+* Expanded `sl::Preferences` to include `PreferenceFlags::eAllowOTA` to automatically opt-in in the OTA program (SL and NGX). This flag is set by default.
+
+### DLSS PRESETS
+
+* Host can change DL networks (presets) for the DLSS by modifying `sl::DLSSOptions`.
+
+## SL 2.0
+
+Streamline 2.0 **includes all the above mentioned v1.5 changes with the following additions**:
+
+### FEATURE ID
+
+* No longer provided as enum but rather as constant expression unsigned integers.
+* Core feature IDs declared and defined in `sl.h` while specific feature IDs are now located in their respective header files.
+
+### ENUM NAMING
+
+* All enums have been converted to `enum class Name::eValue` format.
+
+### ERROR REPORTING
+
+* All SL functions now return `sl::Result` (new header `sl_result.h`)
+* Still required to monitor error logging callbacks to catch every single possible error at the right time but this improves handling of the most common errors.
+* Introduced helper macro `SL_FAILED`.
+* Helper method added to convert `sl::Result` to a string.
+
+### VERSIONING AND OTA
+
+* New API `slGetFeatureVersion` returns both SL and NGX (if any) versions.
+
+### REQUIREMENTS REPORTING
+
+* Removed `slGetFeatureConfiguration` which was returning JSON since it is not always convenient for eve
+* New API `slGetFeatureRequirements` is added to provide info about OS, driver, HWS, rendering API, VK extensions and other requirements
+* Added `getVkPhysicalDeviceVulkan12Features` and `getVkPhysicalDeviceVulkan13Features` helper functions in the new `sl_helpers_vk.h` header.
+
+### CONSTANTS VS SETTINGS
+
+* Generic `slSetFeatureConsts` and `slGetFeatureSettings` API have been removed and new API `slGetFeatureFunction` has been added.
+* Each SL feature exports set of functions which are used to perform feature specific task.
+* New helper macro `SL_FEATURE_FUN_IMPORT` and helper functions in the related `sl_$feature.h` headers.
+* Helper functions added to each per-feature header to make importing easy.
+
+### IS FEATURE SUPPORTED AND ADAPTER BIT-MASK
+
+* `slIsFeatureSupported` is modified to use adapter LUID which is easily obtained from DXGIAdapterDesc or VK physical device.
+* Engines are already enumerating adapters so this should fit in nicely with the existing code.
+* When using VK host can provide `VkPhysicalDevice` instead of LUID if needed.
+
+### ACTUAL FPS
+
+* Removed `actualFrameTimeMs` and `timeBetweenPresentsMs` and replaced with an integer value `numFramesActuallyPresented`.
+
+### IMPROVED VIEWPORT SUPPORT FOR DLSS-G
+
+* Host can specify any viewport id when calling `slDLSSGSetOptions` rather than forcing viewport 0 all the time.
+
+### "NOT RENDERING GAME FRAMES" FLAG
+
+* Removed completely since it has become redundant.
+* Host is now required to turn DLSS-G on/off using `slDLSSGSetOptions`
+
+### BUFFER COPIES AND TAGGING
+
+* `slSetTag` API has been expanded to include command list and resource life-cycle information.
+* If needed resources are automatically copied internally by SL.
+* `slEvaluateFeature` can be used to tag resources locally (tags only valid for the specific evaluate call, see programming guide for details)
+
+### FRAME ID
+
+* New API `slGetNewFrameToken` is added to allow host to obtain frame handle for the next frame.
+* Same handle is then passed around to all SL calls.
+* If host wants to fully control frame counting the frame index can be provided as input
+
+### MULTIPLE DEVICES
+
+* New API `slSetD3DDevice` and `slSetVulkanInfo` can be used to specify which device SL should be using.
+
+### OBTAINING NATIVE INTERFACES
+
+* When using 3rd party libraries (including NVAPI) it is not advisable to pass SL proxies as inputs.
+* New API `slGetNativeInterface` added to allow access to native interfaces as needed.
+
+### MANUAL HOOKING
+
+* Removed `slGetHook*` API
+* New API `slGetNativeInterface` in combination with `slUpgradeIntercace` is now used to significantly simplify manual hooking.
+

Plugins/Marketplace/StreamlineCore/Docs/Debugging - JSON Configs (Plugin Configs).md

@@ -0,0 +1,164 @@
+# Debugging with JSON Configs
+> **NOTE:**
+> This document applies to non-production, development builds only.  JSON configuration is disabled in production builds.
+> Additionally, you will need to turn off any checks for signed libraries when loading Streamline libraries in order to be able to load the non-production libraries.
+
+## JSON Config File(s)
+
+### Location of the JSON
+
+Note that the `sl.interposer.json` file is loaded by finding the first copy in the following ordered list of paths:
+1. The directory containing the application's executable.
+2. The application's current working directory at the point at which the app calls `slInit`.
+
+### "Commenting-out" Lines
+Note that the example configuration JSON files (located in `./scripts/`) include some tags that are disabled, but visible as a form of "comment"; this is done by prefixing the correct/expected tag name with underscore (_):
+
+Functional:
+```json
+{
+	"enableInterposer": false,	
+}
+```
+
+Non-functional "comment":
+```json
+{
+	"_enableInterposer": false,	
+}
+```
+
+## How to toggle SL on/off
+
+Place the `sl.interposer.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"enableInterposer": false,	
+}
+```
+
+When the game starts, if the flag is set to off, interposing will be completely disabled. This can be used to check for added CPU overhead in games.
+
+## How to force use of proxies
+
+Place the `sl.interposer.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"forceProxies": true
+}
+```
+
+> NOTE:
+> This effectively forces `slGetNativeInterface` to return proxies all the time. Useful for debugging and redirecting/changing behavior by intercepting all APIs for command queues, lists, devices etc.
+## How to track engine D3D12 allocations
+
+Place the `sl.interposer.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"trackEngineAllocations": true
+}
+```
+> NOTE:
+> This only works for D3D12 at the moment.
+## How to override plugin location
+
+Place the `sl.interposer.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"pathToPlugins": "N:/My/Plugin/Path"
+}
+```
+
+By default SL looks for plugins next to the executable or in the paths provided by the host application (see sl::Preferences). If `pathToPlugins` is provided in JSON it overrides all these settings.
+> **NOTE:**
+> The `sl.interposer.dll` still needs to reside in the game's working directory in order to be found and loaded properly.  All other SL plugin dlls should reside in the path referenced in the `pathToPlugins` setting.
+
+## How to override logging settings
+
+Place the `sl.interposer.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"showConsole": true,
+	"logLevel": 2,
+	"logPath": "N:/My/Log/Path"
+}
+```
+
+To modify NGX logging, place `sl.common.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"logLevelNGX": 2,
+}
+```
+
+Log levels are `off` (0), `on` (1) and `verbose` (2). Default values come from the `sl::Preferences` structure set by the app.
+
+> **NOTE:**
+>
+> NGX logging gets redirected to SL so NGX log files will NOT be generated.
+>
+> Logging overrides set via this JSON configuration will override any Streamline registry or environment variable logging overrides that are currently set.
+
+## How to override feature allow list
+
+Place the `sl.interposer.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"loadAllFeatures": true,
+	"loadSpecificFeatures": [0,1],
+}
+```
+
+> **NOTE:**
+> This entry tells the interposer to load all features or a specific subset using the unique Ids from `sl.h`. `loadAllFeatures` supersedes `loadSpecificFeatures` if set to true.
+
+## How to override existing or add new hot-keys
+
+Place the `sl.common.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"keys": [
+		{
+			"alt": false,
+			"ctrl": true,
+			"shift": true,
+			"key": 36,
+			"id": "stats"
+		},
+		{
+			"alt": false,
+			"ctrl": true,
+			"shift": true,
+			"key": 45,
+			"id": "debug"
+		}
+	]
+}
+```
+
+Note that `"key"` lines specify the *decimal* number of the Windows Virtual Key Code (`VK_*`) for the desired key.
+
+## How to override DLSS-G settings
+
+Place the `sl.dlss_g.json` file (located in `./scripts/`) in the game's working directory. Edit the following line(s):
+
+```json
+{
+	"_comment_compute" : "use compute queue or not, if game crashes set this back to false since some drivers might be buggy",
+	"useCompute": true,
+	"_comment_frames" : "optimal defaults - 1 @4K, 2 @1440p, 3 @1080p",
+	"numFramesToGenerate":  1,
+	"_comment_mode" : "possible modes cur, prev, auto - async flush current or previous frame or decide automatically",
+	"mode" : "auto",
+	"showDebugText" : true
+}
+```
+