From 887dd07ac772598b936ceead1f69adae8b788d58 Mon Sep 17 00:00:00 2001 From: cdozdil Date: Sun, 2 Jun 2024 19:05:07 +0300 Subject: [PATCH 1/4] adding params objects --- OptiScaler/NVNGX_DLSS_Dx12.cpp | 19 ++ OptiScaler/NVNGX_Parameter.h | 13 ++ OptiScaler/OptiScaler.vcxproj | 5 +- OptiScaler/OptiScaler.vcxproj.filters | 9 + OptiScaler/backends/IFeatureCreateParams.h | 54 +++++ .../backends/IFeatureCreateParams_DLSS.h | 194 ++++++++++++++++++ OptiScaler/backends/IFeatureEvaluateParams.h | 12 ++ .../backends/fsr2_212/FSR2Feature_Vk_212.cpp | 2 +- 8 files changed, 306 insertions(+), 2 deletions(-) create mode 100644 OptiScaler/backends/IFeatureCreateParams.h create mode 100644 OptiScaler/backends/IFeatureCreateParams_DLSS.h create mode 100644 OptiScaler/backends/IFeatureEvaluateParams.h diff --git a/OptiScaler/NVNGX_DLSS_Dx12.cpp b/OptiScaler/NVNGX_DLSS_Dx12.cpp index cc6afaa5..3053a5af 100644 --- a/OptiScaler/NVNGX_DLSS_Dx12.cpp +++ b/OptiScaler/NVNGX_DLSS_Dx12.cpp @@ -15,6 +15,8 @@ inline ID3D12Device* D3D12Device = nullptr; static inline ankerl::unordered_dense::map > Dx12Contexts; +static inline NVNGX_Init_Info NVNGXInitInfo = {}; + static inline NVSDK_NGX_Parameter* createParams = nullptr; static inline int changeBackendCounter = 0; static inline std::wstring appDataPath = L"."; @@ -161,6 +163,11 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Init_Ext(unsigned long long InApp Config::Instance()->NVNGX_Version = InSDKVersion; Config::Instance()->NVNGX_FeatureInfo = InFeatureInfo; + NVNGXInitInfo.ApplicationId = InApplicationId; + NVNGXInitInfo.ApplicationDataPath = std::wstring(InApplicationDataPath); + NVNGXInitInfo.Version = InSDKVersion; + NVNGXInitInfo.FeatureCommonInfo = InFeatureInfo; + if (InFeatureInfo != nullptr && InSDKVersion > 0x0000013) Config::Instance()->NVNGX_Logger = InFeatureInfo->LoggingInfo; @@ -171,6 +178,7 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Init_Ext(unsigned long long InApp spdlog::info("NVSDK_NGX_D3D12_Init_Ext InApplicationDataPath {0}", str); Config::Instance()->NVNGX_FeatureInfo_Paths.clear(); + NVNGXInitInfo.FeatureInfoPaths.clear(); if (InFeatureInfo != nullptr) { @@ -179,6 +187,7 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Init_Ext(unsigned long long InApp const wchar_t* path = InFeatureInfo->PathListInfo.Path[i]; Config::Instance()->NVNGX_FeatureInfo_Paths.push_back(std::wstring(path)); + NVNGXInitInfo.FeatureInfoPaths.push_back(std::wstring(path)); std::wstring iniPathW(path); std::string iniPath(iniPathW.begin(), iniPathW.end()); @@ -221,6 +230,10 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Init_ProjectID(const char* InProj Config::Instance()->NVNGX_Engine = InEngineType; Config::Instance()->NVNGX_EngineVersion = std::string(InEngineVersion); + NVNGXInitInfo.ProjectId = std::string(InProjectId); + NVNGXInitInfo.Engine = InEngineType; + NVNGXInitInfo.EngineVersion = std::string(InEngineVersion); + if (Config::Instance()->NVNGX_Engine == NVSDK_NGX_ENGINE_TYPE_UNREAL && InEngineVersion) Config::Instance()->NVNGX_EngineVersion5 = InEngineVersion[0] == '5'; else @@ -234,6 +247,8 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Init_with_ProjectID(const char* I { auto result = NVSDK_NGX_D3D12_Init_Ext(0x1337, InApplicationDataPath, InDevice, InSDKVersion, InFeatureInfo); + + spdlog::info("NVSDK_NGX_D3D12_Init_with_ProjectID InProjectId: {0}", InProjectId); spdlog::info("NVSDK_NGX_D3D12_Init_with_ProjectID InEngineType: {0}", (int)InEngineType); spdlog::info("NVSDK_NGX_D3D12_Init_with_ProjectID InEngineVersion: {0}", InEngineVersion); @@ -242,6 +257,10 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Init_with_ProjectID(const char* I Config::Instance()->NVNGX_Engine = InEngineType; Config::Instance()->NVNGX_EngineVersion = std::string(InEngineVersion); + NVNGXInitInfo.ProjectId = std::string(InProjectId); + NVNGXInitInfo.Engine = InEngineType; + NVNGXInitInfo.EngineVersion = std::string(InEngineVersion); + if (Config::Instance()->NVNGX_Engine == NVSDK_NGX_ENGINE_TYPE_UNREAL && InEngineVersion) Config::Instance()->NVNGX_EngineVersion5 = InEngineVersion[0] == '5'; else diff --git a/OptiScaler/NVNGX_Parameter.h b/OptiScaler/NVNGX_Parameter.h index e357e787..d0eb66df 100644 --- a/OptiScaler/NVNGX_Parameter.h +++ b/OptiScaler/NVNGX_Parameter.h @@ -3,6 +3,19 @@ #include #include "Config.h" +struct NVNGX_Init_Info +{ + unsigned long long ApplicationId; + std::wstring ApplicationDataPath= L""; + std::string ProjectId = ""; + NVSDK_NGX_Version Version{}; + const NVSDK_NGX_FeatureCommonInfo* FeatureCommonInfo = nullptr; + std::vector FeatureInfoPaths; + NVSDK_NGX_LoggingInfo Logger{ nullptr, NVSDK_NGX_LOGGING_LEVEL_OFF, false }; + NVSDK_NGX_EngineType Engine = NVSDK_NGX_ENGINE_TYPE_CUSTOM; + std::string EngineVersion; +}; + inline std::optional GetQualityOverrideRatio(const NVSDK_NGX_PerfQuality_Value input) { std::optional output; diff --git a/OptiScaler/OptiScaler.vcxproj b/OptiScaler/OptiScaler.vcxproj index 8d2cc118..39a25e0b 100644 --- a/OptiScaler/OptiScaler.vcxproj +++ b/OptiScaler/OptiScaler.vcxproj @@ -82,7 +82,7 @@ $(SolutionDir)external\vulkan\include;$(SolutionDir)external\nvngx_dlss_sdk;$(SolutionDir)external\xess\inc\xess;$(SolutionDir)external\simpleini;$(SolutionDir)external\unordered_dense\include;$(SolutionDir)external\spdlog\include;$(IncludePath) $(ProjectDir)fsr2\lib;$(ProjectDir)fsr2_212\lib;$(ProjectDir)vulkan;$(ProjectDir)d3dx;$(ProjectDir)detours;$(SolutionDir)external\xess\lib;$(LibraryPath) dlss-enabler-upscaler - D:\Folders\Games\Banishers Ghosts of New Eden\NWD\Binaries\Win64\ + D:\Folders\Games\SteamLibrary\steamapps\common\Ghost of Tsushima DIRECTOR%27S CUT\ .\x64\Debug @@ -192,6 +192,9 @@ copy $(SolutionDir)nvngx.ini $(SolutionDir)x64\Release\a\ + + + diff --git a/OptiScaler/OptiScaler.vcxproj.filters b/OptiScaler/OptiScaler.vcxproj.filters index d5971729..eb93134d 100644 --- a/OptiScaler/OptiScaler.vcxproj.filters +++ b/OptiScaler/OptiScaler.vcxproj.filters @@ -179,6 +179,15 @@ Header Files + + Header Files + + + Header Files + + + Header Files + diff --git a/OptiScaler/backends/IFeatureCreateParams.h b/OptiScaler/backends/IFeatureCreateParams.h new file mode 100644 index 00000000..992d81ac --- /dev/null +++ b/OptiScaler/backends/IFeatureCreateParams.h @@ -0,0 +1,54 @@ +#pragma once +#include "../pch.h" + +enum CommonQualityPreset +{ + NativeAA, + UltraQuality, + Quality, + Balanced, + Performance, + UltraPerformance, + Undefined +}; + +class IFeatureCreateParams +{ +protected: + bool _isInited = false; + + uint32_t _renderWidth; + uint32_t _renderHeight; + uint32_t _displayWidth; + uint32_t _displayHeight; + uint32_t _targetWidth; + uint32_t _targetHeight; + + CommonQualityPreset _pqValue = Undefined; + + bool _autoExposure = false; + bool _hdr = false; + bool _sharpening = false; + bool _disableReactiveMask = false; + bool _jitterCancellation = false; + bool _displayResMV = false; + bool _depthInverted = false; + +public: + bool IsInited() { return _isInited; } + uint32_t RenderWidth() { return _renderWidth; } + uint32_t RenderHeight() { return _renderHeight; } + uint32_t DisplayWidth() { return _displayWidth; } + uint32_t DisplayHeight() { return _displayHeight; } + uint32_t TargetWidth() { return _targetWidth; } + uint32_t TargetHeight() { return _targetHeight; } + CommonQualityPreset QualityPreset() { return _pqValue; } + bool AutoExposure() { return _autoExposure; } + bool Hdr() { return _hdr; } + bool Sharpening() { return _sharpening; } + bool DisableReactiveMask() { return _disableReactiveMask; } + bool JitterCancellation() { return _jitterCancellation; } + bool DisplayResolutionMV() { return _displayResMV; } + bool DepthInverted() { return _depthInverted; } + +}; \ No newline at end of file diff --git a/OptiScaler/backends/IFeatureCreateParams_DLSS.h b/OptiScaler/backends/IFeatureCreateParams_DLSS.h new file mode 100644 index 00000000..5fd556ab --- /dev/null +++ b/OptiScaler/backends/IFeatureCreateParams_DLSS.h @@ -0,0 +1,194 @@ +#pragma once + +#include "IFeatureCreateParams.h" + +#include "../Config.h" +#include "../NVNGX_Parameter.h" + + +class IFeatureCreateParams_DLSS : public IFeatureCreateParams +{ +private: + const NVNGX_Init_Info _initInfo; + + inline static CommonQualityPreset GetQualityPreset(int pqValue) + { + CommonQualityPreset result = Undefined; + + switch (pqValue) + { + case 0: // NVSDK_NGX_PerfQuality_Value_MaxPerf, + result = Performance; + break; + + case 1: // NVSDK_NGX_PerfQuality_Value_Balanced, + result = Balanced; + break; + + case 2: // NVSDK_NGX_PerfQuality_Value_MaxQuality, + result = Quality; + break; + + case 3: // NVSDK_NGX_PerfQuality_Value_UltraPerformance, + result = UltraPerformance; + break; + + case 4: // NVSDK_NGX_PerfQuality_Value_UltraQuality, + result = UltraQuality; + break; + + case 5: // NVSDK_NGX_PerfQuality_Value_DLAA, + result = NativeAA; + break; + + } + + return result; + } + +public: + IFeatureCreateParams_DLSS(const NVSDK_NGX_Parameter* InParameters, const NVNGX_Init_Info InInitInfo) : _initInfo(InInitInfo) + { + if (InParameters == nullptr) + return; + + NVSDK_NGX_Result result; + + unsigned int width = 0; + unsigned int outWidth = 0; + unsigned int height = 0; + unsigned int outHeight = 0; + int pqValue = 1; + + // Resolutions + if (InParameters->Get(NVSDK_NGX_Parameter_Width, &width) == NVSDK_NGX_Result_Success && + InParameters->Get(NVSDK_NGX_Parameter_Height, &height) == NVSDK_NGX_Result_Success && + InParameters->Get(NVSDK_NGX_Parameter_OutWidth, &outWidth) == NVSDK_NGX_Result_Success && + InParameters->Get(NVSDK_NGX_Parameter_OutHeight, &outHeight) == NVSDK_NGX_Result_Success) + { + // Thanks to Crytek added these checks + if (width > 16384 || width < 0) + width = 0; + + if (height > 16384 || height < 0) + height = 0; + + if (outWidth > 16384 || outWidth < 0) + outWidth = 0; + + if (outHeight > 16384 || outHeight < 0) + outHeight = 0; + + if (pqValue > 5 || pqValue < 0) + pqValue = 1; + + _displayWidth = width > outWidth ? width : outWidth; + _displayHeight = height > outHeight ? height : outHeight; + _targetWidth = _displayWidth; + _targetHeight = _displayHeight; + + if (InParameters->Get(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width, &_renderWidth) != NVSDK_NGX_Result_Success || + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, &_renderHeight) != NVSDK_NGX_Result_Success) + { + _renderWidth = width < outWidth ? width : outWidth; + _renderHeight = height < outHeight ? height : outHeight; + } + + _pqValue = GetQualityPreset(pqValue); + + spdlog::info("IFeatureContext::SetInitParameters Render Resolution: {0}x{1}, Display Resolution {2}x{3}, Quality: {4}", + _renderWidth, _renderHeight, _displayWidth, _displayHeight, pqValue); + } + else + { + spdlog::error("IFeatureCreateParams_DLSS::IFeatureCreateParams_DLSS Can't get resolution info from parameters!"); + return; + } + + // Quality + result = InParameters->Get(NVSDK_NGX_Parameter_PerfQualityValue, &pqValue); + + if(result != NVSDK_NGX_Result_Success) + spdlog::warn("IFeatureCreateParams_DLSS::IFeatureCreateParams_DLSS Can't get quality profile from parameters!"); + + _pqValue = GetQualityPreset(pqValue); + + // Init flags + unsigned int createFlags = 0; + if (InParameters->Get(NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, &createFlags) != NVSDK_NGX_Result_Success) + { + spdlog::error("IFeatureCreateParams_DLSS::IFeatureCreateParams_DLSS Can't get create flags from parameters!"); + return; + } + + _hdr = (createFlags & NVSDK_NGX_DLSS_Feature_Flags_IsHDR); + _displayResMV = !(createFlags & NVSDK_NGX_DLSS_Feature_Flags_MVLowRes); + _jitterCancellation = (createFlags & NVSDK_NGX_DLSS_Feature_Flags_MVJittered); + _depthInverted = (createFlags & NVSDK_NGX_DLSS_Feature_Flags_DepthInverted); + _sharpening = (createFlags & NVSDK_NGX_DLSS_Feature_Flags_DoSharpening); + _autoExposure = (createFlags & NVSDK_NGX_DLSS_Feature_Flags_AutoExposure); + + // Output scaling + if (Config::Instance()->OutputScalingEnabled.value_or(false) && !Config::Instance()->DisplayResolution.value_or(_displayResMV)) + { + float ssMulti = Config::Instance()->OutputScalingMultiplier.value_or(1.5f); + + if (ssMulti < 0.5f) + { + ssMulti = 0.5f; + Config::Instance()->OutputScalingMultiplier = ssMulti; + } + else if (ssMulti > 3.0f) + { + ssMulti = 3.0f; + Config::Instance()->OutputScalingMultiplier = ssMulti; + } + + _targetWidth = _displayWidth * ssMulti; + _targetHeight = _displayHeight * ssMulti; + } + else + { + _targetWidth = _displayWidth; + _targetHeight = _displayHeight; + } + + // dlss presets + unsigned int RenderPresetDLAA = 0; + unsigned int RenderPresetUltraQuality = 0; + unsigned int RenderPresetQuality = 0; + unsigned int RenderPresetBalanced = 0; + unsigned int RenderPresetPerformance = 0; + unsigned int RenderPresetUltraPerformance = 0; + + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_DLAA, &RenderPresetDLAA); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraQuality, &RenderPresetUltraQuality); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Quality, &RenderPresetQuality); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Balanced, &RenderPresetBalanced); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Performance, &RenderPresetPerformance); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraPerformance, &RenderPresetUltraPerformance); + + if (Config::Instance()->RenderPresetOverride.value_or(false)) + { + Config::Instance()->RenderPresetDLAA = Config::Instance()->RenderPresetDLAA.value_or(RenderPresetDLAA); + Config::Instance()->RenderPresetUltraQuality = Config::Instance()->RenderPresetUltraQuality.value_or(RenderPresetUltraQuality); + Config::Instance()->RenderPresetQuality = Config::Instance()->RenderPresetQuality.value_or(RenderPresetQuality); + Config::Instance()->RenderPresetBalanced = Config::Instance()->RenderPresetBalanced.value_or(RenderPresetBalanced); + Config::Instance()->RenderPresetPerformance = Config::Instance()->RenderPresetPerformance.value_or(RenderPresetPerformance); + Config::Instance()->RenderPresetUltraPerformance = Config::Instance()->RenderPresetUltraPerformance.value_or(RenderPresetUltraPerformance); + } + else + { + Config::Instance()->RenderPresetDLAA = RenderPresetDLAA; + Config::Instance()->RenderPresetUltraQuality = RenderPresetUltraQuality; + Config::Instance()->RenderPresetQuality = RenderPresetQuality; + Config::Instance()->RenderPresetBalanced = RenderPresetBalanced; + Config::Instance()->RenderPresetPerformance = RenderPresetPerformance; + Config::Instance()->RenderPresetUltraPerformance = RenderPresetUltraPerformance; + } + + _isInited = true; + } + + NVNGX_Init_Info InitInfo() { return _initInfo; } +}; \ No newline at end of file diff --git a/OptiScaler/backends/IFeatureEvaluateParams.h b/OptiScaler/backends/IFeatureEvaluateParams.h new file mode 100644 index 00000000..178a9055 --- /dev/null +++ b/OptiScaler/backends/IFeatureEvaluateParams.h @@ -0,0 +1,12 @@ +#pragma once + +class IFeatureEvaluateParams +{ +private: + +protected: + +public: + + +}; diff --git a/OptiScaler/backends/fsr2_212/FSR2Feature_Vk_212.cpp b/OptiScaler/backends/fsr2_212/FSR2Feature_Vk_212.cpp index ae750431..ac8a6c6c 100644 --- a/OptiScaler/backends/fsr2_212/FSR2Feature_Vk_212.cpp +++ b/OptiScaler/backends/fsr2_212/FSR2Feature_Vk_212.cpp @@ -117,7 +117,7 @@ bool FSR2FeatureVk212::InitFSR2(const NVSDK_NGX_Parameter* InParameters) SetInit(true); return true; - } +} bool FSR2FeatureVk212::Init(VkInstance InInstance, VkPhysicalDevice InPD, VkDevice InDevice, VkCommandBuffer InCmdList, PFN_vkGetInstanceProcAddr InGIPA, PFN_vkGetDeviceProcAddr InGDPA, const NVSDK_NGX_Parameter* InParameters) { From 4194ad1e72dfaccbf7cdf9b887d37e126cab8fd6 Mon Sep 17 00:00:00 2001 From: cdozdil Date: Mon, 3 Jun 2024 00:02:25 +0300 Subject: [PATCH 2/4] unified infos --- OptiScaler/backends/IFeatureCreateParams.h | 4 +- OptiScaler/backends/IFeatureEvaluateParams.h | 78 ++++++++++++++++ .../backends/IFeatureEvaluateParams_DLSS.h | 93 +++++++++++++++++++ 3 files changed, 174 insertions(+), 1 deletion(-) create mode 100644 OptiScaler/backends/IFeatureEvaluateParams_DLSS.h diff --git a/OptiScaler/backends/IFeatureCreateParams.h b/OptiScaler/backends/IFeatureCreateParams.h index 992d81ac..f01868e0 100644 --- a/OptiScaler/backends/IFeatureCreateParams.h +++ b/OptiScaler/backends/IFeatureCreateParams.h @@ -36,13 +36,16 @@ protected: public: bool IsInited() { return _isInited; } + uint32_t RenderWidth() { return _renderWidth; } uint32_t RenderHeight() { return _renderHeight; } uint32_t DisplayWidth() { return _displayWidth; } uint32_t DisplayHeight() { return _displayHeight; } uint32_t TargetWidth() { return _targetWidth; } uint32_t TargetHeight() { return _targetHeight; } + CommonQualityPreset QualityPreset() { return _pqValue; } + bool AutoExposure() { return _autoExposure; } bool Hdr() { return _hdr; } bool Sharpening() { return _sharpening; } @@ -50,5 +53,4 @@ public: bool JitterCancellation() { return _jitterCancellation; } bool DisplayResolutionMV() { return _displayResMV; } bool DepthInverted() { return _depthInverted; } - }; \ No newline at end of file diff --git a/OptiScaler/backends/IFeatureEvaluateParams.h b/OptiScaler/backends/IFeatureEvaluateParams.h index 178a9055..e088fa81 100644 --- a/OptiScaler/backends/IFeatureEvaluateParams.h +++ b/OptiScaler/backends/IFeatureEvaluateParams.h @@ -1,12 +1,90 @@ #pragma once +#include "../pch.h" class IFeatureEvaluateParams { private: + inline static double _lastFrameTime = -1; + + inline static double MillisecondsNow() + { + LARGE_INTEGER s_frequency; + bool s_use_qpc = QueryPerformanceFrequency(&s_frequency); + double milliseconds = 0; + + if (s_use_qpc) + { + LARGE_INTEGER now; + QueryPerformanceCounter(&now); + milliseconds = double(1000.0 * now.QuadPart) / s_frequency.QuadPart; + } + else + { + milliseconds = double(GetTickCount64()); + } + + return milliseconds; + } protected: + bool _isInited = false; + + void* _inputColor = nullptr; + void* _inputDepth = nullptr; + void* _inputMotion = nullptr; + void* _inputExposure = nullptr; + void* _inputMask = nullptr; + void* _outputColor = nullptr; + + uint32_t _renderWidth = 0; + uint32_t _renderHeight = 0; + + float _jitterOffsetX = 0.0f; + float _jitterOffsetY = 0.0f; + + float _mvScaleX = 1.0f; + float _mvScaleY = 1.0f; + + float _sharpness = 0.0f; + float _exposureScale = 1.0f; + float _frameTimeDelta = 0.0f; + + bool _reset = false; public: + IFeatureEvaluateParams() + { + if (_lastFrameTime < 0) + { + _lastFrameTime = MillisecondsNow(); + } + else + { + double currentTime = MillisecondsNow(); + _frameTimeDelta = currentTime - _lastFrameTime; + _lastFrameTime = currentTime; + } + } + bool IsInited() const { return _isInited; } + void* InputColor() const { return _inputColor; } + void* InputDepth() const { return _inputDepth; } + void* InputMotion() const { return _inputMotion; } + void* InputExposure() const { return _inputExposure; } + void* InputMask() const { return _inputMask; } + void* OutputColor() const { return _outputColor; } + + uint32_t RenderWidth() const { return _renderWidth; } + uint32_t RenderHeight() const { return _renderHeight; } + + float JitterOffsetX() const { return _jitterOffsetX; } + float JitterOffsetY() const { return _jitterOffsetY; } + float MvScaleX() const { return _mvScaleX; } + float MvScaleY() const { return _mvScaleY; } + float Sharpness() const { return _sharpness; } + float ExposureScale() const { return _exposureScale; } + float FrameTimeDelta() const { return _frameTimeDelta; } + + bool Reset() const { return _reset; } }; diff --git a/OptiScaler/backends/IFeatureEvaluateParams_DLSS.h b/OptiScaler/backends/IFeatureEvaluateParams_DLSS.h new file mode 100644 index 00000000..6319fabd --- /dev/null +++ b/OptiScaler/backends/IFeatureEvaluateParams_DLSS.h @@ -0,0 +1,93 @@ +#pragma once + +#include "IFeatureEvaluateParams.h" + +class IFeatureEvaluateParams_DLSS : public IFeatureEvaluateParams +{ +private: + void GetRenderResolution(const NVSDK_NGX_Parameter* InParameters) + { + uint32_t OutWidth; + uint32_t OutHeight; + + if (InParameters->Get(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width, &OutWidth) != NVSDK_NGX_Result_Success || + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, &OutHeight) != NVSDK_NGX_Result_Success) + { + unsigned int width; + unsigned int height; + unsigned int outWidth; + unsigned int outHeight; + + do + { + if (InParameters->Get(NVSDK_NGX_Parameter_Width, &width) == NVSDK_NGX_Result_Success && + InParameters->Get(NVSDK_NGX_Parameter_Height, &height) == NVSDK_NGX_Result_Success) + { + if (InParameters->Get(NVSDK_NGX_Parameter_OutWidth, &outWidth) == NVSDK_NGX_Result_Success && + InParameters->Get(NVSDK_NGX_Parameter_OutHeight, &outHeight) == NVSDK_NGX_Result_Success) + { + if (width < outWidth) + { + OutWidth = width; + OutHeight = height; + break; + } + + OutWidth = outWidth; + OutHeight = outHeight; + } + else + { + if (width < RenderWidth()) + { + OutWidth = width; + OutHeight = height; + break; + } + + OutWidth = -1; + OutHeight = -1; + return; + } + } + + OutWidth = -1; + OutHeight = -1; + + } while (false); + } + + _renderWidth = OutWidth; + _renderHeight = OutHeight; + } + +public: + IFeatureEvaluateParams_DLSS(const NVSDK_NGX_Parameter* InParameters) : IFeatureEvaluateParams() + { + InParameters->Get(NVSDK_NGX_Parameter_Jitter_Offset_X, &_jitterOffsetX); + InParameters->Get(NVSDK_NGX_Parameter_Jitter_Offset_Y, &_jitterOffsetY); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Exposure_Scale, &_exposureScale); + + int reset = 0; + InParameters->Get(NVSDK_NGX_Parameter_Reset, &reset); + _reset = reset != 0; + + InParameters->Get(NVSDK_NGX_Parameter_Color, &_inputColor); + InParameters->Get(NVSDK_NGX_Parameter_MotionVectors, &_inputMotion); + InParameters->Get(NVSDK_NGX_Parameter_Depth, &_inputDepth); + InParameters->Get(NVSDK_NGX_Parameter_ExposureTexture, &_inputExposure); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, &_inputMask); + InParameters->Get(NVSDK_NGX_Parameter_Output, &_outputColor); + + InParameters->Get(NVSDK_NGX_Parameter_MV_Scale_X, &_mvScaleX); + InParameters->Get(NVSDK_NGX_Parameter_MV_Scale_Y, &_mvScaleY); + + float ftDelta = 0.0f; + if (InParameters->Get(NVSDK_NGX_Parameter_FrameTimeDeltaInMsec, &ftDelta) == NVSDK_NGX_Result_Success || ftDelta > 1.0f) + _frameTimeDelta = ftDelta; + + InParameters->Get(NVSDK_NGX_Parameter_Sharpness, &_sharpness); + + GetRenderResolution(InParameters); + } +}; \ No newline at end of file From 0e108da2053c06de487c0e3a50a8de9bc6c3e919 Mon Sep 17 00:00:00 2001 From: cdozdil Date: Mon, 3 Jun 2024 00:02:50 +0300 Subject: [PATCH 3/4] implementation fiddleing --- OptiScaler/backends/IFeature.h | 5 + OptiScaler/backends/IFeature_Dx12.cpp | 276 ++++++++++++++++++ OptiScaler/backends/IFeature_Dx12.h | 7 +- OptiScaler/backends/xess/XeSSFeature_Dx12.cpp | 96 +++++- OptiScaler/backends/xess/XeSSFeature_Dx12.h | 2 + 5 files changed, 383 insertions(+), 3 deletions(-) diff --git a/OptiScaler/backends/IFeature.h b/OptiScaler/backends/IFeature.h index 377b6b9a..c7f94071 100644 --- a/OptiScaler/backends/IFeature.h +++ b/OptiScaler/backends/IFeature.h @@ -1,4 +1,8 @@ #pragma once +#include "IFeatureCreateParams.h" +#include "IFeatureEvaluateParams.h" + + #include #include @@ -16,6 +20,7 @@ private: protected: NVSDK_NGX_Handle* _handle = nullptr; + IFeatureCreateParams _createParams = {}; float _sharpness = 0; bool _hasColor = false; diff --git a/OptiScaler/backends/IFeature_Dx12.cpp b/OptiScaler/backends/IFeature_Dx12.cpp index 73de8541..b71a6e62 100644 --- a/OptiScaler/backends/IFeature_Dx12.cpp +++ b/OptiScaler/backends/IFeature_Dx12.cpp @@ -2,6 +2,7 @@ #include "IFeature_Dx12.h" #include "../pch.h" + void IFeature_Dx12::ResourceBarrier(ID3D12GraphicsCommandList* InCommandList, ID3D12Resource* InResource, D3D12_RESOURCE_STATES InBeforeState, D3D12_RESOURCE_STATES InAfterState) const { D3D12_RESOURCE_BARRIER barrier = {}; @@ -13,6 +14,281 @@ void IFeature_Dx12::ResourceBarrier(ID3D12GraphicsCommandList* InCommandList, ID InCommandList->ResourceBarrier(1, &barrier); } +bool IFeature_Dx12::BeforeEvaluate(ID3D12GraphicsCommandList* InCommandList, const IFeatureEvaluateParams* InParams, ID3D12Resource* OutputTexture) +{ + auto useOutputScaling = Config::Instance()->OutputScalingEnabled.value_or(false) && !Config::Instance()->DisplayResolution.value_or(_createParams.DisplayResolutionMV()); + auto outputScalingMultiplier = Config::Instance()->OutputScalingMultiplier.value_or(1.5f); + + auto paramColor = (ID3D12Resource*)InParams->InputColor(); + auto paramMotion = (ID3D12Resource*)InParams->InputMotion(); + auto paramOutput = (ID3D12Resource*)InParams->OutputColor(); + auto paramDepth = (ID3D12Resource*)InParams->InputDepth(); + auto paramExposure = (ID3D12Resource*)InParams->InputExposure(); + auto paramMask = (ID3D12Resource*)InParams->InputMask(); + + // Color + if (paramColor) + { + spdlog::debug("IFeature_Dx12::BeforeEvaluate Color exist.."); + paramColor->SetName(L"paramColor"); + + if (Config::Instance()->ColorResourceBarrier.has_value()) + { + ResourceBarrier(InCommandList, paramColor, (D3D12_RESOURCE_STATES)Config::Instance()->ColorResourceBarrier.value(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + } + else if (Config::Instance()->NVNGX_Engine == NVSDK_NGX_ENGINE_TYPE_UNREAL) + { + Config::Instance()->ColorResourceBarrier = (int)D3D12_RESOURCE_STATE_RENDER_TARGET; + ResourceBarrier(InCommandList, paramColor, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + } + } + else + { + spdlog::error("IFeature_Dx12::BeforeEvaluate Color not exist!!"); + return false; + } + + // Motion + if (paramMotion) + { + spdlog::debug("IFeature_Dx12::BeforeEvaluate MotionVectors exist.."); + paramMotion->SetName(L"paramMotion"); + + if (Config::Instance()->MVResourceBarrier.has_value()) + { + ResourceBarrier(InCommandList, paramMotion, (D3D12_RESOURCE_STATES)Config::Instance()->MVResourceBarrier.value(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + } + else if (Config::Instance()->NVNGX_Engine == NVSDK_NGX_ENGINE_TYPE_UNREAL) + { + Config::Instance()->MVResourceBarrier = (int)D3D12_RESOURCE_STATE_UNORDERED_ACCESS; + ResourceBarrier(InCommandList, paramMotion, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + } + } + else + { + spdlog::error("IFeature_Dx12::BeforeEvaluate MotionVectors not exist!!"); + return false; + } + + // Output + if (paramOutput) + { + spdlog::debug("IFeature_Dx12::BeforeEvaluate Output exist.."); + paramOutput->SetName(L"paramOutput"); + + if (Config::Instance()->OutputResourceBarrier.has_value()) + { + ResourceBarrier(InCommandList, paramOutput, (D3D12_RESOURCE_STATES)Config::Instance()->OutputResourceBarrier.value(), D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + } + + if (useOutputScaling) + { + if (OutputScaler->CreateBufferResource(Device, paramOutput, TargetWidth(), TargetHeight(), D3D12_RESOURCE_STATE_UNORDERED_ACCESS)) + { + OutputScaler->SetBufferState(InCommandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + OutputTexture = OutputScaler->Buffer(); + } + else + OutputTexture = paramOutput; + } + else + OutputTexture = paramOutput; + + if (Config::Instance()->RcasEnabled.value_or(true) && + (InParams->Sharpness() > 0.0f || (Config::Instance()->MotionSharpnessEnabled.value_or(false) && Config::Instance()->MotionSharpness.value_or(0.4) > 0.0f)) && + RCAS->IsInit() && RCAS->CreateBufferResource(Device, OutputTexture, D3D12_RESOURCE_STATE_UNORDERED_ACCESS)) + { + RCAS->SetBufferState(InCommandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + OutputTexture = RCAS->Buffer(); + } + } + else + { + spdlog::error("IFeature_Dx12::BeforeEvaluate Output not exist!!"); + return false; + } + + // Depth + if (paramDepth) + { + spdlog::debug("IFeature_Dx12::BeforeEvaluate Depth exist.."); + paramDepth->SetName(L"params.pDepthTexture"); + + if (Config::Instance()->DepthResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramDepth, (D3D12_RESOURCE_STATES)Config::Instance()->DepthResourceBarrier.value(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + } + else + { + if (!Config::Instance()->DisplayResolution.value_or(false)) + spdlog::error("IFeature_Dx12::BeforeEvaluate Depth not exist!!"); + else + spdlog::info("IFeature_Dx12::BeforeEvaluate Using high res motion vectors, depth is not needed!!"); + } + + // Exposure + if (!Config::Instance()->AutoExposure.value_or(false)) + { + + if (paramExposure) + { + spdlog::debug("IFeature_Dx12::BeforeEvaluate ExposureTexture exist.."); + + if (Config::Instance()->ExposureResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramExposure, (D3D12_RESOURCE_STATES)Config::Instance()->ExposureResourceBarrier.value(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + } + else + { + spdlog::warn("IFeature_Dx12::BeforeEvaluate AutoExposure disabled but ExposureTexture is not exist, it may cause problems!!"); + Config::Instance()->AutoExposure = true; + Config::Instance()->changeBackend = true; + return true; + } + } + else + spdlog::debug("IFeature_Dx12::BeforeEvaluate AutoExposure enabled!"); + + // Mask + if (!Config::Instance()->DisableReactiveMask.value_or(true)) + { + if (paramMask) + { + spdlog::debug("IFeature_Dx12::BeforeEvaluate Bias mask exist.."); + + if (Config::Instance()->MaskResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramMask, (D3D12_RESOURCE_STATES)Config::Instance()->MaskResourceBarrier.value(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + } + else + { + spdlog::warn("IFeature_Dx12::BeforeEvaluate Bias mask not exist and its enabled in config, it may cause problems!!"); + Config::Instance()->DisableReactiveMask = true; + Config::Instance()->changeBackend = true; + return true; + } + } + + _hasColor = paramColor != nullptr; + _hasMV = paramMotion != nullptr; + _hasOutput = paramOutput != nullptr; + _hasDepth = paramDepth != nullptr; + _hasExposure = paramExposure != nullptr; + _hasTM = paramMask != nullptr; + + return true; +} + +void IFeature_Dx12::AfterEvaluate(ID3D12GraphicsCommandList* InCommandList, const IFeatureEvaluateParams* InParams, ID3D12Resource* OutputTexture) +{ + auto useOutputScaling = Config::Instance()->OutputScalingEnabled.value_or(false) && !Config::Instance()->DisplayResolution.value_or(_createParams.DisplayResolutionMV()); + + auto paramColor = (ID3D12Resource*)InParams->InputColor(); + auto paramMotion = (ID3D12Resource*)InParams->InputMotion(); + auto paramOutput = (ID3D12Resource*)InParams->OutputColor(); + auto paramDepth = (ID3D12Resource*)InParams->InputDepth(); + auto paramExposure = (ID3D12Resource*)InParams->InputExposure(); + auto paramMask = (ID3D12Resource*)InParams->InputMask(); + + // apply rcas + if (Config::Instance()->RcasEnabled.value_or(true) && + (InParams->Sharpness() > 0.0f || (Config::Instance()->MotionSharpnessEnabled.value_or(false) && Config::Instance()->MotionSharpness.value_or(0.4) > 0.0f)) && + RCAS->CanRender()) + { + if (OutputTexture != RCAS->Buffer()) + ResourceBarrier(InCommandList, OutputTexture, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + + RCAS->SetBufferState(InCommandList, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + + RcasConstants rcasConstants{}; + rcasConstants.Sharpness = InParams->Sharpness(); + rcasConstants.DisplayWidth = TargetWidth(); + rcasConstants.DisplayHeight = TargetHeight(); + rcasConstants.MvScaleX = InParams->MvScaleX(); + rcasConstants.MvScaleY = InParams->MvScaleY(); + rcasConstants.DisplaySizeMV = _createParams.DisplayResolutionMV(); + rcasConstants.RenderHeight = RenderHeight(); + rcasConstants.RenderWidth = RenderWidth(); + + if (useOutputScaling) + { + if (!RCAS->Dispatch(Device, InCommandList, OutputTexture, paramMotion, rcasConstants, OutputScaler->Buffer())) + { + Config::Instance()->RcasEnabled = false; + return; + } + } + else + { + if (!RCAS->Dispatch(Device, InCommandList, OutputTexture, paramMotion, rcasConstants, paramOutput)) + { + Config::Instance()->RcasEnabled = false; + return; + } + } + } + + if (useOutputScaling) + { + spdlog::debug("IFeature_Dx12::AfterEvaluate output scaling output..."); + OutputScaler->SetBufferState(InCommandList, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + + if (!OutputScaler->Dispatch(Device, InCommandList, OutputScaler->Buffer(), paramOutput)) + { + Config::Instance()->OutputScalingEnabled = false; + Config::Instance()->changeBackend = true; + return; + } + } + + // Imgui + if (!Config::Instance()->OverlayMenu.value_or(true) && _frameCount > 30) + { + if (Imgui != nullptr && Imgui.get() != nullptr) + { + if (Imgui->IsHandleDifferent()) + { + Imgui.reset(); + } + else + Imgui->Render(InCommandList, paramOutput); + } + else + { + if (Imgui == nullptr || Imgui.get() == nullptr) + Imgui = std::make_unique(GetForegroundWindow(), Device); + } + } + + // Restore resource states + if (paramColor && Config::Instance()->ColorResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramColor, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + (D3D12_RESOURCE_STATES)Config::Instance()->ColorResourceBarrier.value()); + + if (paramMotion && Config::Instance()->MVResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramMotion, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + (D3D12_RESOURCE_STATES)Config::Instance()->MVResourceBarrier.value()); + + if (paramOutput && Config::Instance()->OutputResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramOutput, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS, + (D3D12_RESOURCE_STATES)Config::Instance()->OutputResourceBarrier.value()); + + if (paramDepth && Config::Instance()->DepthResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramDepth, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + (D3D12_RESOURCE_STATES)Config::Instance()->DepthResourceBarrier.value()); + + if (paramExposure && Config::Instance()->ExposureResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramExposure, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + (D3D12_RESOURCE_STATES)Config::Instance()->ExposureResourceBarrier.value()); + + if (paramMask && Config::Instance()->MaskResourceBarrier.has_value()) + ResourceBarrier(InCommandList, paramMask, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + (D3D12_RESOURCE_STATES)Config::Instance()->MaskResourceBarrier.value()); +} + IFeature_Dx12::IFeature_Dx12(unsigned int InHandleId, const NVSDK_NGX_Parameter* InParameters) { } diff --git a/OptiScaler/backends/IFeature_Dx12.h b/OptiScaler/backends/IFeature_Dx12.h index df143bcd..c08874b6 100644 --- a/OptiScaler/backends/IFeature_Dx12.h +++ b/OptiScaler/backends/IFeature_Dx12.h @@ -13,16 +13,21 @@ class IFeature_Dx12 : public virtual IFeature { protected: ID3D12Device* Device = nullptr; + static inline std::unique_ptr Imgui = nullptr; std::unique_ptr OutputScaler = nullptr; - std::unique_ptr RCAS = nullptr; void ResourceBarrier(ID3D12GraphicsCommandList* InCommandList, ID3D12Resource* InResource, D3D12_RESOURCE_STATES InBeforeState, D3D12_RESOURCE_STATES InAfterState) const; public: virtual bool Init(ID3D12Device* InDevice, ID3D12GraphicsCommandList* InCommandList, const NVSDK_NGX_Parameter* InParameters) = 0; + virtual bool Init(ID3D12Device* InDevice, ID3D12GraphicsCommandList* InCommandList, const IFeatureCreateParams InParams) = 0; virtual bool Evaluate(ID3D12GraphicsCommandList* InCommandList, const NVSDK_NGX_Parameter* InParameters) = 0; + virtual bool Evaluate(ID3D12GraphicsCommandList* InCommandList, const IFeatureEvaluateParams* InParams) = 0; + + bool BeforeEvaluate(ID3D12GraphicsCommandList* InCommandList, const IFeatureEvaluateParams* InParams, ID3D12Resource* OutputTexture); + void AfterEvaluate(ID3D12GraphicsCommandList* InCommandList, const IFeatureEvaluateParams* InParams, ID3D12Resource* OutputTexture); IFeature_Dx12(unsigned int InHandleId, const NVSDK_NGX_Parameter* InParameters); diff --git a/OptiScaler/backends/xess/XeSSFeature_Dx12.cpp b/OptiScaler/backends/xess/XeSSFeature_Dx12.cpp index e2d5f410..1ca4599c 100644 --- a/OptiScaler/backends/xess/XeSSFeature_Dx12.cpp +++ b/OptiScaler/backends/xess/XeSSFeature_Dx12.cpp @@ -178,7 +178,7 @@ bool XeSSFeatureDx12::Evaluate(ID3D12GraphicsCommandList* InCommandList, const N else params.pOutputTexture = paramOutput; - if (Config::Instance()->RcasEnabled.value_or(true) && + if (Config::Instance()->RcasEnabled.value_or(true) && (sharpness > 0.0f || (Config::Instance()->MotionSharpnessEnabled.value_or(false) && Config::Instance()->MotionSharpness.value_or(0.4) > 0.0f)) && RCAS->IsInit() && RCAS->CreateBufferResource(Device, params.pOutputTexture, D3D12_RESOURCE_STATE_UNORDERED_ACCESS)) { @@ -291,7 +291,7 @@ bool XeSSFeatureDx12::Evaluate(ID3D12GraphicsCommandList* InCommandList, const N } // apply rcas - if (Config::Instance()->RcasEnabled.value_or(true) && + if (Config::Instance()->RcasEnabled.value_or(true) && (sharpness > 0.0f || (Config::Instance()->MotionSharpnessEnabled.value_or(false) && Config::Instance()->MotionSharpness.value_or(0.4) > 0.0f)) && RCAS->CanRender()) { @@ -397,6 +397,98 @@ bool XeSSFeatureDx12::Evaluate(ID3D12GraphicsCommandList* InCommandList, const N return true; } +bool XeSSFeatureDx12::Evaluate(ID3D12GraphicsCommandList* InCommandList, const IFeatureEvaluateParams* InParams) +{ + spdlog::debug("XeSSFeatureDx12::Evaluate"); + + if (!IsInited() || !_xessContext || !ModuleLoaded()) + { + spdlog::error("XeSSFeatureDx12::Evaluate Not inited!"); + return false; + } + + if (!RCAS->IsInit()) + Config::Instance()->RcasEnabled = false; + + if (!OutputScaler->IsInit()) + Config::Instance()->OutputScalingEnabled = false; + + if (Config::Instance()->xessDebug) + { + spdlog::error("XeSSFeatureDx12::Evaluate xessDebug"); + + xess_dump_parameters_t dumpParams{}; + dumpParams.frame_count = Config::Instance()->xessDebugFrames; + dumpParams.frame_idx = dumpCount; + dumpParams.path = "."; + dumpParams.dump_elements_mask = XESS_DUMP_INPUT_COLOR | XESS_DUMP_INPUT_VELOCITY | XESS_DUMP_INPUT_DEPTH | XESS_DUMP_OUTPUT | XESS_DUMP_EXECUTION_PARAMETERS | XESS_DUMP_HISTORY; + + if (!Config::Instance()->DisableReactiveMask.value_or(true)) + dumpParams.dump_elements_mask |= XESS_DUMP_INPUT_RESPONSIVE_PIXEL_MASK; + + StartDump()(_xessContext, &dumpParams); + Config::Instance()->xessDebug = false; + dumpCount += Config::Instance()->xessDebugFrames; + } + + xess_result_t xessResult; + xess_d3d12_execute_params_t params{}; + + params.jitterOffsetX = InParams->JitterOffsetX(); + params.jitterOffsetY = InParams->JitterOffsetY(); + params.exposureScale = InParams->ExposureScale(); + params.resetHistory = InParams->Reset() ? 1 : 0; + + if (InParams->RenderWidth() > 0) + params.inputWidth = InParams->RenderWidth(); + else + params.inputWidth = RenderWidth(); + + if (InParams->RenderHeight() > 0) + params.inputHeight = InParams->RenderHeight(); + else + params.inputHeight = RenderHeight(); + + spdlog::debug("XeSSFeatureDx12::Evaluate Input Resolution: {0}x{1}", params.inputWidth, params.inputHeight); + + auto sharpness = InParams->Sharpness(); + + auto beforeResult = BeforeEvaluate(InCommandList, InParams, params.pOutputTexture); + + // Autoexposure Reset + if (Config::Instance()->changeBackend) + return true; + + params.pColorTexture = (ID3D12Resource*)InParams->InputColor(); + params.pDepthTexture = (ID3D12Resource*)InParams->InputDepth(); + params.pExposureScaleTexture = (ID3D12Resource*)InParams->InputExposure(); + params.pVelocityTexture = (ID3D12Resource*)InParams->InputMotion(); + params.pResponsivePixelMaskTexture = (ID3D12Resource*)InParams->InputMask(); + + xessResult = SetVelocityScale()(_xessContext, InParams->MvScaleX(), InParams->MvScaleY()); + + if (xessResult != XESS_RESULT_SUCCESS) + { + spdlog::error("XeSSFeatureDx12::Evaluate xessSetVelocityScale: {0}", ResultToString(xessResult)); + return false; + } + + spdlog::debug("XeSSFeatureDx12::Evaluate Executing!!"); + xessResult = D3D12Execute()(_xessContext, InCommandList, ¶ms); + + if (xessResult != XESS_RESULT_SUCCESS) + { + spdlog::error("XeSSFeatureDx12::Evaluate xessD3D12Execute error: {0}", ResultToString(xessResult)); + return false; + } + + AfterEvaluate(InCommandList, InParams, params.pOutputTexture); + + _frameCount++; + + return true; +} + XeSSFeatureDx12::~XeSSFeatureDx12() { if (RCAS != nullptr && RCAS.get() != nullptr) diff --git a/OptiScaler/backends/xess/XeSSFeature_Dx12.h b/OptiScaler/backends/xess/XeSSFeature_Dx12.h index bb525a7c..6034bc6f 100644 --- a/OptiScaler/backends/xess/XeSSFeature_Dx12.h +++ b/OptiScaler/backends/xess/XeSSFeature_Dx12.h @@ -1,5 +1,6 @@ #pragma once #include "../IFeature_Dx12.h" +#include "../IFeatureCreateParams.h" #include "XeSSFeature.h" #include @@ -16,6 +17,7 @@ public: bool Init(ID3D12Device* InDevice, ID3D12GraphicsCommandList* InCommandList, const NVSDK_NGX_Parameter* InParameters) override; bool Evaluate(ID3D12GraphicsCommandList* InCommandList, const NVSDK_NGX_Parameter* InParameters) override; + bool Evaluate(ID3D12GraphicsCommandList* InCommandList, const IFeatureEvaluateParams* InParams) override; ~XeSSFeatureDx12(); }; \ No newline at end of file From f0da97cd0147a2b82d243f8f49850810a51bd33f Mon Sep 17 00:00:00 2001 From: cdozdil Date: Mon, 3 Jun 2024 00:02:59 +0300 Subject: [PATCH 4/4] new files --- OptiScaler/OptiScaler.vcxproj | 1 + 1 file changed, 1 insertion(+) diff --git a/OptiScaler/OptiScaler.vcxproj b/OptiScaler/OptiScaler.vcxproj index 39a25e0b..bc611838 100644 --- a/OptiScaler/OptiScaler.vcxproj +++ b/OptiScaler/OptiScaler.vcxproj @@ -209,6 +209,7 @@ copy $(SolutionDir)nvngx.ini $(SolutionDir)x64\Release\a\ +