From 07b21c75de1f00a04d02106f7b58bd6379646a2f Mon Sep 17 00:00:00 2001 From: cdozdil Date: Fri, 13 Nov 2026 11:37:44 +0300 Subject: [PATCH] Crop DLSS subrects on the Dx11 side of the Dx12 bridge and copy back only the view --- OptiScaler/OptiScaler.vcxproj | 3 + OptiScaler/OptiScaler.vcxproj.filters | 9 ++ OptiScaler/shaders/resource_copy/RC_Common.h | 57 +++++++ OptiScaler/shaders/resource_copy/RC_Dx11.cpp | 154 +++++++++++++++++++ OptiScaler/shaders/resource_copy/RC_Dx11.h | 36 +++++ OptiScaler/shaders/resource_copy/RC_Dx12.cpp | 54 +------ OptiScaler/upscalers/IFeature.cpp | 45 ++++-- OptiScaler/upscalers/IFeature.h | 19 +++ OptiScaler/upscalers/IFeature_Dx11.cpp | 33 ++++ OptiScaler/upscalers/IFeature_Dx11.h | 7 + OptiScaler/upscalers/IFeature_Dx11wDx12.cpp | 77 +++++++++- OptiScaler/upscalers/IFeature_Dx11wDx12.h | 2 +- OptiScaler/upscalers/IFeature_Dx12.cpp | 27 +--- OptiScaler/with_dx12/dx11_with_dx12.cpp | 12 +- OptiScaler/with_dx12/dx11_with_dx12.h | 4 +- 15 files changed, 444 insertions(+), 95 deletions(-) create mode 100644 OptiScaler/shaders/resource_copy/RC_Common.h create mode 100644 OptiScaler/shaders/resource_copy/RC_Dx11.cpp create mode 100644 OptiScaler/shaders/resource_copy/RC_Dx11.h diff --git a/OptiScaler/OptiScaler.vcxproj b/OptiScaler/OptiScaler.vcxproj index 8f068a7d..113e35ca 100644 --- a/OptiScaler/OptiScaler.vcxproj +++ b/OptiScaler/OptiScaler.vcxproj @@ -374,6 +374,8 @@ copy NUL "$(SolutionDir)x64\Release\a\!! EXTRACT ALL FILES TO GAME FOLDER !!" /Y + + @@ -678,6 +680,7 @@ copy NUL "$(SolutionDir)x64\Release\a\!! EXTRACT ALL FILES TO GAME FOLDER !!" /Y + diff --git a/OptiScaler/OptiScaler.vcxproj.filters b/OptiScaler/OptiScaler.vcxproj.filters index 4e3fb2b6..ff340171 100644 --- a/OptiScaler/OptiScaler.vcxproj.filters +++ b/OptiScaler/OptiScaler.vcxproj.filters @@ -725,6 +725,12 @@ Header Files + + Header Files + + + Header Files + Header Files @@ -1643,6 +1649,9 @@ Source Files + + Source Files + Source Files diff --git a/OptiScaler/shaders/resource_copy/RC_Common.h b/OptiScaler/shaders/resource_copy/RC_Common.h new file mode 100644 index 00000000..b97226f9 --- /dev/null +++ b/OptiScaler/shaders/resource_copy/RC_Common.h @@ -0,0 +1,57 @@ +#pragma once + +#include + +// DXGI formats for copying textures with the resource copy shaders +class RC_Formats +{ + public: + // Typeless formats TranslateTypelessFormats doesn't cover, R16 is D16 depth or the half float FFX assumes + static DXGI_FORMAT SrvFormat(DXGI_FORMAT format, bool depth) + { + switch (format) + { + case DXGI_FORMAT_R16_TYPELESS: + return depth ? DXGI_FORMAT_R16_UNORM : DXGI_FORMAT_R16_FLOAT; + + case DXGI_FORMAT_R8_TYPELESS: + return DXGI_FORMAT_R8_UNORM; + + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + return DXGI_FORMAT_B8G8R8X8_UNORM; + + default: + return DXGI_FORMAT_UNKNOWN; + } + } + + // The copy must be writable through a UAV and read back the same values + static DXGI_FORMAT BufferFormat(DXGI_FORMAT format, bool depth) + { + // Depth formats can't be UAVs, the shader reads the depth plane as float + if (depth) + return DXGI_FORMAT_R32_FLOAT; + + switch (format) + { + // sRGB can't be a UAV, the shader reads them decoded so keep the precision + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: + case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: + case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: + return DXGI_FORMAT_R16G16B16A16_FLOAT; + + // BGRA UAV stores are optional + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + case DXGI_FORMAT_B8G8R8X8_UNORM: + return DXGI_FORMAT_R8G8B8A8_UNORM; + + default: + if (auto srvFormat = SrvFormat(format, depth); srvFormat != DXGI_FORMAT_UNKNOWN) + return srvFormat; + + return format; + } + } +}; diff --git a/OptiScaler/shaders/resource_copy/RC_Dx11.cpp b/OptiScaler/shaders/resource_copy/RC_Dx11.cpp new file mode 100644 index 00000000..184f7dd9 --- /dev/null +++ b/OptiScaler/shaders/resource_copy/RC_Dx11.cpp @@ -0,0 +1,154 @@ +#include "pch.h" +#include "RC_Dx11.h" + +#include "RC_Common.h" +#include "precompile/rc_offset_Shader_Dx11.h" + +bool RC_Dx11::CreateBufferResource(ID3D11Device* InDevice, ID3D11Resource* InSource, uint32_t InWidth, + uint32_t InHeight) +{ + D3D11_TEXTURE2D_DESC current {}; + + if (_buffer != nullptr) + _buffer->GetDesc(¤t); + + return CreateBufferResourceCommon(InDevice, InSource, _buffer, + [&](D3D11_TEXTURE2D_DESC& desc) + { + desc.Format = RC_Formats::BufferFormat(desc.Format, _depth); + desc.Width = InWidth; + desc.Height = InHeight; + + if (_buffer != nullptr && current.Format == desc.Format) + { + desc.Width = std::max(desc.Width, current.Width); + desc.Height = std::max(desc.Height, current.Height); + } + + desc.MipLevels = 1; + desc.ArraySize = 1; + desc.SampleDesc = { 1, 0 }; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + }); +} + +bool RC_Dx11::InitializeViews(ID3D11Texture2D* InResource, ID3D11Texture2D* OutResource) +{ + if (InResource != _currentInResource || _srvInput == nullptr) + { + SAFE_RELEASE(_srvInput); + + D3D11_TEXTURE2D_DESC desc; + InResource->GetDesc(&desc); + + auto format = RC_Formats::SrvFormat(desc.Format, _depth); + + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; + srvDesc.Format = format != DXGI_FORMAT_UNKNOWN ? format : TranslateTypelessFormats(desc.Format); + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + srvDesc.Texture2D.MipLevels = 1; + + auto hr = _device->CreateShaderResourceView(InResource, &srvDesc, &_srvInput); + if (FAILED(hr)) + { + LOG_ERROR("[{0}] CreateShaderResourceView error {1:x}", _name, hr); + return false; + } + + _currentInResource = InResource; + } + + return InitializeUAV(OutResource, _currentOutResource, _uavOutput); +} + +bool RC_Dx11::Dispatch(ID3D11DeviceContext* InContext, ID3D11Texture2D* InResource, ID3D11Texture2D* OutResource, + uint32_t InSrcX, uint32_t InSrcY, uint32_t InDstX, uint32_t InDstY, uint32_t InWidth, + uint32_t InHeight) +{ + if (!_init || InContext == nullptr || InResource == nullptr || OutResource == nullptr) + return false; + + LOG_DEBUG("[{0}] Start!", _name); + + if (!InitializeViews(InResource, OutResource)) + return false; + + InternalConstants constants {}; + constants.SrcOffset[0] = InSrcX; + constants.SrcOffset[1] = InSrcY; + constants.DstOffset[0] = InDstX; + constants.DstOffset[1] = InDstY; + constants.Size[0] = InWidth; + constants.Size[1] = InHeight; + + D3D11_MAPPED_SUBRESOURCE mappedResource; + auto hr = InContext->Map(_constantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + if (FAILED(hr)) + { + if (hr == DXGI_ERROR_DEVICE_REMOVED && _device != nullptr) + Util::GetDeviceRemovedReason(_device); + + LOG_ERROR("[{0}] Map error {1:x}", _name, hr); + return false; + } + + memcpy(mappedResource.pData, &constants, sizeof(constants)); + InContext->Unmap(_constantBuffer, 0); + + InContext->CSSetShader(_computeShader, nullptr, 0); + InContext->CSSetConstantBuffers(0, 1, &_constantBuffer); + InContext->CSSetShaderResources(0, 1, &_srvInput); + InContext->CSSetUnorderedAccessViews(0, 1, &_uavOutput, nullptr); + + InContext->Dispatch((InWidth + InNumThreadsX - 1) / InNumThreadsX, (InHeight + InNumThreadsY - 1) / InNumThreadsY, + 1); + + // Unbind resources + ID3D11UnorderedAccessView* nullUAV = nullptr; + InContext->CSSetUnorderedAccessViews(0, 1, &nullUAV, nullptr); + ID3D11ShaderResourceView* nullSRV = nullptr; + InContext->CSSetShaderResources(0, 1, &nullSRV); + + return true; +} + +RC_Dx11::RC_Dx11(std::string InName, ID3D11Device* InDevice, bool InDepth) + : Shader_Dx11(InName, InDevice), _depth(InDepth) +{ + if (InDevice == nullptr) + { + LOG_ERROR("InDevice is nullptr!"); + return; + } + + LOG_DEBUG("{0} start!", _name); + + _device = InDevice; + + auto result = CreateComputeShader(InDevice, _computeShader, reinterpret_cast(rc_offset_cso), + sizeof(rc_offset_cso), nullptr); + + if (FAILED(result)) + { + LOG_ERROR("[{0}] CreateComputeShader error: {1:X}", _name, result); + return; + } + + D3D11_BUFFER_DESC cbDesc = {}; + cbDesc.Usage = D3D11_USAGE_DYNAMIC; + cbDesc.ByteWidth = sizeof(InternalConstants); + cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + + result = InDevice->CreateBuffer(&cbDesc, nullptr, &_constantBuffer); + if (result != S_OK) + { + LOG_ERROR("CreateBuffer error: {0:X}", (UINT) result); + return; + } + + _init = true; +} diff --git a/OptiScaler/shaders/resource_copy/RC_Dx11.h b/OptiScaler/shaders/resource_copy/RC_Dx11.h new file mode 100644 index 00000000..65b718df --- /dev/null +++ b/OptiScaler/shaders/resource_copy/RC_Dx11.h @@ -0,0 +1,36 @@ +#pragma once +#include "SysUtils.h" + +#include +#include + +// Copies a rectangle between textures through an SRV and a UAV, used to crop and place DLSS subrects +class RC_Dx11 : public Shader_Dx11 +{ + private: + struct alignas(256) InternalConstants + { + uint32_t SrcOffset[2]; + uint32_t DstOffset[2]; + uint32_t Size[2]; + }; + + uint32_t InNumThreadsX = 16; + uint32_t InNumThreadsY = 16; + bool _depth = false; + + bool InitializeViews(ID3D11Texture2D* InResource, ID3D11Texture2D* OutResource); + + public: + // Only grows, so dynamic resolution doesn't recreate it every frame + bool CreateBufferResource(ID3D11Device* InDevice, ID3D11Resource* InSource, uint32_t InWidth, uint32_t InHeight); + bool Dispatch(ID3D11DeviceContext* InContext, ID3D11Texture2D* InResource, ID3D11Texture2D* OutResource, + uint32_t InSrcX, uint32_t InSrcY, uint32_t InDstX, uint32_t InDstY, uint32_t InWidth, + uint32_t InHeight); + + // InDepth: the source is a depth buffer, read as depth and copied to R32_FLOAT + RC_Dx11(std::string InName, ID3D11Device* InDevice, bool InDepth = false); + + // Shader_Dx11 releases it but InitializeUAV never took a reference + ~RC_Dx11() { _currentOutResource = nullptr; } +}; diff --git a/OptiScaler/shaders/resource_copy/RC_Dx12.cpp b/OptiScaler/shaders/resource_copy/RC_Dx12.cpp index 65f9e9c6..633b321a 100644 --- a/OptiScaler/shaders/resource_copy/RC_Dx12.cpp +++ b/OptiScaler/shaders/resource_copy/RC_Dx12.cpp @@ -1,64 +1,16 @@ #include "pch.h" #include "RC_Dx12.h" +#include "RC_Common.h" #include "precompile/rc_offset_Shader.h" -// Typeless formats TranslateTypelessFormats doesn't cover, R16 is D16 depth or the half float FFX assumes -static DXGI_FORMAT SrvFormat(DXGI_FORMAT format, bool depth) -{ - switch (format) - { - case DXGI_FORMAT_R16_TYPELESS: - return depth ? DXGI_FORMAT_R16_UNORM : DXGI_FORMAT_R16_FLOAT; - - case DXGI_FORMAT_R8_TYPELESS: - return DXGI_FORMAT_R8_UNORM; - - case DXGI_FORMAT_B8G8R8X8_TYPELESS: - return DXGI_FORMAT_B8G8R8X8_UNORM; - - default: - return DXGI_FORMAT_UNKNOWN; - } -} - -// The copy must be writable through a UAV and read back the same values -static DXGI_FORMAT BufferFormat(DXGI_FORMAT format, bool depth) -{ - // Depth formats can't be UAVs, the shader reads the depth plane as float - if (depth) - return DXGI_FORMAT_R32_FLOAT; - - switch (format) - { - // sRGB can't be a UAV, the shader reads them decoded so keep the precision - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: - case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: - return DXGI_FORMAT_R16G16B16A16_FLOAT; - - // BGRA UAV stores are optional - case DXGI_FORMAT_B8G8R8A8_TYPELESS: - case DXGI_FORMAT_B8G8R8A8_UNORM: - case DXGI_FORMAT_B8G8R8X8_TYPELESS: - case DXGI_FORMAT_B8G8R8X8_UNORM: - return DXGI_FORMAT_R8G8B8A8_UNORM; - - default: - if (auto srvFormat = SrvFormat(format, depth); srvFormat != DXGI_FORMAT_UNKNOWN) - return srvFormat; - - return format; - } -} - bool RC_Dx12::CreateBufferResource(ID3D12Device* InDevice, ID3D12Resource* InSource, uint32_t InWidth, uint32_t InHeight, D3D12_RESOURCE_STATES InState) { if (InSource == nullptr) return false; - auto format = BufferFormat(InSource->GetDesc().Format, _depth); + auto format = RC_Formats::BufferFormat(InSource->GetDesc().Format, _depth); uint64_t width = InWidth; uint32_t height = InHeight; @@ -105,7 +57,7 @@ bool RC_Dx12::Dispatch(ID3D12GraphicsCommandList* InCmdList, ID3D12Resource* InR FrameDescriptorHeap& currentHeap = _frameHeaps[_counter]; CreateShaderResourceView(_device, InResource, currentHeap.GetSrvCPU(0), - SrvFormat(InResource->GetDesc().Format, _depth)); + RC_Formats::SrvFormat(InResource->GetDesc().Format, _depth)); CreateUnorderedAccessView(_device, OutResource, currentHeap.GetUavCPU(0), 0); InternalConstants constants {}; diff --git a/OptiScaler/upscalers/IFeature.cpp b/OptiScaler/upscalers/IFeature.cpp index 2c318a9b..0e0557f8 100644 --- a/OptiScaler/upscalers/IFeature.cpp +++ b/OptiScaler/upscalers/IFeature.cpp @@ -2,6 +2,8 @@ #include #include "IFeature.h" +#include + void IFeature::SetHandle(unsigned int InHandleId) { _handle = new NVSDK_NGX_Handle { InHandleId }; @@ -269,21 +271,12 @@ void IFeature::GetRenderResolution(const NVSDK_NGX_Parameter* InParameters, unsi void IFeature::ReadSubrects(const NVSDK_NGX_Parameter* InParameters) { - static constexpr std::array, (size_t) SubrectSlot::Count> baseKeys = { { - { NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y }, - { NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y }, - { NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y }, - { NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, - NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y }, - { NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y }, - } }; - - for (size_t i = 0; i < baseKeys.size(); i++) + for (size_t i = 0; i < SubrectBaseKeys.size(); i++) { auto& rect = _subrects[i]; rect = { 0, 0, _renderWidth, _renderHeight }; - InParameters->Get(baseKeys[i].first, &rect.X); - InParameters->Get(baseKeys[i].second, &rect.Y); + rect.Given = InParameters->Get(SubrectBaseKeys[i].first, &rect.X) == NVSDK_NGX_Result_Success; + rect.Given |= InParameters->Get(SubrectBaseKeys[i].second, &rect.Y) == NVSDK_NGX_Result_Success; } // Display resolution motion vectors and the output keep the creation size, even with dynamic resolution @@ -298,7 +291,33 @@ void IFeature::ReadSubrects(const NVSDK_NGX_Parameter* InParameters) output.Height = DisplayHeight(); if (!_outputSubrects) - output.X = output.Y = 0; + output = { 0, 0, output.Width, output.Height }; +} + +bool IFeature::SubrectFits(SubrectSlot InSlot, const Subrect& InRect, uint64_t InWidth, uint32_t InHeight) +{ + const uint32_t slotBit = 1u << (uint32_t) InSlot; + + if ((uint64_t) InRect.X + InRect.Width > InWidth || (uint64_t) InRect.Y + InRect.Height > InHeight) + { + if (!(_subrectWarned & slotBit)) + { + LOG_WARN("{} subrect {}x{} at ({}, {}) is outside the {}x{} texture, using it as is", + magic_enum::enum_name(InSlot), InRect.Width, InRect.Height, InRect.X, InRect.Y, InWidth, InHeight); + _subrectWarned |= slotBit; + } + + return false; + } + + if (!(_subrectLogged & slotBit)) + { + LOG_INFO("{} subrect {}x{} at ({}, {}) of the {}x{} texture, copying it for {}", magic_enum::enum_name(InSlot), + InRect.Width, InRect.Height, InRect.X, InRect.Y, InWidth, InHeight, Name()); + _subrectLogged |= slotBit; + } + + return true; } float IFeature::GetSharpness(const NVSDK_NGX_Parameter* InParameters) diff --git a/OptiScaler/upscalers/IFeature.h b/OptiScaler/upscalers/IFeature.h index 66ec817a..18484f89 100644 --- a/OptiScaler/upscalers/IFeature.h +++ b/OptiScaler/upscalers/IFeature.h @@ -50,10 +50,27 @@ struct Subrect uint32_t Y = 0; uint32_t Width = 0; uint32_t Height = 0; + bool Given = false; // The game passed the base, even (0, 0) bool HasOffset() const { return X != 0 || Y != 0; } + + // Only part of the texture belongs to this view, the rest can be other views + bool IsPartOf(uint64_t InWidth, uint32_t InHeight) const + { + return HasOffset() || (Given && (Width < InWidth || Height < InHeight)); + } }; +// Base X/Y parameter names, in SubrectSlot order +inline constexpr std::array, (size_t) SubrectSlot::Count> SubrectBaseKeys = { { + { NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_X, NVSDK_NGX_Parameter_DLSS_Input_Color_Subrect_Base_Y }, + { NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_X, NVSDK_NGX_Parameter_DLSS_Input_Depth_Subrect_Base_Y }, + { NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_X, NVSDK_NGX_Parameter_DLSS_Input_MV_SubrectBase_Y }, + { NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_X, + NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_SubrectBase_Y }, + { NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_X, NVSDK_NGX_Parameter_DLSS_Output_Subrect_Base_Y }, +} }; + struct DetailedGpuTime { std::string name; @@ -132,6 +149,8 @@ class IFeature void GetRenderResolution(const NVSDK_NGX_Parameter* InParameters, unsigned int* OutWidth, unsigned int* OutHeight); void ReadSubrects(const NVSDK_NGX_Parameter* InParameters); const Subrect& GetSubrect(SubrectSlot InSlot) const { return _subrects[(size_t) InSlot]; } + // Warns once when the subrect is outside the texture, otherwise logs it once + bool SubrectFits(SubrectSlot InSlot, const Subrect& InRect, uint64_t InWidth, uint32_t InHeight); void GetDynamicOutputResolution(NVSDK_NGX_Parameter* InParameters, unsigned int* width, unsigned int* height); float GetSharpness(const NVSDK_NGX_Parameter* InParameters); diff --git a/OptiScaler/upscalers/IFeature_Dx11.cpp b/OptiScaler/upscalers/IFeature_Dx11.cpp index 3d28d6dd..fc35af91 100644 --- a/OptiScaler/upscalers/IFeature_Dx11.cpp +++ b/OptiScaler/upscalers/IFeature_Dx11.cpp @@ -5,6 +5,39 @@ using Microsoft::WRL::ComPtr; +ID3D11Resource* IFeature_Dx11::SubrectInput(ID3D11DeviceContext* InContext, ID3D11Resource* InResource, + SubrectSlot InSlot) +{ + const auto& rect = GetSubrect(InSlot); + + if (InResource == nullptr || !rect.HasOffset()) + return InResource; + + ComPtr texture; + + if (InResource->QueryInterface(IID_PPV_ARGS(&texture)) != S_OK) + return InResource; + + D3D11_TEXTURE2D_DESC desc {}; + texture->GetDesc(&desc); + + if (!SubrectFits(InSlot, rect, desc.Width, desc.Height)) + return InResource; + + auto& copy = SubrectCopy[(size_t) InSlot]; + + if (copy == nullptr) + copy = std::make_unique("Subrect Copy", Device, InSlot == SubrectSlot::Depth); + + if (!copy->IsInit() || !copy->CreateBufferResource(Device, InResource, rect.Width, rect.Height) || + !copy->Dispatch(InContext, texture.Get(), copy->Buffer(), rect.X, rect.Y, 0, 0, rect.Width, rect.Height)) + { + return InResource; + } + + return copy->Buffer(); +} + bool IFeature_Dx11::Init(ID3D11Device* InDevice, ID3D11DeviceContext* InContext, NVSDK_NGX_Parameter* InParameters) { if (InDevice == nullptr) diff --git a/OptiScaler/upscalers/IFeature_Dx11.h b/OptiScaler/upscalers/IFeature_Dx11.h index 84f4707e..20022463 100644 --- a/OptiScaler/upscalers/IFeature_Dx11.h +++ b/OptiScaler/upscalers/IFeature_Dx11.h @@ -6,6 +6,7 @@ #include #include #include +#include #include class IFeature_Dx11 : public virtual IFeature @@ -35,6 +36,12 @@ class IFeature_Dx11 : public virtual IFeature std::unique_ptr UpscalerTime = nullptr; + // Created on the first view that doesn't start at (0, 0) + std::array, (size_t) SubrectSlot::Count> SubrectCopy; + + // Resource for backends without subrect support, a copy of the view when it doesn't start at (0, 0) + ID3D11Resource* SubrectInput(ID3D11DeviceContext* InContext, ID3D11Resource* InResource, SubrectSlot InSlot); + virtual bool InitInternal(ID3D11DeviceContext* InContext, NVSDK_NGX_Parameter* InParameters) = 0; virtual bool EvaluateInternal(ID3D11DeviceContext* DeviceContext, NVSDK_NGX_Parameter* InParameters) = 0; diff --git a/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp b/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp index d36eafe1..4dd1baa1 100644 --- a/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp +++ b/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp @@ -227,10 +227,10 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame return true; } -bool IFeature_Dx11wDx12::CopyBackOutput() +bool IFeature_Dx11wDx12::CopyBackOutput(const D3D11_BOX* InView, UINT InDstX, UINT InDstY) { const auto resourceFrame = (UINT) (_frameCount % DX11_WITH_DX12_CACHED_FRAMES); - return Dx11WithDx12::CopyUpscalerOutputToDx11(ResourceCache, resourceFrame); + return Dx11WithDx12::CopyUpscalerOutputToDx11(ResourceCache, resourceFrame, InView, InDstX, InDstY); } bool IFeature_Dx11wDx12::Init(ID3D11Device* InDevice, ID3D11DeviceContext* InContext, NVSDK_NGX_Parameter* InParameters) @@ -364,8 +364,11 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG ComPtr restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {}; ID3D11RenderTargetView* rawRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {}; ComPtr restoreDSV = nullptr; + ComPtr restoreCS = nullptr; // backup compute shader resources + InDeviceContext->CSGetShader(restoreCS.GetAddressOf(), nullptr, nullptr); + for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++) { InDeviceContext->CSGetShaderResources(i, 1, restoreSRVs[i].GetAddressOf()); @@ -400,8 +403,48 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG bool dx12EvalResult = false; bool commandListRecording = false; bool commandListExecuted = false; + + // The D3D12 feature gets the views at (0, 0), so only they are shared and copied back + uint32_t zeroedSubrects = 0; + std::optional outputView; + + auto zeroSubrect = [&](SubrectSlot slot) + { + InParameters->Set(SubrectBaseKeys[(size_t) slot].first, 0u); + InParameters->Set(SubrectBaseKeys[(size_t) slot].second, 0u); + zeroedSubrects |= 1u << (uint32_t) slot; + }; + do { + // The D3D12 feature calls GetRenderResolution, without dimensions it's the creation size like DLSS + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width, &_renderWidth); + InParameters->Get(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, &_renderHeight); + ReadSubrects(InParameters); + + static constexpr std::pair subrectInputs[] = { + { SubrectSlot::Color, NVSDK_NGX_Parameter_Color }, + { SubrectSlot::Depth, NVSDK_NGX_Parameter_Depth }, + { SubrectSlot::MV, NVSDK_NGX_Parameter_MotionVectors }, + { SubrectSlot::Mask, NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask }, + }; + + for (const auto& [slot, name] : subrectInputs) + { + ID3D11Resource* resource = nullptr; + + if (!getOriginalNgxResource(InParameters, name, &resource)) + continue; + + auto view = SubrectInput(InDeviceContext, resource, slot); + + if (view != resource) + { + InParameters->Set(name, (void*) view); + zeroSubrect(slot); + } + } + if (!ProcessDx11Textures(InParameters)) { LOG_ERROR("Can't process Dx11 textures!"); @@ -415,6 +458,18 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG commandListRecording = true; + // An already shared output is written in place, the D3D12 feature places the view there + const auto& outputRect = GetSubrect(SubrectSlot::Output); + const auto& outputDesc = dx11Out.SourceDesc; + + if (cache.ParamOutput[resourceFrame] != static_cast(dx11Out.SharedTexture) && + outputRect.IsPartOf(outputDesc.Width, outputDesc.Height) && + SubrectFits(SubrectSlot::Output, outputRect, outputDesc.Width, outputDesc.Height)) + { + outputView = D3D11_BOX { 0, 0, 0, outputRect.Width, outputRect.Height, 1 }; + zeroSubrect(SubrectSlot::Output); + } + InParameters->Set(NVSDK_NGX_Parameter_Color, (void*) dx11Color.Dx12Resource); InParameters->Set(NVSDK_NGX_Parameter_MotionVectors, (void*) dx11Mv.Dx12Resource); InParameters->Set(NVSDK_NGX_Parameter_Output, (void*) dx11Out.Dx12Resource); @@ -458,6 +513,15 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG InParameters->Set("FSR.reactive", restoreFsrReactive); InParameters->Set("FSR.transparencyAndComposition", restoreFsrTransparency); + for (uint32_t slot = 0; slot < (uint32_t) SubrectSlot::Count; slot++) + { + if (zeroedSubrects & (1u << slot)) + { + InParameters->Set(SubrectBaseKeys[slot].first, _subrects[slot].X); + InParameters->Set(SubrectBaseKeys[slot].second, _subrects[slot].Y); + } + } + if (commandListRecording) { const auto closeResult = cmdList->Close(); @@ -494,7 +558,9 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG if (!dx12EvalResult || !commandListExecuted) break; - if (!CopyBackOutput()) + const auto& outputRect = GetSubrect(SubrectSlot::Output); + + if (!CopyBackOutput(outputView ? &outputView.value() : nullptr, outputRect.X, outputRect.Y)) { LOG_ERROR("Can't copy output texture back!"); break; @@ -509,7 +575,10 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG else Dx11WithDx12::ClearLastPreparedUpscalerFrameState(ResourceCache); - // restore compute shader resources + // restore compute shader resources, the shader only changes when we cropped the inputs + if (zeroedSubrects & ~(1u << (uint32_t) SubrectSlot::Output)) + InDeviceContext->CSSetShader(restoreCS.Get(), nullptr, 0); + for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++) { auto raw = restoreSRVs[i].Get(); diff --git a/OptiScaler/upscalers/IFeature_Dx11wDx12.h b/OptiScaler/upscalers/IFeature_Dx11wDx12.h index 5b326343..01a2bcd1 100644 --- a/OptiScaler/upscalers/IFeature_Dx11wDx12.h +++ b/OptiScaler/upscalers/IFeature_Dx11wDx12.h @@ -45,7 +45,7 @@ class IFeature_Dx11wDx12 : public virtual IFeature_Dx11 bool CreateD3D12Objects(); bool ProcessDx11Textures(const NVSDK_NGX_Parameter* InParameters); - bool CopyBackOutput(); + bool CopyBackOutput(const D3D11_BOX* InView, UINT InDstX, UINT InDstY); void ResourceBarrier(ID3D12GraphicsCommandList* InCommandList, ID3D12Resource* InResource, D3D12_RESOURCE_STATES InBeforeState, D3D12_RESOURCE_STATES InAfterState); diff --git a/OptiScaler/upscalers/IFeature_Dx12.cpp b/OptiScaler/upscalers/IFeature_Dx12.cpp index 49564ae3..c87682db 100644 --- a/OptiScaler/upscalers/IFeature_Dx12.cpp +++ b/OptiScaler/upscalers/IFeature_Dx12.cpp @@ -6,7 +6,6 @@ #include "IFeature_Dx12.h" #include "State.h" #include -#include void IFeature_Dx12::ResourceBarrier(ID3D12GraphicsCommandList* InCommandList, ID3D12Resource* InResource, D3D12_RESOURCE_STATES InBeforeState, D3D12_RESOURCE_STATES InAfterState) const @@ -40,28 +39,10 @@ void IFeature_Dx12::RestoreBarriers(ID3D12GraphicsCommandList* InCommandList) bool IFeature_Dx12::CheckSubrect(SubrectSlot InSlot, const Subrect& InRect, ID3D12Resource* InResource) { - const uint32_t slotBit = 1u << (uint32_t) InSlot; const auto desc = InResource->GetDesc(); - if ((uint64_t) InRect.X + InRect.Width > desc.Width || (uint64_t) InRect.Y + InRect.Height > desc.Height) - { - if (!(_subrectWarned & slotBit)) - { - LOG_WARN("{} subrect {}x{} at ({}, {}) is outside the {}x{} texture, using it as is", - magic_enum::enum_name(InSlot), InRect.Width, InRect.Height, InRect.X, InRect.Y, desc.Width, - desc.Height); - _subrectWarned |= slotBit; - } - + if (!SubrectFits(InSlot, InRect, desc.Width, desc.Height)) return false; - } - - if (!(_subrectLogged & slotBit)) - { - LOG_INFO("{} subrect {}x{} at ({}, {}) of the {}x{} texture, copying it for {}", magic_enum::enum_name(InSlot), - InRect.Width, InRect.Height, InRect.X, InRect.Y, desc.Width, desc.Height, Name()); - _subrectLogged |= slotBit; - } auto& copy = SubrectCopy[(size_t) InSlot]; @@ -326,11 +307,13 @@ bool IFeature_Dx12::Evaluate(ID3D12GraphicsCommandList* InCommandList, NVSDK_NGX } // The upscaler and the passes work on the view at (0, 0) of our buffers, this last pass writes it to the output - // base. Native subrect upscalers without passes write there by themselves. + // base. Upscalers write only their view by themselves, at (0, 0) or at the base for native subrect ones, but the + // passes write the whole texture over the other views. const bool nativeSubrects = upscaler == Upscaler::XeSS || upscaler == Upscaler::DLSS || upscaler == Upscaler::DLSSD; bool placeOutput = false; - if (paramOutput && outputRect.HasOffset() && (!nativeSubrects || !pipeline.empty()) && + if (paramOutput && outputRect.IsPartOf(paramOutput->GetDesc().Width, paramOutput->GetDesc().Height) && + (!pipeline.empty() || (outputRect.HasOffset() && !nativeSubrects)) && CheckSubrect(SubrectSlot::Output, outputRect, paramOutput)) { // By value, the lambdas run after this scope diff --git a/OptiScaler/with_dx12/dx11_with_dx12.cpp b/OptiScaler/with_dx12/dx11_with_dx12.cpp index aebe51ec..a0e1d344 100644 --- a/OptiScaler/with_dx12/dx11_with_dx12.cpp +++ b/OptiScaler/with_dx12/dx11_with_dx12.cpp @@ -993,7 +993,8 @@ Dx11WithDx12::PrepareUpscalerResources(D3D11_UPSCALER_RESOURCE_CACHE_C& cache, c return result; } -bool Dx11WithDx12::CopyUpscalerOutputToDx11(D3D11_UPSCALER_RESOURCE_CACHE_C& cache, UINT frameIndex) +bool Dx11WithDx12::CopyUpscalerOutputToDx11(D3D11_UPSCALER_RESOURCE_CACHE_C& cache, UINT frameIndex, + const D3D11_BOX* InView, UINT InDstX, UINT InDstY) { if (Dx11DeviceContext == nullptr) { @@ -1016,8 +1017,13 @@ bool Dx11WithDx12::CopyUpscalerOutputToDx11(D3D11_UPSCALER_RESOURCE_CACHE_C& cac } // An already shared output is written in place, copying a resource onto itself is invalid - if (cache.ParamOutput[outputIndex] != static_cast(cache.Output[outputIndex].SharedTexture)) - Dx11DeviceContext->CopyResource(cache.ParamOutput[outputIndex], cache.Output[outputIndex].SharedTexture); + auto output = cache.ParamOutput[outputIndex]; + auto shared = cache.Output[outputIndex].SharedTexture; + + if (output != static_cast(shared) && InView != nullptr) + Dx11DeviceContext->CopySubresourceRegion(output, 0, InDstX, InDstY, 0, shared, 0, InView); + else if (output != static_cast(shared)) + Dx11DeviceContext->CopyResource(output, shared); // After a CPU wait the D3D11 queue is idle, submit right away instead of waiting for the next flush if (UseCpuWaitForDx12()) diff --git a/OptiScaler/with_dx12/dx11_with_dx12.h b/OptiScaler/with_dx12/dx11_with_dx12.h index 3cf34f9b..8ae96a21 100644 --- a/OptiScaler/with_dx12/dx11_with_dx12.h +++ b/OptiScaler/with_dx12/dx11_with_dx12.h @@ -159,7 +159,9 @@ class Dx11WithDx12 static bool SyncDx11ToDx12(); static bool SyncDx12ToDx11(); - static bool CopyUpscalerOutputToDx11(D3D11_UPSCALER_RESOURCE_CACHE_C& cache, UINT frameIndex); + // InView: rectangle of the shared output copied to InDstX/InDstY, nullptr copies the whole texture + static bool CopyUpscalerOutputToDx11(D3D11_UPSCALER_RESOURCE_CACHE_C& cache, UINT frameIndex, + const D3D11_BOX* InView = nullptr, UINT InDstX = 0, UINT InDstY = 0); static bool CheckMask(ResourceMask mask, ResourceMask resource);