mirror of
https://github.com/optiscaler/OptiScaler.git
synced 2026-11-16 10:46:45 +00:00
647 lines
24 KiB
C++
647 lines
24 KiB
C++
#include "FfxApi_Vk.h"
|
|
|
|
#include <Util.h>
|
|
#include <Config.h>
|
|
#include <resource.h>
|
|
#include <NVNGX_Parameter.h>
|
|
|
|
#include <proxies/FfxApi_Proxy.h>
|
|
|
|
#include <ffx_upscale.h>
|
|
#include <vk/ffx_api_vk.h>
|
|
|
|
#include <nvsdk_ngx_vk.h>
|
|
#include <nvsdk_ngx_helpers_vk.h>
|
|
|
|
static std::unordered_map<ffxContext, ffxCreateContextDescUpscale> _initParams;
|
|
static std::unordered_map<ffxContext, NVSDK_NGX_Parameter*> _nvParams;
|
|
static std::unordered_map<ffxContext, NVSDK_NGX_Handle*> _contexts;
|
|
static VkDevice _vkDevice = nullptr;
|
|
static VkPhysicalDevice _vkPhysicalDevice = nullptr;
|
|
static PFN_vkGetDeviceProcAddr _vkDeviceProcAddress = nullptr;
|
|
static bool _nvnxgInited = false;
|
|
static float qualityRatios[] = { 1.0f, 1.5f, 1.7f, 2.0f, 3.0f };
|
|
static VkImageView depthImageView = nullptr;
|
|
static VkImageView expImageView = nullptr;
|
|
static VkImageView biasImageView = nullptr;
|
|
static VkImageView colorImageView = nullptr;
|
|
static VkImageView mvImageView = nullptr;
|
|
static VkImageView outputImageView = nullptr;
|
|
static VkImageView fsrReactiveView = nullptr;
|
|
static VkImageView fsrTransparencyView = nullptr;
|
|
static NVSDK_NGX_Resource_VK depthNVRes {};
|
|
static NVSDK_NGX_Resource_VK expNVRes {};
|
|
static NVSDK_NGX_Resource_VK biasNVRes {};
|
|
static NVSDK_NGX_Resource_VK colorNVRes {};
|
|
static NVSDK_NGX_Resource_VK mvNVRes {};
|
|
static NVSDK_NGX_Resource_VK outputNVRes {};
|
|
static NVSDK_NGX_Resource_VK fsrReactiveNVRes {};
|
|
static NVSDK_NGX_Resource_VK fsrTransparencyNVRes {};
|
|
|
|
static VkFormat ffxApiGetVkFormat(uint32_t fmt)
|
|
{
|
|
switch (fmt)
|
|
{
|
|
case FFX_API_SURFACE_FORMAT_R32G32B32A32_FLOAT:
|
|
return VK_FORMAT_R32G32B32A32_SFLOAT;
|
|
case FFX_API_SURFACE_FORMAT_R32G32B32A32_UINT:
|
|
return VK_FORMAT_R32G32B32A32_UINT;
|
|
case FFX_API_SURFACE_FORMAT_R16G16B16A16_FLOAT:
|
|
return VK_FORMAT_R16G16B16A16_SFLOAT;
|
|
case FFX_API_SURFACE_FORMAT_R32G32_FLOAT:
|
|
return VK_FORMAT_R32G32_SFLOAT;
|
|
case FFX_API_SURFACE_FORMAT_R32_UINT:
|
|
// case VK_FORMAT_D24_UNORM_S8_UINT:
|
|
// case VK_FORMAT_X8_D24_UNORM_PACK32:
|
|
return VK_FORMAT_R32_UINT;
|
|
case FFX_API_SURFACE_FORMAT_R8G8B8A8_UNORM:
|
|
return VK_FORMAT_R8G8B8A8_UNORM;
|
|
case FFX_API_SURFACE_FORMAT_R8G8B8A8_SNORM:
|
|
return VK_FORMAT_R8G8B8A8_SNORM;
|
|
case FFX_API_SURFACE_FORMAT_R8G8B8A8_SRGB:
|
|
return VK_FORMAT_R8G8B8A8_SRGB;
|
|
case FFX_API_SURFACE_FORMAT_B8G8R8A8_UNORM:
|
|
return VK_FORMAT_B8G8R8A8_UNORM;
|
|
case FFX_API_SURFACE_FORMAT_B8G8R8A8_SRGB:
|
|
return VK_FORMAT_B8G8R8A8_SRGB;
|
|
case FFX_API_SURFACE_FORMAT_R11G11B10_FLOAT:
|
|
return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
|
|
case FFX_API_SURFACE_FORMAT_R10G10B10A2_UNORM:
|
|
return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
|
|
case FFX_API_SURFACE_FORMAT_R16G16_FLOAT:
|
|
return VK_FORMAT_R16G16_SFLOAT;
|
|
case FFX_API_SURFACE_FORMAT_R16G16_UINT:
|
|
return VK_FORMAT_R16G16_UINT;
|
|
case FFX_API_SURFACE_FORMAT_R16G16_SINT:
|
|
return VK_FORMAT_R16G16_SINT;
|
|
case FFX_API_SURFACE_FORMAT_R16_FLOAT:
|
|
return VK_FORMAT_R16_SFLOAT;
|
|
case FFX_API_SURFACE_FORMAT_R16_UINT:
|
|
return VK_FORMAT_R16_UINT;
|
|
case FFX_API_SURFACE_FORMAT_R16_UNORM:
|
|
// case VK_FORMAT_D16_UNORM:
|
|
// case VK_FORMAT_D16_UNORM_S8_UINT:
|
|
return VK_FORMAT_R16_UNORM;
|
|
case FFX_API_SURFACE_FORMAT_R16_SNORM:
|
|
return VK_FORMAT_R16_SNORM;
|
|
case FFX_API_SURFACE_FORMAT_R8_UNORM:
|
|
return VK_FORMAT_R8_UNORM;
|
|
case FFX_API_SURFACE_FORMAT_R8_UINT:
|
|
// case VK_FORMAT_S8_UINT:
|
|
return VK_FORMAT_R8_UINT;
|
|
case FFX_API_SURFACE_FORMAT_R8G8_UNORM:
|
|
return VK_FORMAT_R8G8_UNORM;
|
|
case FFX_API_SURFACE_FORMAT_R8G8_UINT:
|
|
return VK_FORMAT_R8G8_UINT;
|
|
case FFX_API_SURFACE_FORMAT_R32_FLOAT:
|
|
// case VK_FORMAT_D32_SFLOAT:
|
|
// case VK_FORMAT_D32_SFLOAT_S8_UINT:
|
|
return VK_FORMAT_R32_SFLOAT;
|
|
case FFX_API_SURFACE_FORMAT_R9G9B9E5_SHAREDEXP:
|
|
return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
|
|
case FFX_API_SURFACE_FORMAT_UNKNOWN:
|
|
return VK_FORMAT_UNDEFINED;
|
|
|
|
default:
|
|
return VK_FORMAT_UNDEFINED;
|
|
}
|
|
}
|
|
|
|
static bool CreateIVandNVRes(FfxApiResource resource, VkImageView* imageView, NVSDK_NGX_Resource_VK* nvResource)
|
|
{
|
|
VkImageViewCreateInfo createInfo {};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
createInfo.image = (VkImage) resource.resource;
|
|
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
createInfo.format = ffxApiGetVkFormat(resource.description.format);
|
|
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
|
|
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_NONE;
|
|
if (resource.description.usage & FFX_API_RESOURCE_USAGE_DEPTHTARGET)
|
|
createInfo.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
else if (resource.description.usage & FFX_API_RESOURCE_USAGE_STENCILTARGET)
|
|
createInfo.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
|
|
else
|
|
createInfo.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_COLOR_BIT;
|
|
|
|
createInfo.subresourceRange.baseMipLevel = 0;
|
|
createInfo.subresourceRange.levelCount = 1;
|
|
createInfo.subresourceRange.baseArrayLayer = 0;
|
|
createInfo.subresourceRange.layerCount = 1;
|
|
|
|
auto result = vkCreateImageView(_vkDevice, &createInfo, nullptr, imageView);
|
|
|
|
if (result != VK_SUCCESS)
|
|
{
|
|
LOG_ERROR("vkCreateImageView error!: {:X}", (int) result);
|
|
return false;
|
|
}
|
|
|
|
(*nvResource).Type = NVSDK_NGX_RESOURCE_VK_TYPE_VK_IMAGEVIEW;
|
|
(*nvResource).Resource.ImageViewInfo.ImageView = *imageView;
|
|
(*nvResource).Resource.ImageViewInfo.Image = createInfo.image;
|
|
(*nvResource).Resource.ImageViewInfo.SubresourceRange = createInfo.subresourceRange;
|
|
(*nvResource).Resource.ImageViewInfo.Height = resource.description.height;
|
|
(*nvResource).Resource.ImageViewInfo.Width = resource.description.width;
|
|
(*nvResource).Resource.ImageViewInfo.Format = ffxApiGetVkFormat(resource.description.format);
|
|
(*nvResource).ReadWrite = (resource.description.usage & FFX_API_RESOURCE_USAGE_UAV) > 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool CreateDLSSContext(ffxContext handle, const ffxDispatchDescUpscale* pExecParams)
|
|
{
|
|
LOG_DEBUG("context: {:X}", (size_t) handle);
|
|
|
|
if (!_nvParams.contains(handle))
|
|
return false;
|
|
|
|
NVSDK_NGX_Handle* nvHandle = nullptr;
|
|
auto params = _nvParams[handle];
|
|
auto initParams = &_initParams[handle];
|
|
auto commandList = (VkCommandBuffer) pExecParams->commandList;
|
|
|
|
UINT initFlags = 0;
|
|
|
|
if (initParams->flags & FFX_UPSCALE_ENABLE_HIGH_DYNAMIC_RANGE)
|
|
initFlags |= NVSDK_NGX_DLSS_Feature_Flags_IsHDR;
|
|
|
|
if (initParams->flags & FFX_UPSCALE_ENABLE_DEPTH_INVERTED)
|
|
initFlags |= NVSDK_NGX_DLSS_Feature_Flags_DepthInverted;
|
|
|
|
if (initParams->flags & FFX_UPSCALE_ENABLE_AUTO_EXPOSURE)
|
|
initFlags |= NVSDK_NGX_DLSS_Feature_Flags_AutoExposure;
|
|
|
|
if (initParams->flags & FFX_UPSCALE_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION)
|
|
initFlags |= NVSDK_NGX_DLSS_Feature_Flags_MVJittered;
|
|
|
|
if ((initParams->flags & FFX_UPSCALE_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS) == 0)
|
|
initFlags |= NVSDK_NGX_DLSS_Feature_Flags_MVLowRes;
|
|
|
|
params->Set(NVSDK_NGX_Parameter_DLSS_Feature_Create_Flags, initFlags);
|
|
|
|
params->Set(NVSDK_NGX_Parameter_Width, pExecParams->renderSize.width);
|
|
params->Set(NVSDK_NGX_Parameter_Height, pExecParams->renderSize.height);
|
|
params->Set(NVSDK_NGX_Parameter_OutWidth, initParams->maxUpscaleSize.width);
|
|
params->Set(NVSDK_NGX_Parameter_OutHeight, initParams->maxUpscaleSize.height);
|
|
params->Set("FSR.upscaleSize.width", pExecParams->upscaleSize.width);
|
|
params->Set("FSR.upscaleSize.height", pExecParams->upscaleSize.height);
|
|
|
|
auto width = pExecParams->upscaleSize.width > 0 ? pExecParams->upscaleSize.width : initParams->maxUpscaleSize.width;
|
|
|
|
auto ratio = (float) width / (float) pExecParams->renderSize.width;
|
|
|
|
LOG_INFO("renderWidth: {}, maxWidth: {}, ratio: {}", pExecParams->renderSize.width, width, ratio);
|
|
|
|
if (ratio <= 3.0)
|
|
params->Set(NVSDK_NGX_Parameter_PerfQualityValue, NVSDK_NGX_PerfQuality_Value_UltraPerformance);
|
|
else if (ratio <= 2.0)
|
|
params->Set(NVSDK_NGX_Parameter_PerfQualityValue, NVSDK_NGX_PerfQuality_Value_MaxPerf);
|
|
else if (ratio <= 1.7)
|
|
params->Set(NVSDK_NGX_Parameter_PerfQualityValue, NVSDK_NGX_PerfQuality_Value_Balanced);
|
|
else if (ratio <= 1.5)
|
|
params->Set(NVSDK_NGX_Parameter_PerfQualityValue, NVSDK_NGX_PerfQuality_Value_MaxQuality);
|
|
else if (ratio <= 1.3)
|
|
params->Set(NVSDK_NGX_Parameter_PerfQualityValue, NVSDK_NGX_PerfQuality_Value_UltraQuality);
|
|
else
|
|
params->Set(NVSDK_NGX_Parameter_PerfQualityValue, NVSDK_NGX_PerfQuality_Value_DLAA);
|
|
|
|
auto nvngxResult = NVSDK_NGX_VULKAN_CreateFeature(commandList, NVSDK_NGX_Feature_SuperSampling, params, &nvHandle);
|
|
if (nvngxResult != NVSDK_NGX_Result_Success)
|
|
{
|
|
LOG_ERROR("NVSDK_NGX_VULKAN_CreateFeature error: {:X}", (UINT) nvngxResult);
|
|
return false;
|
|
}
|
|
|
|
_contexts[handle] = nvHandle;
|
|
LOG_INFO("context created: {:X}", (size_t) handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
static std::optional<float> GetQualityOverrideRatioFfx(const uint32_t input)
|
|
{
|
|
std::optional<float> output;
|
|
|
|
auto sliderLimit = Config::Instance()->ExtendedLimits.value_or(false) ? 0.1f : 1.0f;
|
|
|
|
if (Config::Instance()->UpscaleRatioOverrideEnabled.value_or(false) &&
|
|
Config::Instance()->UpscaleRatioOverrideValue.value_or(1.3f) >= sliderLimit)
|
|
{
|
|
output = Config::Instance()->UpscaleRatioOverrideValue.value_or(1.3f);
|
|
|
|
return output;
|
|
}
|
|
|
|
if (!Config::Instance()->QualityRatioOverrideEnabled.value_or(false))
|
|
return output; // override not enabled
|
|
|
|
switch (input)
|
|
{
|
|
case FFX_UPSCALE_QUALITY_MODE_ULTRA_PERFORMANCE:
|
|
if (Config::Instance()->QualityRatio_UltraPerformance.value_or(3.0f) >= sliderLimit)
|
|
output = Config::Instance()->QualityRatio_UltraPerformance.value_or(3.0f);
|
|
|
|
break;
|
|
|
|
case FFX_UPSCALE_QUALITY_MODE_PERFORMANCE:
|
|
if (Config::Instance()->QualityRatio_Performance.value_or(2.0f) >= sliderLimit)
|
|
output = Config::Instance()->QualityRatio_Performance.value_or(2.0f);
|
|
|
|
break;
|
|
|
|
case FFX_UPSCALE_QUALITY_MODE_BALANCED:
|
|
if (Config::Instance()->QualityRatio_Balanced.value_or(1.7f) >= sliderLimit)
|
|
output = Config::Instance()->QualityRatio_Balanced.value_or(1.7f);
|
|
|
|
break;
|
|
|
|
case FFX_UPSCALE_QUALITY_MODE_QUALITY:
|
|
if (Config::Instance()->QualityRatio_Quality.value_or(1.5f) >= sliderLimit)
|
|
output = Config::Instance()->QualityRatio_Quality.value_or(1.5f);
|
|
|
|
break;
|
|
|
|
case FFX_UPSCALE_QUALITY_MODE_NATIVEAA:
|
|
if (Config::Instance()->QualityRatio_DLAA.value_or(1.0f) >= sliderLimit)
|
|
output = Config::Instance()->QualityRatio_DLAA.value_or(1.0f);
|
|
|
|
break;
|
|
|
|
default:
|
|
LOG_WARN("Unknown quality: {0}", (int) input);
|
|
break;
|
|
}
|
|
|
|
if (output.has_value())
|
|
LOG_DEBUG("ratio: {}", output.value());
|
|
else
|
|
LOG_DEBUG("ratio: no value");
|
|
|
|
return output;
|
|
}
|
|
|
|
ffxReturnCode_t ffxCreateContext_Vk(ffxContext* context, ffxCreateContextDescHeader* desc,
|
|
const ffxAllocationCallbacks* memCb)
|
|
{
|
|
if (desc == nullptr)
|
|
return FFX_API_RETURN_ERROR_PARAMETER;
|
|
|
|
LOG_DEBUG("type: {:X}", desc->type);
|
|
|
|
auto ffxApiResult = FfxApiProxy::VULKAN_CreateContext()(context, desc, memCb);
|
|
|
|
if (ffxApiResult != FFX_API_RETURN_OK)
|
|
{
|
|
LOG_ERROR("D3D12_CreateContext error: {:X} ({})", (UINT) ffxApiResult,
|
|
FfxApiProxy::ReturnCodeToString(ffxApiResult));
|
|
return ffxApiResult;
|
|
}
|
|
|
|
bool upscaleContext = false;
|
|
ffxApiHeader* header = desc;
|
|
ffxCreateContextDescUpscale* createDesc = nullptr;
|
|
|
|
do
|
|
{
|
|
if (header->type == FFX_API_CREATE_CONTEXT_DESC_TYPE_UPSCALE)
|
|
{
|
|
upscaleContext = true;
|
|
createDesc = (ffxCreateContextDescUpscale*) header;
|
|
}
|
|
else if (header->type == FFX_API_CREATE_CONTEXT_DESC_TYPE_BACKEND_VK)
|
|
{
|
|
auto backendDesc = (ffxCreateBackendVKDesc*) header;
|
|
_vkDevice = backendDesc->vkDevice;
|
|
_vkPhysicalDevice = backendDesc->vkPhysicalDevice;
|
|
_vkDeviceProcAddress = backendDesc->vkDeviceProcAddr;
|
|
}
|
|
|
|
header = header->pNext;
|
|
|
|
} while (header != nullptr);
|
|
|
|
if (!upscaleContext)
|
|
return ffxApiResult;
|
|
|
|
if (!State::Instance().NvngxVkInited)
|
|
{
|
|
NVSDK_NGX_FeatureCommonInfo fcInfo {};
|
|
|
|
auto dllPath = Util::DllPath().remove_filename();
|
|
auto nvngxDlssPath = Util::FindFilePath(dllPath, "nvngx_dlss.dll");
|
|
auto nvngxDlssDPath = Util::FindFilePath(dllPath, "nvngx_dlssd.dll");
|
|
auto nvngxDlssGPath = Util::FindFilePath(dllPath, "nvngx_dlssg.dll");
|
|
|
|
std::vector<std::wstring> pathStorage;
|
|
|
|
pathStorage.push_back(dllPath.wstring());
|
|
|
|
if (nvngxDlssPath.has_value())
|
|
pathStorage.push_back(nvngxDlssPath.value().parent_path().wstring());
|
|
|
|
if (nvngxDlssDPath.has_value())
|
|
pathStorage.push_back(nvngxDlssDPath.value().parent_path().wstring());
|
|
|
|
if (nvngxDlssGPath.has_value())
|
|
pathStorage.push_back(nvngxDlssGPath.value().parent_path().wstring());
|
|
|
|
if (Config::Instance()->DLSSFeaturePath.has_value())
|
|
pathStorage.push_back(Config::Instance()->DLSSFeaturePath.value());
|
|
|
|
// Build pointer array
|
|
wchar_t const** paths = new const wchar_t*[pathStorage.size()];
|
|
for (size_t i = 0; i < pathStorage.size(); ++i)
|
|
{
|
|
paths[i] = pathStorage[i].c_str();
|
|
}
|
|
|
|
fcInfo.PathListInfo.Path = paths;
|
|
fcInfo.PathListInfo.Length = (int) pathStorage.size();
|
|
|
|
auto nvResult = NVSDK_NGX_VULKAN_Init_ProjectID_Ext(
|
|
"OptiScaler", State::Instance().NVNGX_Engine, VER_PRODUCT_VERSION_STR, dllPath.c_str(),
|
|
State::Instance().VulkanInstance, _vkPhysicalDevice, _vkDevice, vkGetInstanceProcAddr, _vkDeviceProcAddress,
|
|
State::Instance().NVNGX_Version, &fcInfo);
|
|
|
|
if (nvResult != NVSDK_NGX_Result_Success)
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
|
|
_nvnxgInited = true;
|
|
}
|
|
|
|
NVSDK_NGX_Parameter* params = nullptr;
|
|
|
|
if (NVSDK_NGX_VULKAN_GetCapabilityParameters(¶ms) != NVSDK_NGX_Result_Success)
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
|
|
_nvParams[*context] = params;
|
|
|
|
ffxCreateContextDescUpscale ccd {};
|
|
ccd.flags = createDesc->flags;
|
|
ccd.maxRenderSize = createDesc->maxRenderSize;
|
|
ccd.maxUpscaleSize = createDesc->maxUpscaleSize;
|
|
_initParams[*context] = ccd;
|
|
|
|
LOG_INFO("context created: {:X}", (size_t) *context);
|
|
|
|
return FFX_API_RETURN_OK;
|
|
}
|
|
|
|
ffxReturnCode_t ffxDestroyContext_Vk(ffxContext* context, const ffxAllocationCallbacks* memCb)
|
|
{
|
|
if (context == nullptr)
|
|
return FFX_API_RETURN_ERROR_PARAMETER;
|
|
|
|
LOG_DEBUG("context: {:X}", (size_t) *context);
|
|
|
|
if (_contexts.contains(*context))
|
|
NVSDK_NGX_VULKAN_ReleaseFeature(_contexts[*context]);
|
|
|
|
_contexts.erase(*context);
|
|
_nvParams.erase(*context);
|
|
_initParams.erase(*context);
|
|
|
|
auto cdResult = FfxApiProxy::VULKAN_DestroyContext()(context, memCb);
|
|
LOG_INFO("result: {:X}", (UINT) cdResult);
|
|
|
|
return FFX_API_RETURN_OK;
|
|
}
|
|
|
|
ffxReturnCode_t ffxConfigure_Vk(ffxContext* context, const ffxConfigureDescHeader* desc)
|
|
{
|
|
if (desc == nullptr)
|
|
return FFX_API_RETURN_ERROR_PARAMETER;
|
|
|
|
LOG_DEBUG("type: {:X}", desc->type);
|
|
|
|
return FfxApiProxy::VULKAN_Configure()(context, desc);
|
|
}
|
|
|
|
ffxReturnCode_t ffxQuery_Vk(ffxContext* context, ffxQueryDescHeader* desc)
|
|
{
|
|
if (desc == nullptr)
|
|
return FFX_API_RETURN_ERROR_PARAMETER;
|
|
|
|
LOG_DEBUG("type: {:X}", desc->type);
|
|
|
|
if (desc->type == FFX_API_QUERY_DESC_TYPE_UPSCALE_GETRENDERRESOLUTIONFROMQUALITYMODE)
|
|
{
|
|
auto ratioDesc = (ffxQueryDescUpscaleGetRenderResolutionFromQualityMode*) desc;
|
|
auto ratio = GetQualityOverrideRatioFfx(ratioDesc->qualityMode).value_or(qualityRatios[ratioDesc->qualityMode]);
|
|
|
|
if (ratioDesc->pOutRenderHeight != nullptr)
|
|
*ratioDesc->pOutRenderHeight = (uint32_t) (ratioDesc->displayHeight / ratio);
|
|
|
|
if (ratioDesc->pOutRenderWidth != nullptr)
|
|
*ratioDesc->pOutRenderWidth = (uint32_t) (ratioDesc->displayWidth / ratio);
|
|
|
|
if (ratioDesc->pOutRenderWidth != nullptr && ratioDesc->pOutRenderHeight != nullptr)
|
|
LOG_DEBUG("Quality mode: {}, Render resolution: {}x{}", ratioDesc->qualityMode, *ratioDesc->pOutRenderWidth,
|
|
*ratioDesc->pOutRenderHeight);
|
|
else
|
|
LOG_WARN("Quality mode: {}, pOutRenderWidth or pOutRenderHeight is null!", ratioDesc->qualityMode);
|
|
|
|
return FFX_API_RETURN_OK;
|
|
}
|
|
else if (desc->type == FFX_API_QUERY_DESC_TYPE_UPSCALE_GETUPSCALERATIOFROMQUALITYMODE)
|
|
{
|
|
auto scaleDesc = (ffxQueryDescUpscaleGetUpscaleRatioFromQualityMode*) desc;
|
|
*scaleDesc->pOutUpscaleRatio = GetQualityOverrideRatioFfx((FfxApiUpscaleQualityMode) scaleDesc->qualityMode)
|
|
.value_or(qualityRatios[scaleDesc->qualityMode]);
|
|
|
|
LOG_DEBUG("Quality mode: {}, Upscale ratio: {}", scaleDesc->qualityMode, *scaleDesc->pOutUpscaleRatio);
|
|
|
|
return FFX_API_RETURN_OK;
|
|
}
|
|
|
|
return FfxApiProxy::VULKAN_Query()(context, desc);
|
|
}
|
|
|
|
ffxReturnCode_t ffxDispatch_Vk(ffxContext* context, ffxDispatchDescHeader* desc)
|
|
{
|
|
// Skip OptiScaler stuff
|
|
if (!Config::Instance()->UseFfxInputs.value_or(true))
|
|
return FfxApiProxy::VULKAN_Dispatch()(context, desc);
|
|
|
|
if (desc == nullptr || context == nullptr)
|
|
return FFX_API_RETURN_ERROR_PARAMETER;
|
|
|
|
LOG_DEBUG("context: {:X}, type: {:X}", (size_t) *context, desc->type);
|
|
|
|
if (!_initParams.contains(*context))
|
|
{
|
|
LOG_INFO("Not in _contexts, desc type: {:X}", desc->type);
|
|
return FfxApiProxy::VULKAN_Dispatch()(context, desc);
|
|
}
|
|
|
|
ffxApiHeader* header = desc;
|
|
ffxDispatchDescUpscale* dispatchDesc = nullptr;
|
|
bool rmDesc = false;
|
|
|
|
do
|
|
{
|
|
if (header->type == FFX_API_DISPATCH_DESC_TYPE_UPSCALE)
|
|
{
|
|
dispatchDesc = (ffxDispatchDescUpscale*) header;
|
|
break;
|
|
}
|
|
|
|
header = header->pNext;
|
|
|
|
} while (header != nullptr);
|
|
|
|
if (dispatchDesc == nullptr)
|
|
{
|
|
LOG_INFO("dispatchDesc == nullptr, desc type: {:X}", desc->type);
|
|
return FfxApiProxy::VULKAN_Dispatch()(context, desc);
|
|
}
|
|
|
|
if (dispatchDesc->commandList == nullptr)
|
|
{
|
|
LOG_ERROR("dispatchDesc->commandList == nullptr !!!");
|
|
return FFX_API_RETURN_ERROR_PARAMETER;
|
|
}
|
|
|
|
// If not in contexts list create and add context
|
|
auto contextId = (size_t) *context;
|
|
if (!_contexts.contains(*context) && _initParams.contains(*context) && !CreateDLSSContext(*context, dispatchDesc))
|
|
{
|
|
LOG_DEBUG("!_contexts.contains(*context) && _initParams.contains(*context) && !CreateDLSSContext(*context, "
|
|
"dispatchDesc)");
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
}
|
|
|
|
NVSDK_NGX_Parameter* params = _nvParams[*context];
|
|
NVSDK_NGX_Handle* handle = _contexts[*context];
|
|
|
|
params->Set(NVSDK_NGX_Parameter_Jitter_Offset_X, dispatchDesc->jitterOffset.x);
|
|
params->Set(NVSDK_NGX_Parameter_Jitter_Offset_Y, dispatchDesc->jitterOffset.y);
|
|
params->Set(NVSDK_NGX_Parameter_MV_Scale_X, dispatchDesc->motionVectorScale.x);
|
|
params->Set(NVSDK_NGX_Parameter_MV_Scale_Y, dispatchDesc->motionVectorScale.y);
|
|
params->Set(NVSDK_NGX_Parameter_DLSS_Exposure_Scale, 1.0);
|
|
params->Set(NVSDK_NGX_Parameter_DLSS_Pre_Exposure, dispatchDesc->preExposure);
|
|
params->Set(NVSDK_NGX_Parameter_Reset, dispatchDesc->reset ? 1 : 0);
|
|
params->Set(NVSDK_NGX_Parameter_Width, dispatchDesc->renderSize.width);
|
|
params->Set(NVSDK_NGX_Parameter_Height, dispatchDesc->renderSize.height);
|
|
params->Set(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Width, dispatchDesc->renderSize.width);
|
|
params->Set(NVSDK_NGX_Parameter_DLSS_Render_Subrect_Dimensions_Height, dispatchDesc->renderSize.height);
|
|
|
|
// Clear last frames image views
|
|
LOG_DEBUG("Clear last frames image views");
|
|
if (depthImageView != nullptr)
|
|
vkDestroyImageView(_vkDevice, depthImageView, nullptr);
|
|
|
|
if (expImageView != nullptr)
|
|
vkDestroyImageView(_vkDevice, expImageView, nullptr);
|
|
|
|
if (biasImageView != nullptr)
|
|
vkDestroyImageView(_vkDevice, biasImageView, nullptr);
|
|
|
|
if (colorImageView != nullptr)
|
|
vkDestroyImageView(_vkDevice, colorImageView, nullptr);
|
|
|
|
if (mvImageView != nullptr)
|
|
vkDestroyImageView(_vkDevice, mvImageView, nullptr);
|
|
|
|
if (outputImageView != nullptr)
|
|
vkDestroyImageView(_vkDevice, outputImageView, nullptr);
|
|
|
|
if (fsrReactiveView != nullptr)
|
|
vkDestroyImageView(_vkDevice, fsrReactiveView, nullptr);
|
|
|
|
if (fsrTransparencyView != nullptr)
|
|
vkDestroyImageView(_vkDevice, fsrTransparencyView, nullptr);
|
|
|
|
// generate new ones with nvidia resource infos
|
|
if (dispatchDesc->depth.resource == nullptr || !CreateIVandNVRes(dispatchDesc->depth, &depthImageView, &depthNVRes))
|
|
{
|
|
LOG_ERROR("Depth error!");
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
}
|
|
else
|
|
{
|
|
params->Set(NVSDK_NGX_Parameter_Depth, &depthNVRes);
|
|
}
|
|
|
|
if (dispatchDesc->exposure.resource != nullptr &&
|
|
CreateIVandNVRes(dispatchDesc->exposure, &expImageView, &expNVRes))
|
|
{
|
|
params->Set(NVSDK_NGX_Parameter_ExposureTexture, &expNVRes);
|
|
}
|
|
|
|
if (dispatchDesc->reactive.resource != nullptr &&
|
|
CreateIVandNVRes(dispatchDesc->reactive, &biasImageView, &biasNVRes))
|
|
{
|
|
params->Set(NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, &biasNVRes);
|
|
}
|
|
|
|
if (dispatchDesc->color.resource == nullptr || !CreateIVandNVRes(dispatchDesc->color, &colorImageView, &colorNVRes))
|
|
{
|
|
LOG_ERROR("Color error!");
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
}
|
|
else
|
|
{
|
|
params->Set(NVSDK_NGX_Parameter_Color, &colorNVRes);
|
|
}
|
|
|
|
if (dispatchDesc->motionVectors.resource == nullptr ||
|
|
!CreateIVandNVRes(dispatchDesc->motionVectors, &mvImageView, &mvNVRes))
|
|
{
|
|
LOG_ERROR("Motion Vectors error!");
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
}
|
|
else
|
|
{
|
|
params->Set(NVSDK_NGX_Parameter_MotionVectors, &mvNVRes);
|
|
}
|
|
|
|
if (dispatchDesc->output.resource == nullptr ||
|
|
!CreateIVandNVRes(dispatchDesc->output, &outputImageView, &outputNVRes))
|
|
{
|
|
LOG_ERROR("Output error!");
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
}
|
|
else
|
|
{
|
|
params->Set(NVSDK_NGX_Parameter_Output, &outputNVRes);
|
|
}
|
|
|
|
if (dispatchDesc->transparencyAndComposition.resource != nullptr &&
|
|
CreateIVandNVRes(dispatchDesc->transparencyAndComposition, &fsrTransparencyView, &fsrTransparencyNVRes))
|
|
{
|
|
params->Set("FSR.transparencyAndComposition", &fsrTransparencyNVRes);
|
|
}
|
|
|
|
if (dispatchDesc->reactive.resource != nullptr &&
|
|
CreateIVandNVRes(dispatchDesc->reactive, &fsrReactiveView, &fsrReactiveNVRes))
|
|
{
|
|
params->Set("FSR.reactive", &fsrReactiveNVRes);
|
|
}
|
|
|
|
params->Set("FSR.cameraNear", dispatchDesc->cameraNear);
|
|
params->Set("FSR.cameraFar", dispatchDesc->cameraFar);
|
|
params->Set("FSR.cameraFovAngleVertical", dispatchDesc->cameraFovAngleVertical);
|
|
params->Set("FSR.frameTimeDelta", dispatchDesc->frameTimeDelta);
|
|
params->Set("FSR.viewSpaceToMetersFactor", dispatchDesc->viewSpaceToMetersFactor);
|
|
params->Set(NVSDK_NGX_Parameter_Sharpness, dispatchDesc->sharpness);
|
|
|
|
LOG_DEBUG("handle: {:X}, internalResolution: {}x{}", handle->Id, dispatchDesc->renderSize.width,
|
|
dispatchDesc->renderSize.height);
|
|
|
|
State::Instance().setInputApiName = "FFX-VK";
|
|
|
|
auto evalResult =
|
|
NVSDK_NGX_VULKAN_EvaluateFeature((VkCommandBuffer) dispatchDesc->commandList, handle, params, nullptr);
|
|
|
|
if (evalResult == NVSDK_NGX_Result_Success)
|
|
return FFX_API_RETURN_OK;
|
|
|
|
LOG_ERROR("evalResult: {:X}", (UINT) evalResult);
|
|
return FFX_API_RETURN_ERROR_RUNTIME_ERROR;
|
|
}
|