mirror of
https://github.com/godotengine/godot
synced 2024-09-16 03:47:09 +00:00
057367bf4f
Introduces support for FSR2 as a new upscaler option available from the project settings. Also introduces an specific render list for surfaces that require motion and the ability to derive motion vectors from depth buffer and camera motion.
1374 lines
74 KiB
C++
1374 lines
74 KiB
C++
// This file is part of the FidelityFX SDK.
|
|
//
|
|
// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
#include <algorithm> // for max used inside SPD CPU code.
|
|
#include <cmath> // for fabs, abs, sinf, sqrt, etc.
|
|
#include <string.h> // for memset
|
|
#include <cfloat> // for FLT_EPSILON
|
|
#include "ffx_fsr2.h"
|
|
#define FFX_CPU
|
|
#include "shaders/ffx_core.h"
|
|
#include "shaders/ffx_fsr1.h"
|
|
#include "shaders/ffx_spd.h"
|
|
#include "shaders/ffx_fsr2_callbacks_hlsl.h"
|
|
|
|
#include "ffx_fsr2_maximum_bias.h"
|
|
|
|
#ifdef __clang__
|
|
#pragma clang diagnostic ignored "-Wunused-variable"
|
|
#endif
|
|
|
|
// -- GODOT start --
|
|
#ifndef _countof
|
|
#define _countof(array) (sizeof(array) / sizeof(array[0]))
|
|
#endif
|
|
|
|
#ifndef _MSC_VER
|
|
#include <wchar.h>
|
|
#define wcscpy_s wcscpy
|
|
#endif
|
|
// -- GODOT end --
|
|
|
|
// max queued frames for descriptor management
|
|
static const uint32_t FSR2_MAX_QUEUED_FRAMES = 16;
|
|
|
|
#include "ffx_fsr2_private.h"
|
|
|
|
// lists to map shader resource bindpoint name to resource identifier
|
|
typedef struct ResourceBinding
|
|
{
|
|
uint32_t index;
|
|
wchar_t name[64];
|
|
}ResourceBinding;
|
|
|
|
static const ResourceBinding srvResourceBindingTable[] =
|
|
{
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR, L"r_input_color_jittered"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY, L"r_input_opaque_only"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS, L"r_input_motion_vectors"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_DEPTH, L"r_input_depth" },
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_EXPOSURE, L"r_input_exposure"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE, L"r_auto_exposure"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK, L"r_reactive_mask"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK, L"r_transparency_and_composition_mask"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH, L"r_reconstructed_previous_nearest_depth"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS, L"r_dilated_motion_vectors"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_PREVIOUS_DILATED_MOTION_VECTORS, L"r_previous_dilated_motion_vectors"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_DEPTH, L"r_dilatedDepth"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR, L"r_internal_upscaled_color"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS, L"r_lock_status"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_PREPARED_INPUT_COLOR, L"r_prepared_input_color"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY, L"r_luma_history" },
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_RCAS_INPUT, L"r_rcas_input"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_LANCZOS_LUT, L"r_lanczos_lut"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE, L"r_imgMips"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE, L"r_img_mip_shading_change"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_5, L"r_img_mip_5"},
|
|
{FFX_FSR2_RESOURCE_IDENTITIER_UPSAMPLE_MAXIMUM_BIAS_LUT, L"r_upsample_maximum_bias_lut"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS, L"r_dilated_reactive_masks"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_NEW_LOCKS, L"r_new_locks"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_INPUT_LUMA, L"r_lock_input_luma"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR, L"r_input_prev_color_pre_alpha"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR, L"r_input_prev_color_post_alpha"},
|
|
};
|
|
|
|
static const ResourceBinding uavResourceBindingTable[] =
|
|
{
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH, L"rw_reconstructed_previous_nearest_depth"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS, L"rw_dilated_motion_vectors"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_DEPTH, L"rw_dilatedDepth"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR, L"rw_internal_upscaled_color"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS, L"rw_lock_status"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_PREPARED_INPUT_COLOR, L"rw_prepared_input_color"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY, L"rw_luma_history"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT, L"rw_upscaled_output"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE, L"rw_img_mip_shading_change"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_5, L"rw_img_mip_5"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS, L"rw_dilated_reactive_masks"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE, L"rw_auto_exposure"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT, L"rw_spd_global_atomic"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_NEW_LOCKS, L"rw_new_locks"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_INPUT_LUMA, L"rw_lock_input_luma"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE, L"rw_output_autoreactive"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_AUTOCOMPOSITION, L"rw_output_autocomposition"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR, L"rw_output_prev_color_pre_alpha"},
|
|
{FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR, L"rw_output_prev_color_post_alpha"},
|
|
};
|
|
|
|
static const ResourceBinding cbResourceBindingTable[] =
|
|
{
|
|
{FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_FSR2, L"cbFSR2"},
|
|
{FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_SPD, L"cbSPD"},
|
|
{FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_RCAS, L"cbRCAS"},
|
|
{FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE, L"cbGenerateReactive"},
|
|
};
|
|
|
|
// Broad structure of the root signature.
|
|
typedef enum Fsr2RootSignatureLayout {
|
|
|
|
FSR2_ROOT_SIGNATURE_LAYOUT_UAVS,
|
|
FSR2_ROOT_SIGNATURE_LAYOUT_SRVS,
|
|
FSR2_ROOT_SIGNATURE_LAYOUT_CONSTANTS,
|
|
FSR2_ROOT_SIGNATURE_LAYOUT_CONSTANTS_REGISTER_1,
|
|
FSR2_ROOT_SIGNATURE_LAYOUT_PARAMETER_COUNT
|
|
} Fsr2RootSignatureLayout;
|
|
|
|
typedef struct Fsr2RcasConstants {
|
|
|
|
uint32_t rcasConfig[4];
|
|
} FfxRcasConstants;
|
|
|
|
typedef struct Fsr2SpdConstants {
|
|
|
|
uint32_t mips;
|
|
uint32_t numworkGroups;
|
|
uint32_t workGroupOffset[2];
|
|
uint32_t renderSize[2];
|
|
} Fsr2SpdConstants;
|
|
|
|
typedef struct Fsr2GenerateReactiveConstants
|
|
{
|
|
float scale;
|
|
float threshold;
|
|
float binaryValue;
|
|
uint32_t flags;
|
|
|
|
} Fsr2GenerateReactiveConstants;
|
|
|
|
typedef struct Fsr2GenerateReactiveConstants2
|
|
{
|
|
float autoTcThreshold;
|
|
float autoTcScale;
|
|
float autoReactiveScale;
|
|
float autoReactiveMax;
|
|
|
|
} Fsr2GenerateReactiveConstants2;
|
|
|
|
typedef union Fsr2SecondaryUnion {
|
|
|
|
Fsr2RcasConstants rcas;
|
|
Fsr2SpdConstants spd;
|
|
Fsr2GenerateReactiveConstants2 autogenReactive;
|
|
} Fsr2SecondaryUnion;
|
|
|
|
typedef struct Fsr2ResourceDescription {
|
|
|
|
uint32_t id;
|
|
const wchar_t* name;
|
|
FfxResourceUsage usage;
|
|
FfxSurfaceFormat format;
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t mipCount;
|
|
FfxResourceFlags flags;
|
|
uint32_t initDataSize;
|
|
void* initData;
|
|
} Fsr2ResourceDescription;
|
|
|
|
FfxConstantBuffer globalFsr2ConstantBuffers[4] = {
|
|
{ sizeof(Fsr2Constants) / sizeof(uint32_t) },
|
|
{ sizeof(Fsr2SpdConstants) / sizeof(uint32_t) },
|
|
{ sizeof(Fsr2RcasConstants) / sizeof(uint32_t) },
|
|
{ sizeof(Fsr2GenerateReactiveConstants) / sizeof(uint32_t) }
|
|
};
|
|
|
|
// Lanczos
|
|
static float lanczos2(float value)
|
|
{
|
|
return abs(value) < FFX_EPSILON ? 1.f : (sinf(FFX_PI * value) / (FFX_PI * value)) * (sinf(0.5f * FFX_PI * value) / (0.5f * FFX_PI * value));
|
|
}
|
|
|
|
// Calculate halton number for index and base.
|
|
static float halton(int32_t index, int32_t base)
|
|
{
|
|
float f = 1.0f, result = 0.0f;
|
|
|
|
for (int32_t currentIndex = index; currentIndex > 0;) {
|
|
|
|
f /= (float)base;
|
|
result = result + f * (float)(currentIndex % base);
|
|
currentIndex = (uint32_t)(floorf((float)(currentIndex) / (float)(base)));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void fsr2DebugCheckDispatch(FfxFsr2Context_Private* context, const FfxFsr2DispatchDescription* params)
|
|
{
|
|
if (params->commandList == nullptr)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"commandList is null");
|
|
}
|
|
|
|
if (params->color.resource == nullptr)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"color resource is null");
|
|
}
|
|
|
|
if (params->depth.resource == nullptr)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"depth resource is null");
|
|
}
|
|
|
|
if (params->motionVectors.resource == nullptr)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"motionVectors resource is null");
|
|
}
|
|
|
|
if (params->exposure.resource != nullptr)
|
|
{
|
|
if ((context->contextDescription.flags & FFX_FSR2_ENABLE_AUTO_EXPOSURE) == FFX_FSR2_ENABLE_AUTO_EXPOSURE)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"exposure resource provided, however auto exposure flag is present");
|
|
}
|
|
}
|
|
|
|
if (params->output.resource == nullptr)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"output resource is null");
|
|
}
|
|
|
|
if (fabs(params->jitterOffset.x) > 1.0f || fabs(params->jitterOffset.y) > 1.0f)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"jitterOffset contains value outside of expected range [-1.0, 1.0]");
|
|
}
|
|
|
|
if ((params->motionVectorScale.x > (float)context->contextDescription.maxRenderSize.width) ||
|
|
(params->motionVectorScale.y > (float)context->contextDescription.maxRenderSize.height))
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"motionVectorScale contains scale value greater than maxRenderSize");
|
|
}
|
|
if ((params->motionVectorScale.x == 0.0f) ||
|
|
(params->motionVectorScale.y == 0.0f))
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"motionVectorScale contains zero scale value");
|
|
}
|
|
|
|
if ((params->renderSize.width > context->contextDescription.maxRenderSize.width) ||
|
|
(params->renderSize.height > context->contextDescription.maxRenderSize.height))
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"renderSize is greater than context maxRenderSize");
|
|
}
|
|
if ((params->renderSize.width == 0) ||
|
|
(params->renderSize.height == 0))
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"renderSize contains zero dimension");
|
|
}
|
|
|
|
if (params->sharpness < 0.0f || params->sharpness > 1.0f)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"sharpness contains value outside of expected range [0.0, 1.0]");
|
|
}
|
|
|
|
if (params->frameTimeDelta < 1.0f)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING, L"frameTimeDelta is less than 1.0f - this value should be milliseconds (~16.6f for 60fps)");
|
|
}
|
|
|
|
if (params->preExposure == 0.0f)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"preExposure provided as 0.0f which is invalid");
|
|
}
|
|
|
|
bool infiniteDepth = (context->contextDescription.flags & FFX_FSR2_ENABLE_DEPTH_INFINITE) == FFX_FSR2_ENABLE_DEPTH_INFINITE;
|
|
bool inverseDepth = (context->contextDescription.flags & FFX_FSR2_ENABLE_DEPTH_INVERTED) == FFX_FSR2_ENABLE_DEPTH_INVERTED;
|
|
|
|
if (inverseDepth)
|
|
{
|
|
if (params->cameraNear < params->cameraFar)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING,
|
|
L"FFX_FSR2_ENABLE_DEPTH_INVERTED flag is present yet cameraNear is less than cameraFar");
|
|
}
|
|
if (infiniteDepth)
|
|
{
|
|
if (params->cameraNear != FLT_MAX)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING,
|
|
L"FFX_FSR2_ENABLE_DEPTH_INFINITE and FFX_FSR2_ENABLE_DEPTH_INVERTED present, yet cameraNear != FLT_MAX");
|
|
}
|
|
}
|
|
if (params->cameraFar < 0.075f)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING,
|
|
L"FFX_FSR2_ENABLE_DEPTH_INFINITE and FFX_FSR2_ENABLE_DEPTH_INVERTED present, cameraFar value is very low which may result in depth separation artefacting");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (params->cameraNear > params->cameraFar)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING,
|
|
L"cameraNear is greater than cameraFar in non-inverted-depth context");
|
|
}
|
|
if (infiniteDepth)
|
|
{
|
|
if (params->cameraFar != FLT_MAX)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING,
|
|
L"FFX_FSR2_ENABLE_DEPTH_INFINITE and FFX_FSR2_ENABLE_DEPTH_INVERTED present, yet cameraFar != FLT_MAX");
|
|
}
|
|
}
|
|
if (params->cameraNear < 0.075f)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_WARNING,
|
|
L"FFX_FSR2_ENABLE_DEPTH_INFINITE and FFX_FSR2_ENABLE_DEPTH_INVERTED present, cameraNear value is very low which may result in depth separation artefacting");
|
|
}
|
|
}
|
|
|
|
if (params->cameraFovAngleVertical <= 0.0f)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"cameraFovAngleVertical is 0.0f - this value should be > 0.0f");
|
|
}
|
|
if (params->cameraFovAngleVertical > FFX_PI)
|
|
{
|
|
context->contextDescription.fpMessage(FFX_FSR2_MESSAGE_TYPE_ERROR, L"cameraFovAngleVertical is greater than 180 degrees/PI");
|
|
}
|
|
}
|
|
|
|
static FfxErrorCode patchResourceBindings(FfxPipelineState* inoutPipeline)
|
|
{
|
|
for (uint32_t srvIndex = 0; srvIndex < inoutPipeline->srvCount; ++srvIndex)
|
|
{
|
|
int32_t mapIndex = 0;
|
|
for (mapIndex = 0; mapIndex < _countof(srvResourceBindingTable); ++mapIndex)
|
|
{
|
|
if (0 == wcscmp(srvResourceBindingTable[mapIndex].name, inoutPipeline->srvResourceBindings[srvIndex].name))
|
|
break;
|
|
}
|
|
if (mapIndex == _countof(srvResourceBindingTable))
|
|
return FFX_ERROR_INVALID_ARGUMENT;
|
|
|
|
inoutPipeline->srvResourceBindings[srvIndex].resourceIdentifier = srvResourceBindingTable[mapIndex].index;
|
|
}
|
|
|
|
for (uint32_t uavIndex = 0; uavIndex < inoutPipeline->uavCount; ++uavIndex)
|
|
{
|
|
int32_t mapIndex = 0;
|
|
for (mapIndex = 0; mapIndex < _countof(uavResourceBindingTable); ++mapIndex)
|
|
{
|
|
if (0 == wcscmp(uavResourceBindingTable[mapIndex].name, inoutPipeline->uavResourceBindings[uavIndex].name))
|
|
break;
|
|
}
|
|
if (mapIndex == _countof(uavResourceBindingTable))
|
|
return FFX_ERROR_INVALID_ARGUMENT;
|
|
|
|
inoutPipeline->uavResourceBindings[uavIndex].resourceIdentifier = uavResourceBindingTable[mapIndex].index;
|
|
}
|
|
|
|
for (uint32_t cbIndex = 0; cbIndex < inoutPipeline->constCount; ++cbIndex)
|
|
{
|
|
int32_t mapIndex = 0;
|
|
for (mapIndex = 0; mapIndex < _countof(cbResourceBindingTable); ++mapIndex)
|
|
{
|
|
if (0 == wcscmp(cbResourceBindingTable[mapIndex].name, inoutPipeline->cbResourceBindings[cbIndex].name))
|
|
break;
|
|
}
|
|
if (mapIndex == _countof(cbResourceBindingTable))
|
|
return FFX_ERROR_INVALID_ARGUMENT;
|
|
|
|
inoutPipeline->cbResourceBindings[cbIndex].resourceIdentifier = cbResourceBindingTable[mapIndex].index;
|
|
}
|
|
|
|
return FFX_OK;
|
|
}
|
|
|
|
|
|
static FfxErrorCode createPipelineStates(FfxFsr2Context_Private* context)
|
|
{
|
|
FFX_ASSERT(context);
|
|
|
|
const size_t samplerCount = 2;
|
|
FfxFilterType samplers[samplerCount];
|
|
samplers[0] = FFX_FILTER_TYPE_POINT;
|
|
samplers[1] = FFX_FILTER_TYPE_LINEAR;
|
|
|
|
const size_t rootConstantCount = 2;
|
|
uint32_t rootConstants[rootConstantCount];
|
|
rootConstants[0] = sizeof(Fsr2Constants) / sizeof(uint32_t);
|
|
rootConstants[1] = sizeof(Fsr2SecondaryUnion) / sizeof(uint32_t);
|
|
|
|
FfxPipelineDescription pipelineDescription;
|
|
pipelineDescription.contextFlags = context->contextDescription.flags;
|
|
pipelineDescription.samplerCount = samplerCount;
|
|
pipelineDescription.samplers = samplers;
|
|
pipelineDescription.rootConstantBufferCount = rootConstantCount;
|
|
pipelineDescription.rootConstantBufferSizes = rootConstants;
|
|
|
|
// New interface: will handle RootSignature in backend
|
|
// set up pipeline descriptor (basically RootSignature and binding)
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_COMPUTE_LUMINANCE_PYRAMID, &pipelineDescription, &context->pipelineComputeLuminancePyramid));
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_RCAS, &pipelineDescription, &context->pipelineRCAS));
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_GENERATE_REACTIVE, &pipelineDescription, &context->pipelineGenerateReactive));
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_TCR_AUTOGENERATE, &pipelineDescription, &context->pipelineTcrAutogenerate));
|
|
|
|
pipelineDescription.rootConstantBufferCount = 1;
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_DEPTH_CLIP, &pipelineDescription, &context->pipelineDepthClip));
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_RECONSTRUCT_PREVIOUS_DEPTH, &pipelineDescription, &context->pipelineReconstructPreviousDepth));
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_LOCK, &pipelineDescription, &context->pipelineLock));
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_ACCUMULATE, &pipelineDescription, &context->pipelineAccumulate));
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreatePipeline(&context->contextDescription.callbacks, FFX_FSR2_PASS_ACCUMULATE_SHARPEN, &pipelineDescription, &context->pipelineAccumulateSharpen));
|
|
|
|
// for each pipeline: re-route/fix-up IDs based on names
|
|
patchResourceBindings(&context->pipelineDepthClip);
|
|
patchResourceBindings(&context->pipelineReconstructPreviousDepth);
|
|
patchResourceBindings(&context->pipelineLock);
|
|
patchResourceBindings(&context->pipelineAccumulate);
|
|
patchResourceBindings(&context->pipelineComputeLuminancePyramid);
|
|
patchResourceBindings(&context->pipelineAccumulateSharpen);
|
|
patchResourceBindings(&context->pipelineRCAS);
|
|
patchResourceBindings(&context->pipelineGenerateReactive);
|
|
patchResourceBindings(&context->pipelineTcrAutogenerate);
|
|
|
|
return FFX_OK;
|
|
}
|
|
|
|
static FfxErrorCode generateReactiveMaskInternal(FfxFsr2Context_Private* contextPrivate, const FfxFsr2DispatchDescription* params);
|
|
|
|
static FfxErrorCode fsr2Create(FfxFsr2Context_Private* context, const FfxFsr2ContextDescription* contextDescription)
|
|
{
|
|
FFX_ASSERT(context);
|
|
FFX_ASSERT(contextDescription);
|
|
|
|
// Setup the data for implementation.
|
|
memset(context, 0, sizeof(FfxFsr2Context_Private));
|
|
context->device = contextDescription->device;
|
|
|
|
memcpy(&context->contextDescription, contextDescription, sizeof(FfxFsr2ContextDescription));
|
|
|
|
if ((context->contextDescription.flags & FFX_FSR2_ENABLE_DEBUG_CHECKING) == FFX_FSR2_ENABLE_DEBUG_CHECKING)
|
|
{
|
|
if (context->contextDescription.fpMessage == nullptr)
|
|
{
|
|
FFX_ASSERT(context->contextDescription.fpMessage != nullptr);
|
|
// remove the debug checking flag - we have no message function
|
|
context->contextDescription.flags &= ~FFX_FSR2_ENABLE_DEBUG_CHECKING;
|
|
}
|
|
}
|
|
|
|
// Create the device.
|
|
FfxErrorCode errorCode = context->contextDescription.callbacks.fpCreateBackendContext(&context->contextDescription.callbacks, context->device);
|
|
FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode);
|
|
|
|
// call out for device caps.
|
|
errorCode = context->contextDescription.callbacks.fpGetDeviceCapabilities(&context->contextDescription.callbacks, &context->deviceCapabilities, context->device);
|
|
FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode);
|
|
|
|
// set defaults
|
|
context->firstExecution = true;
|
|
context->resourceFrameIndex = 0;
|
|
|
|
context->constants.displaySize[0] = contextDescription->displaySize.width;
|
|
context->constants.displaySize[1] = contextDescription->displaySize.height;
|
|
|
|
// generate the data for the LUT.
|
|
const uint32_t lanczos2LutWidth = 128;
|
|
int16_t lanczos2Weights[lanczos2LutWidth] = { };
|
|
|
|
for (uint32_t currentLanczosWidthIndex = 0; currentLanczosWidthIndex < lanczos2LutWidth; currentLanczosWidthIndex++) {
|
|
|
|
const float x = 2.0f * currentLanczosWidthIndex / float(lanczos2LutWidth - 1);
|
|
const float y = lanczos2(x);
|
|
lanczos2Weights[currentLanczosWidthIndex] = int16_t(roundf(y * 32767.0f));
|
|
}
|
|
|
|
// upload path only supports R16_SNORM, let's go and convert
|
|
int16_t maximumBias[FFX_FSR2_MAXIMUM_BIAS_TEXTURE_WIDTH * FFX_FSR2_MAXIMUM_BIAS_TEXTURE_HEIGHT];
|
|
for (uint32_t i = 0; i < FFX_FSR2_MAXIMUM_BIAS_TEXTURE_WIDTH * FFX_FSR2_MAXIMUM_BIAS_TEXTURE_HEIGHT; ++i) {
|
|
|
|
maximumBias[i] = int16_t(roundf(ffxFsr2MaximumBias[i] / 2.0f * 32767.0f));
|
|
}
|
|
|
|
uint8_t defaultReactiveMaskData = 0U;
|
|
uint32_t atomicInitData = 0U;
|
|
float defaultExposure[] = { 0.0f, 0.0f };
|
|
const FfxResourceType texture1dResourceType = (context->contextDescription.flags & FFX_FSR2_ENABLE_TEXTURE1D_USAGE) ? FFX_RESOURCE_TYPE_TEXTURE1D : FFX_RESOURCE_TYPE_TEXTURE2D;
|
|
|
|
// declare internal resources needed
|
|
const Fsr2ResourceDescription internalSurfaceDesc[] = {
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_PREPARED_INPUT_COLOR, L"FSR2_PreparedInputColor", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH, L"FSR2_ReconstructedPrevNearestDepth", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R32_UINT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_1, L"FSR2_InternalDilatedVelocity1", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R16G16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_2, L"FSR2_InternalDilatedVelocity2", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R16G16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_DEPTH, L"FSR2_DilatedDepth", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R32_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_1, L"FSR2_LockStatus1", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R16G16_FLOAT, contextDescription->displaySize.width, contextDescription->displaySize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_2, L"FSR2_LockStatus2", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R16G16_FLOAT, contextDescription->displaySize.width, contextDescription->displaySize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_INPUT_LUMA, L"FSR2_LockInputLuma", (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R16_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_NEW_LOCKS, L"FSR2_NewLocks", (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R8_UNORM, contextDescription->displaySize.width, contextDescription->displaySize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1, L"FSR2_InternalUpscaled1", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, contextDescription->displaySize.width, contextDescription->displaySize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2, L"FSR2_InternalUpscaled2", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, contextDescription->displaySize.width, contextDescription->displaySize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE, L"FSR2_ExposureMips", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R16_FLOAT, contextDescription->maxRenderSize.width / 2, contextDescription->maxRenderSize.height / 2, 0, FFX_RESOURCE_FLAGS_ALIASABLE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_1, L"FSR2_LumaHistory1", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R8G8B8A8_UNORM, contextDescription->displaySize.width, contextDescription->displaySize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_2, L"FSR2_LumaHistory2", (FfxResourceUsage)(FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R8G8B8A8_UNORM, contextDescription->displaySize.width, contextDescription->displaySize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT, L"FSR2_SpdAtomicCounter", (FfxResourceUsage)(FFX_RESOURCE_USAGE_UAV),
|
|
FFX_SURFACE_FORMAT_R32_UINT, 1, 1, 1, FFX_RESOURCE_FLAGS_ALIASABLE, sizeof(atomicInitData), &atomicInitData },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS, L"FSR2_DilatedReactiveMasks", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R8G8_UNORM, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_ALIASABLE },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_LANCZOS_LUT, L"FSR2_LanczosLutData", FFX_RESOURCE_USAGE_READ_ONLY,
|
|
FFX_SURFACE_FORMAT_R16_SNORM, lanczos2LutWidth, 1, 1, FFX_RESOURCE_FLAGS_NONE, sizeof(lanczos2Weights), lanczos2Weights },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY, L"FSR2_DefaultReactiviyMask", FFX_RESOURCE_USAGE_READ_ONLY,
|
|
FFX_SURFACE_FORMAT_R8_UNORM, 1, 1, 1, FFX_RESOURCE_FLAGS_NONE, sizeof(defaultReactiveMaskData), &defaultReactiveMaskData },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTITIER_UPSAMPLE_MAXIMUM_BIAS_LUT, L"FSR2_MaximumUpsampleBias", FFX_RESOURCE_USAGE_READ_ONLY,
|
|
FFX_SURFACE_FORMAT_R16_SNORM, FFX_FSR2_MAXIMUM_BIAS_TEXTURE_WIDTH, FFX_FSR2_MAXIMUM_BIAS_TEXTURE_HEIGHT, 1, FFX_RESOURCE_FLAGS_NONE, sizeof(maximumBias), maximumBias },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE, L"FSR2_DefaultExposure", FFX_RESOURCE_USAGE_READ_ONLY,
|
|
FFX_SURFACE_FORMAT_R32G32_FLOAT, 1, 1, 1, FFX_RESOURCE_FLAGS_NONE, sizeof(defaultExposure), defaultExposure },
|
|
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE, L"FSR2_AutoExposure", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R32G32_FLOAT, 1, 1, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
|
|
// only one for now, will need pingpont to respect the motion vectors
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE, L"FSR2_AutoReactive", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R8_UNORM, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_AUTOCOMPOSITION, L"FSR2_AutoComposition", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R8_UNORM, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_1, L"FSR2_PrevPreAlpha0", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R11G11B10_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_1, L"FSR2_PrevPostAlpha0", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R11G11B10_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_2, L"FSR2_PrevPreAlpha1", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R11G11B10_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
{ FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_2, L"FSR2_PrevPostAlpha1", FFX_RESOURCE_USAGE_UAV,
|
|
FFX_SURFACE_FORMAT_R11G11B10_FLOAT, contextDescription->maxRenderSize.width, contextDescription->maxRenderSize.height, 1, FFX_RESOURCE_FLAGS_NONE },
|
|
|
|
};
|
|
|
|
// clear the SRV resources to NULL.
|
|
memset(context->srvResources, 0, sizeof(context->srvResources));
|
|
|
|
for (int32_t currentSurfaceIndex = 0; currentSurfaceIndex < FFX_ARRAY_ELEMENTS(internalSurfaceDesc); ++currentSurfaceIndex) {
|
|
|
|
const Fsr2ResourceDescription* currentSurfaceDescription = &internalSurfaceDesc[currentSurfaceIndex];
|
|
const FfxResourceType resourceType = currentSurfaceDescription->height > 1 ? FFX_RESOURCE_TYPE_TEXTURE2D : texture1dResourceType;
|
|
const FfxResourceDescription resourceDescription = { resourceType, currentSurfaceDescription->format, currentSurfaceDescription->width, currentSurfaceDescription->height, 1, currentSurfaceDescription->mipCount };
|
|
const FfxResourceStates initialState = (currentSurfaceDescription->usage == FFX_RESOURCE_USAGE_READ_ONLY) ? FFX_RESOURCE_STATE_COMPUTE_READ : FFX_RESOURCE_STATE_UNORDERED_ACCESS;
|
|
const FfxCreateResourceDescription createResourceDescription = { FFX_HEAP_TYPE_DEFAULT, resourceDescription, initialState, currentSurfaceDescription->initDataSize, currentSurfaceDescription->initData, currentSurfaceDescription->name, currentSurfaceDescription->usage, currentSurfaceDescription->id };
|
|
|
|
FFX_VALIDATE(context->contextDescription.callbacks.fpCreateResource(&context->contextDescription.callbacks, &createResourceDescription, &context->srvResources[currentSurfaceDescription->id]));
|
|
}
|
|
|
|
// copy resources to uavResrouces list
|
|
memcpy(context->uavResources, context->srvResources, sizeof(context->srvResources));
|
|
|
|
// avoid compiling pipelines on first render
|
|
{
|
|
context->refreshPipelineStates = false;
|
|
errorCode = createPipelineStates(context);
|
|
FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode);
|
|
}
|
|
return FFX_OK;
|
|
}
|
|
|
|
static void fsr2SafeReleasePipeline(FfxFsr2Context_Private* context, FfxPipelineState* pipeline)
|
|
{
|
|
FFX_ASSERT(pipeline);
|
|
|
|
context->contextDescription.callbacks.fpDestroyPipeline(&context->contextDescription.callbacks, pipeline);
|
|
}
|
|
|
|
static void fsr2SafeReleaseResource(FfxFsr2Context_Private* context, FfxResourceInternal resource)
|
|
{
|
|
context->contextDescription.callbacks.fpDestroyResource(&context->contextDescription.callbacks, resource);
|
|
}
|
|
|
|
static void fsr2SafeReleaseDevice(FfxFsr2Context_Private* context, FfxDevice* device)
|
|
{
|
|
if (*device == nullptr) {
|
|
return;
|
|
}
|
|
|
|
context->contextDescription.callbacks.fpDestroyBackendContext(&context->contextDescription.callbacks);
|
|
*device = nullptr;
|
|
}
|
|
|
|
static FfxErrorCode fsr2Release(FfxFsr2Context_Private* context)
|
|
{
|
|
FFX_ASSERT(context);
|
|
|
|
fsr2SafeReleasePipeline(context, &context->pipelineDepthClip);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineReconstructPreviousDepth);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineLock);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineAccumulate);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineAccumulateSharpen);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineRCAS);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineComputeLuminancePyramid);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineGenerateReactive);
|
|
fsr2SafeReleasePipeline(context, &context->pipelineTcrAutogenerate);
|
|
|
|
// unregister resources not created internally
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_DEPTH] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_EXPOSURE] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_RCAS_INPUT] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT] = { FFX_FSR2_RESOURCE_IDENTIFIER_NULL };
|
|
|
|
// release internal resources
|
|
for (int32_t currentResourceIndex = 0; currentResourceIndex < FFX_FSR2_RESOURCE_IDENTIFIER_COUNT; ++currentResourceIndex) {
|
|
|
|
fsr2SafeReleaseResource(context, context->srvResources[currentResourceIndex]);
|
|
}
|
|
|
|
fsr2SafeReleaseDevice(context, &context->device);
|
|
|
|
return FFX_OK;
|
|
}
|
|
|
|
static void setupDeviceDepthToViewSpaceDepthParams(FfxFsr2Context_Private* context, const FfxFsr2DispatchDescription* params)
|
|
{
|
|
const bool bInverted = (context->contextDescription.flags & FFX_FSR2_ENABLE_DEPTH_INVERTED) == FFX_FSR2_ENABLE_DEPTH_INVERTED;
|
|
const bool bInfinite = (context->contextDescription.flags & FFX_FSR2_ENABLE_DEPTH_INFINITE) == FFX_FSR2_ENABLE_DEPTH_INFINITE;
|
|
|
|
// make sure it has no impact if near and far plane values are swapped in dispatch params
|
|
// the flags "inverted" and "infinite" will decide what transform to use
|
|
float fMin = FFX_MINIMUM(params->cameraNear, params->cameraFar);
|
|
float fMax = FFX_MAXIMUM(params->cameraNear, params->cameraFar);
|
|
|
|
if (bInverted) {
|
|
float tmp = fMin;
|
|
fMin = fMax;
|
|
fMax = tmp;
|
|
}
|
|
|
|
// a 0 0 0 x
|
|
// 0 b 0 0 y
|
|
// 0 0 c d z
|
|
// 0 0 e 0 1
|
|
|
|
const float fQ = fMax / (fMin - fMax);
|
|
const float d = -1.0f; // for clarity
|
|
|
|
const float matrix_elem_c[2][2] = {
|
|
fQ, // non reversed, non infinite
|
|
-1.0f - FLT_EPSILON, // non reversed, infinite
|
|
fQ, // reversed, non infinite
|
|
0.0f + FLT_EPSILON // reversed, infinite
|
|
};
|
|
|
|
const float matrix_elem_e[2][2] = {
|
|
fQ * fMin, // non reversed, non infinite
|
|
-fMin - FLT_EPSILON, // non reversed, infinite
|
|
fQ * fMin, // reversed, non infinite
|
|
fMax, // reversed, infinite
|
|
};
|
|
|
|
context->constants.deviceToViewDepth[0] = d * matrix_elem_c[bInverted][bInfinite];
|
|
context->constants.deviceToViewDepth[1] = matrix_elem_e[bInverted][bInfinite];
|
|
|
|
// revert x and y coords
|
|
const float aspect = params->renderSize.width / float(params->renderSize.height);
|
|
const float cotHalfFovY = cosf(0.5f * params->cameraFovAngleVertical) / sinf(0.5f * params->cameraFovAngleVertical);
|
|
const float a = cotHalfFovY / aspect;
|
|
const float b = cotHalfFovY;
|
|
|
|
context->constants.deviceToViewDepth[2] = (1.0f / a);
|
|
context->constants.deviceToViewDepth[3] = (1.0f / b);
|
|
}
|
|
|
|
static void scheduleDispatch(FfxFsr2Context_Private* context, const FfxFsr2DispatchDescription* params, const FfxPipelineState* pipeline, uint32_t dispatchX, uint32_t dispatchY)
|
|
{
|
|
FfxComputeJobDescription jobDescriptor = {};
|
|
|
|
for (uint32_t currentShaderResourceViewIndex = 0; currentShaderResourceViewIndex < pipeline->srvCount; ++currentShaderResourceViewIndex) {
|
|
|
|
const uint32_t currentResourceId = pipeline->srvResourceBindings[currentShaderResourceViewIndex].resourceIdentifier;
|
|
const FfxResourceInternal currentResource = context->srvResources[currentResourceId];
|
|
jobDescriptor.srvs[currentShaderResourceViewIndex] = currentResource;
|
|
wcscpy_s(jobDescriptor.srvNames[currentShaderResourceViewIndex], pipeline->srvResourceBindings[currentShaderResourceViewIndex].name);
|
|
}
|
|
|
|
for (uint32_t currentUnorderedAccessViewIndex = 0; currentUnorderedAccessViewIndex < pipeline->uavCount; ++currentUnorderedAccessViewIndex) {
|
|
|
|
const uint32_t currentResourceId = pipeline->uavResourceBindings[currentUnorderedAccessViewIndex].resourceIdentifier;
|
|
wcscpy_s(jobDescriptor.uavNames[currentUnorderedAccessViewIndex], pipeline->uavResourceBindings[currentUnorderedAccessViewIndex].name);
|
|
|
|
if (currentResourceId >= FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_0 && currentResourceId <= FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_12)
|
|
{
|
|
const FfxResourceInternal currentResource = context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE];
|
|
jobDescriptor.uavs[currentUnorderedAccessViewIndex] = currentResource;
|
|
jobDescriptor.uavMip[currentUnorderedAccessViewIndex] = currentResourceId - FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_0;
|
|
}
|
|
else
|
|
{
|
|
const FfxResourceInternal currentResource = context->uavResources[currentResourceId];
|
|
jobDescriptor.uavs[currentUnorderedAccessViewIndex] = currentResource;
|
|
jobDescriptor.uavMip[currentUnorderedAccessViewIndex] = 0;
|
|
}
|
|
}
|
|
|
|
jobDescriptor.dimensions[0] = dispatchX;
|
|
jobDescriptor.dimensions[1] = dispatchY;
|
|
jobDescriptor.dimensions[2] = 1;
|
|
jobDescriptor.pipeline = *pipeline;
|
|
|
|
for (uint32_t currentRootConstantIndex = 0; currentRootConstantIndex < pipeline->constCount; ++currentRootConstantIndex) {
|
|
wcscpy_s( jobDescriptor.cbNames[currentRootConstantIndex], pipeline->cbResourceBindings[currentRootConstantIndex].name);
|
|
jobDescriptor.cbs[currentRootConstantIndex] = globalFsr2ConstantBuffers[pipeline->cbResourceBindings[currentRootConstantIndex].resourceIdentifier];
|
|
jobDescriptor.cbSlotIndex[currentRootConstantIndex] = pipeline->cbResourceBindings[currentRootConstantIndex].slotIndex;
|
|
}
|
|
|
|
FfxGpuJobDescription dispatchJob = { FFX_GPU_JOB_COMPUTE };
|
|
dispatchJob.computeJobDescriptor = jobDescriptor;
|
|
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &dispatchJob);
|
|
}
|
|
|
|
static FfxErrorCode fsr2Dispatch(FfxFsr2Context_Private* context, const FfxFsr2DispatchDescription* params)
|
|
{
|
|
if ((context->contextDescription.flags & FFX_FSR2_ENABLE_DEBUG_CHECKING) == FFX_FSR2_ENABLE_DEBUG_CHECKING)
|
|
{
|
|
fsr2DebugCheckDispatch(context, params);
|
|
}
|
|
// take a short cut to the command list
|
|
FfxCommandList commandList = params->commandList;
|
|
|
|
// try and refresh shaders first. Early exit in case of error.
|
|
if (context->refreshPipelineStates) {
|
|
|
|
context->refreshPipelineStates = false;
|
|
|
|
const FfxErrorCode errorCode = createPipelineStates(context);
|
|
FFX_RETURN_ON_ERROR(errorCode == FFX_OK, errorCode);
|
|
}
|
|
|
|
if (context->firstExecution)
|
|
{
|
|
FfxGpuJobDescription clearJob = { FFX_GPU_JOB_CLEAR_FLOAT };
|
|
|
|
const float clearValuesToZeroFloat[]{ 0.f, 0.f, 0.f, 0.f };
|
|
memcpy(clearJob.clearJobDescriptor.color, clearValuesToZeroFloat, 4 * sizeof(float));
|
|
|
|
clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_1];
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &clearJob);
|
|
clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_2];
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &clearJob);
|
|
clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREPARED_INPUT_COLOR];
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &clearJob);
|
|
}
|
|
|
|
// Prepare per frame descriptor tables
|
|
const bool isOddFrame = !!(context->resourceFrameIndex & 1);
|
|
const uint32_t currentCpuOnlyTableBase = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_COUNT : 0;
|
|
const uint32_t currentGpuTableBase = 2 * FFX_FSR2_RESOURCE_IDENTIFIER_COUNT * context->resourceFrameIndex;
|
|
const uint32_t lockStatusSrvResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_2 : FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_1;
|
|
const uint32_t lockStatusUavResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_1 : FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_2;
|
|
const uint32_t upscaledColorSrvResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2 : FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1;
|
|
const uint32_t upscaledColorUavResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1 : FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2;
|
|
const uint32_t dilatedMotionVectorsResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_2 : FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_1;
|
|
const uint32_t previousDilatedMotionVectorsResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_1 : FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_2;
|
|
const uint32_t lumaHistorySrvResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_2 : FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_1;
|
|
const uint32_t lumaHistoryUavResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_1 : FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_2;
|
|
|
|
const uint32_t prevPreAlphaColorSrvResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_2 : FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_1;
|
|
const uint32_t prevPreAlphaColorUavResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_1 : FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_2;
|
|
const uint32_t prevPostAlphaColorSrvResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_2 : FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_1;
|
|
const uint32_t prevPostAlphaColorUavResourceIndex = isOddFrame ? FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_1 : FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_2;
|
|
|
|
const bool resetAccumulation = params->reset || context->firstExecution;
|
|
context->firstExecution = false;
|
|
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->color, &context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR]);
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->depth, &context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_DEPTH]);
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->motionVectors, &context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS]);
|
|
|
|
// if auto exposure is enabled use the auto exposure SRV, otherwise what the app sends.
|
|
if (context->contextDescription.flags & FFX_FSR2_ENABLE_AUTO_EXPOSURE) {
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_EXPOSURE] = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE];
|
|
} else {
|
|
if (ffxFsr2ResourceIsNull(params->exposure)) {
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_EXPOSURE] = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE];
|
|
} else {
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->exposure, &context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_EXPOSURE]);
|
|
}
|
|
}
|
|
|
|
if (params->enableAutoReactive)
|
|
{
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->colorOpaqueOnly, &context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR]);
|
|
}
|
|
|
|
if (ffxFsr2ResourceIsNull(params->reactive)) {
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK] = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY];
|
|
}
|
|
else {
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->reactive, &context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK]);
|
|
}
|
|
|
|
if (ffxFsr2ResourceIsNull(params->transparencyAndComposition)) {
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK] = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY];
|
|
} else {
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->transparencyAndComposition, &context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK]);
|
|
}
|
|
|
|
context->contextDescription.callbacks.fpRegisterResource(&context->contextDescription.callbacks, ¶ms->output, &context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT]);
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS] = context->srvResources[lockStatusSrvResourceIndex];
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR] = context->srvResources[upscaledColorSrvResourceIndex];
|
|
context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS] = context->uavResources[lockStatusUavResourceIndex];
|
|
context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR] = context->uavResources[upscaledColorUavResourceIndex];
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_RCAS_INPUT] = context->uavResources[upscaledColorUavResourceIndex];
|
|
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS] = context->srvResources[dilatedMotionVectorsResourceIndex];
|
|
context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS] = context->uavResources[dilatedMotionVectorsResourceIndex];
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREVIOUS_DILATED_MOTION_VECTORS] = context->srvResources[previousDilatedMotionVectorsResourceIndex];
|
|
|
|
context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY] = context->uavResources[lumaHistoryUavResourceIndex];
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY] = context->srvResources[lumaHistorySrvResourceIndex];
|
|
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR] = context->srvResources[prevPreAlphaColorSrvResourceIndex];
|
|
context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR] = context->uavResources[prevPreAlphaColorUavResourceIndex];
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR] = context->srvResources[prevPostAlphaColorSrvResourceIndex];
|
|
context->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR] = context->uavResources[prevPostAlphaColorUavResourceIndex];
|
|
|
|
// actual resource size may differ from render/display resolution (e.g. due to Hw/API restrictions), so query the descriptor for UVs adjustment
|
|
const FfxResourceDescription resourceDescInputColor = context->contextDescription.callbacks.fpGetResourceDescription(&context->contextDescription.callbacks, context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR]);
|
|
const FfxResourceDescription resourceDescLockStatus = context->contextDescription.callbacks.fpGetResourceDescription(&context->contextDescription.callbacks, context->srvResources[lockStatusSrvResourceIndex]);
|
|
const FfxResourceDescription resourceDescReactiveMask = context->contextDescription.callbacks.fpGetResourceDescription(&context->contextDescription.callbacks, context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK]);
|
|
FFX_ASSERT(resourceDescInputColor.type == FFX_RESOURCE_TYPE_TEXTURE2D);
|
|
FFX_ASSERT(resourceDescLockStatus.type == FFX_RESOURCE_TYPE_TEXTURE2D);
|
|
|
|
context->constants.jitterOffset[0] = params->jitterOffset.x;
|
|
context->constants.jitterOffset[1] = params->jitterOffset.y;
|
|
context->constants.renderSize[0] = int32_t(params->renderSize.width ? params->renderSize.width : resourceDescInputColor.width);
|
|
context->constants.renderSize[1] = int32_t(params->renderSize.height ? params->renderSize.height : resourceDescInputColor.height);
|
|
context->constants.maxRenderSize[0] = int32_t(context->contextDescription.maxRenderSize.width);
|
|
context->constants.maxRenderSize[1] = int32_t(context->contextDescription.maxRenderSize.height);
|
|
context->constants.inputColorResourceDimensions[0] = resourceDescInputColor.width;
|
|
context->constants.inputColorResourceDimensions[1] = resourceDescInputColor.height;
|
|
|
|
// compute the horizontal FOV for the shader from the vertical one.
|
|
const float aspectRatio = (float)params->renderSize.width / (float)params->renderSize.height;
|
|
const float cameraAngleHorizontal = atan(tan(params->cameraFovAngleVertical / 2) * aspectRatio) * 2;
|
|
context->constants.tanHalfFOV = tanf(cameraAngleHorizontal * 0.5f);
|
|
context->constants.viewSpaceToMetersFactor = (params->viewSpaceToMetersFactor > 0.0f) ? params->viewSpaceToMetersFactor : 1.0f;
|
|
|
|
// compute params to enable device depth to view space depth computation in shader
|
|
setupDeviceDepthToViewSpaceDepthParams(context, params);
|
|
|
|
// To be updated if resource is larger than the actual image size
|
|
context->constants.downscaleFactor[0] = float(context->constants.renderSize[0]) / context->contextDescription.displaySize.width;
|
|
context->constants.downscaleFactor[1] = float(context->constants.renderSize[1]) / context->contextDescription.displaySize.height;
|
|
context->constants.previousFramePreExposure = context->constants.preExposure;
|
|
context->constants.preExposure = (params->preExposure != 0) ? params->preExposure : 1.0f;
|
|
|
|
// motion vector data
|
|
const int32_t* motionVectorsTargetSize = (context->contextDescription.flags & FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS) ? context->constants.displaySize : context->constants.renderSize;
|
|
|
|
context->constants.motionVectorScale[0] = (params->motionVectorScale.x / motionVectorsTargetSize[0]);
|
|
context->constants.motionVectorScale[1] = (params->motionVectorScale.y / motionVectorsTargetSize[1]);
|
|
|
|
// compute jitter cancellation
|
|
if (context->contextDescription.flags & FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION) {
|
|
|
|
context->constants.motionVectorJitterCancellation[0] = (context->previousJitterOffset[0] - context->constants.jitterOffset[0]) / motionVectorsTargetSize[0];
|
|
context->constants.motionVectorJitterCancellation[1] = (context->previousJitterOffset[1] - context->constants.jitterOffset[1]) / motionVectorsTargetSize[1];
|
|
|
|
context->previousJitterOffset[0] = context->constants.jitterOffset[0];
|
|
context->previousJitterOffset[1] = context->constants.jitterOffset[1];
|
|
}
|
|
|
|
// lock data, assuming jitter sequence length computation for now
|
|
const int32_t jitterPhaseCount = ffxFsr2GetJitterPhaseCount(params->renderSize.width, context->contextDescription.displaySize.width);
|
|
|
|
// init on first frame
|
|
if (resetAccumulation || context->constants.jitterPhaseCount == 0) {
|
|
context->constants.jitterPhaseCount = (float)jitterPhaseCount;
|
|
} else {
|
|
const int32_t jitterPhaseCountDelta = (int32_t)(jitterPhaseCount - context->constants.jitterPhaseCount);
|
|
if (jitterPhaseCountDelta > 0) {
|
|
context->constants.jitterPhaseCount++;
|
|
} else if (jitterPhaseCountDelta < 0) {
|
|
context->constants.jitterPhaseCount--;
|
|
}
|
|
}
|
|
|
|
// convert delta time to seconds and clamp to [0, 1].
|
|
context->constants.deltaTime = FFX_MAXIMUM(0.0f, FFX_MINIMUM(1.0f, params->frameTimeDelta / 1000.0f));
|
|
|
|
if (resetAccumulation) {
|
|
context->constants.frameIndex = 0;
|
|
} else {
|
|
context->constants.frameIndex++;
|
|
}
|
|
|
|
// shading change usage of the SPD mip levels.
|
|
context->constants.lumaMipLevelToUse = uint32_t(FFX_FSR2_SHADING_CHANGE_MIP_LEVEL);
|
|
|
|
const float mipDiv = float(2 << context->constants.lumaMipLevelToUse);
|
|
context->constants.lumaMipDimensions[0] = uint32_t(context->constants.maxRenderSize[0] / mipDiv);
|
|
context->constants.lumaMipDimensions[1] = uint32_t(context->constants.maxRenderSize[1] / mipDiv);
|
|
|
|
// -- GODOT start --
|
|
memcpy(context->constants.reprojectionMatrix, params->reprojectionMatrix, sizeof(context->constants.reprojectionMatrix));
|
|
// -- GODOT end --
|
|
|
|
// reactive mask bias
|
|
const int32_t threadGroupWorkRegionDim = 8;
|
|
const int32_t dispatchSrcX = (context->constants.renderSize[0] + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
const int32_t dispatchSrcY = (context->constants.renderSize[1] + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
const int32_t dispatchDstX = (context->contextDescription.displaySize.width + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
const int32_t dispatchDstY = (context->contextDescription.displaySize.height + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
|
|
// Clear reconstructed depth for max depth store.
|
|
if (resetAccumulation) {
|
|
|
|
FfxGpuJobDescription clearJob = { FFX_GPU_JOB_CLEAR_FLOAT };
|
|
|
|
// LockStatus resource has no sign bit, callback functions are compensating for this.
|
|
// Clearing the resource must follow the same logic.
|
|
float clearValuesLockStatus[4]{};
|
|
clearValuesLockStatus[LOCK_LIFETIME_REMAINING] = 0.0f;
|
|
clearValuesLockStatus[LOCK_TEMPORAL_LUMA] = 0.0f;
|
|
|
|
memcpy(clearJob.clearJobDescriptor.color, clearValuesLockStatus, 4 * sizeof(float));
|
|
clearJob.clearJobDescriptor.target = context->srvResources[lockStatusSrvResourceIndex];
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &clearJob);
|
|
|
|
const float clearValuesToZeroFloat[]{ 0.f, 0.f, 0.f, 0.f };
|
|
memcpy(clearJob.clearJobDescriptor.color, clearValuesToZeroFloat, 4 * sizeof(float));
|
|
clearJob.clearJobDescriptor.target = context->srvResources[upscaledColorSrvResourceIndex];
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &clearJob);
|
|
|
|
clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE];
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &clearJob);
|
|
|
|
//if (context->contextDescription.flags & FFX_FSR2_ENABLE_AUTO_EXPOSURE)
|
|
// Auto exposure always used to track luma changes in locking logic
|
|
{
|
|
const float clearValuesExposure[]{ -1.f, 1e8f, 0.f, 0.f };
|
|
memcpy(clearJob.clearJobDescriptor.color, clearValuesExposure, 4 * sizeof(float));
|
|
clearJob.clearJobDescriptor.target = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE];
|
|
context->contextDescription.callbacks.fpScheduleGpuJob(&context->contextDescription.callbacks, &clearJob);
|
|
}
|
|
}
|
|
|
|
// Auto exposure
|
|
uint32_t dispatchThreadGroupCountXY[2];
|
|
uint32_t workGroupOffset[2];
|
|
uint32_t numWorkGroupsAndMips[2];
|
|
uint32_t rectInfo[4] = { 0, 0, params->renderSize.width, params->renderSize.height };
|
|
SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo);
|
|
|
|
// downsample
|
|
Fsr2SpdConstants luminancePyramidConstants;
|
|
luminancePyramidConstants.numworkGroups = numWorkGroupsAndMips[0];
|
|
luminancePyramidConstants.mips = numWorkGroupsAndMips[1];
|
|
luminancePyramidConstants.workGroupOffset[0] = workGroupOffset[0];
|
|
luminancePyramidConstants.workGroupOffset[1] = workGroupOffset[1];
|
|
luminancePyramidConstants.renderSize[0] = params->renderSize.width;
|
|
luminancePyramidConstants.renderSize[1] = params->renderSize.height;
|
|
|
|
// compute the constants.
|
|
Fsr2RcasConstants rcasConsts = {};
|
|
const float sharpenessRemapped = (-2.0f * params->sharpness) + 2.0f;
|
|
FsrRcasCon(rcasConsts.rcasConfig, sharpenessRemapped);
|
|
|
|
Fsr2GenerateReactiveConstants2 genReactiveConsts = {};
|
|
genReactiveConsts.autoTcThreshold = params->autoTcThreshold;
|
|
genReactiveConsts.autoTcScale = params->autoTcScale;
|
|
genReactiveConsts.autoReactiveScale = params->autoReactiveScale;
|
|
genReactiveConsts.autoReactiveMax = params->autoReactiveMax;
|
|
|
|
// initialize constantBuffers data
|
|
memcpy(&globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_FSR2].data, &context->constants, globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_FSR2].uint32Size * sizeof(uint32_t));
|
|
memcpy(&globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_SPD].data, &luminancePyramidConstants, globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_SPD].uint32Size * sizeof(uint32_t));
|
|
memcpy(&globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_RCAS].data, &rcasConsts, globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_RCAS].uint32Size * sizeof(uint32_t));
|
|
memcpy(&globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE].data, &genReactiveConsts, globalFsr2ConstantBuffers[FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE].uint32Size * sizeof(uint32_t));
|
|
|
|
// Auto reactive
|
|
if (params->enableAutoReactive)
|
|
{
|
|
generateReactiveMaskInternal(context, params);
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK] = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE];
|
|
context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK] = context->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOCOMPOSITION];
|
|
}
|
|
scheduleDispatch(context, params, &context->pipelineComputeLuminancePyramid, dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1]);
|
|
scheduleDispatch(context, params, &context->pipelineReconstructPreviousDepth, dispatchSrcX, dispatchSrcY);
|
|
scheduleDispatch(context, params, &context->pipelineDepthClip, dispatchSrcX, dispatchSrcY);
|
|
|
|
const bool sharpenEnabled = params->enableSharpening;
|
|
|
|
scheduleDispatch(context, params, &context->pipelineLock, dispatchSrcX, dispatchSrcY);
|
|
scheduleDispatch(context, params, sharpenEnabled ? &context->pipelineAccumulateSharpen : &context->pipelineAccumulate, dispatchDstX, dispatchDstY);
|
|
|
|
// RCAS
|
|
if (sharpenEnabled) {
|
|
|
|
// dispatch RCAS
|
|
const int32_t threadGroupWorkRegionDimRCAS = 16;
|
|
const int32_t dispatchX = (context->contextDescription.displaySize.width + (threadGroupWorkRegionDimRCAS - 1)) / threadGroupWorkRegionDimRCAS;
|
|
const int32_t dispatchY = (context->contextDescription.displaySize.height + (threadGroupWorkRegionDimRCAS - 1)) / threadGroupWorkRegionDimRCAS;
|
|
scheduleDispatch(context, params, &context->pipelineRCAS, dispatchX, dispatchY);
|
|
}
|
|
|
|
context->resourceFrameIndex = (context->resourceFrameIndex + 1) % FSR2_MAX_QUEUED_FRAMES;
|
|
|
|
// Fsr2MaxQueuedFrames must be an even number.
|
|
FFX_STATIC_ASSERT((FSR2_MAX_QUEUED_FRAMES & 1) == 0);
|
|
|
|
context->contextDescription.callbacks.fpExecuteGpuJobs(&context->contextDescription.callbacks, commandList);
|
|
|
|
// release dynamic resources
|
|
context->contextDescription.callbacks.fpUnregisterResources(&context->contextDescription.callbacks);
|
|
|
|
return FFX_OK;
|
|
}
|
|
|
|
FfxErrorCode ffxFsr2ContextCreate(FfxFsr2Context* context, const FfxFsr2ContextDescription* contextDescription)
|
|
{
|
|
// zero context memory
|
|
memset(context, 0, sizeof(FfxFsr2Context));
|
|
|
|
// check pointers are valid.
|
|
FFX_RETURN_ON_ERROR(
|
|
context,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
contextDescription,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
|
|
// validate that all callbacks are set for the interface
|
|
FFX_RETURN_ON_ERROR(contextDescription->callbacks.fpGetDeviceCapabilities, FFX_ERROR_INCOMPLETE_INTERFACE);
|
|
FFX_RETURN_ON_ERROR(contextDescription->callbacks.fpCreateBackendContext, FFX_ERROR_INCOMPLETE_INTERFACE);
|
|
FFX_RETURN_ON_ERROR(contextDescription->callbacks.fpDestroyBackendContext, FFX_ERROR_INCOMPLETE_INTERFACE);
|
|
|
|
// if a scratch buffer is declared, then we must have a size
|
|
if (contextDescription->callbacks.scratchBuffer) {
|
|
|
|
FFX_RETURN_ON_ERROR(contextDescription->callbacks.scratchBufferSize, FFX_ERROR_INCOMPLETE_INTERFACE);
|
|
}
|
|
|
|
// ensure the context is large enough for the internal context.
|
|
FFX_STATIC_ASSERT(sizeof(FfxFsr2Context) >= sizeof(FfxFsr2Context_Private));
|
|
|
|
// create the context.
|
|
FfxFsr2Context_Private* contextPrivate = (FfxFsr2Context_Private*)(context);
|
|
const FfxErrorCode errorCode = fsr2Create(contextPrivate, contextDescription);
|
|
|
|
return errorCode;
|
|
}
|
|
|
|
FfxErrorCode ffxFsr2ContextDestroy(FfxFsr2Context* context)
|
|
{
|
|
FFX_RETURN_ON_ERROR(
|
|
context,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
|
|
// destroy the context.
|
|
FfxFsr2Context_Private* contextPrivate = (FfxFsr2Context_Private*)(context);
|
|
const FfxErrorCode errorCode = fsr2Release(contextPrivate);
|
|
return errorCode;
|
|
}
|
|
|
|
FfxErrorCode ffxFsr2ContextDispatch(FfxFsr2Context* context, const FfxFsr2DispatchDescription* dispatchParams)
|
|
{
|
|
FFX_RETURN_ON_ERROR(
|
|
context,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
dispatchParams,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
|
|
FfxFsr2Context_Private* contextPrivate = (FfxFsr2Context_Private*)(context);
|
|
|
|
// validate that renderSize is within the maximum.
|
|
FFX_RETURN_ON_ERROR(
|
|
dispatchParams->renderSize.width <= contextPrivate->contextDescription.maxRenderSize.width,
|
|
FFX_ERROR_OUT_OF_RANGE);
|
|
FFX_RETURN_ON_ERROR(
|
|
dispatchParams->renderSize.height <= contextPrivate->contextDescription.maxRenderSize.height,
|
|
FFX_ERROR_OUT_OF_RANGE);
|
|
FFX_RETURN_ON_ERROR(
|
|
contextPrivate->device,
|
|
FFX_ERROR_NULL_DEVICE);
|
|
|
|
// dispatch the FSR2 passes.
|
|
const FfxErrorCode errorCode = fsr2Dispatch(contextPrivate, dispatchParams);
|
|
return errorCode;
|
|
}
|
|
|
|
float ffxFsr2GetUpscaleRatioFromQualityMode(FfxFsr2QualityMode qualityMode)
|
|
{
|
|
switch (qualityMode) {
|
|
|
|
case FFX_FSR2_QUALITY_MODE_QUALITY:
|
|
return 1.5f;
|
|
case FFX_FSR2_QUALITY_MODE_BALANCED:
|
|
return 1.7f;
|
|
case FFX_FSR2_QUALITY_MODE_PERFORMANCE:
|
|
return 2.0f;
|
|
case FFX_FSR2_QUALITY_MODE_ULTRA_PERFORMANCE:
|
|
return 3.0f;
|
|
default:
|
|
return 0.0f;
|
|
}
|
|
}
|
|
|
|
FfxErrorCode ffxFsr2GetRenderResolutionFromQualityMode(
|
|
uint32_t* renderWidth,
|
|
uint32_t* renderHeight,
|
|
uint32_t displayWidth,
|
|
uint32_t displayHeight,
|
|
FfxFsr2QualityMode qualityMode)
|
|
{
|
|
FFX_RETURN_ON_ERROR(
|
|
renderWidth,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
renderHeight,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
FFX_FSR2_QUALITY_MODE_QUALITY <= qualityMode && qualityMode <= FFX_FSR2_QUALITY_MODE_ULTRA_PERFORMANCE,
|
|
FFX_ERROR_INVALID_ENUM);
|
|
|
|
// scale by the predefined ratios in each dimension.
|
|
const float ratio = ffxFsr2GetUpscaleRatioFromQualityMode(qualityMode);
|
|
const uint32_t scaledDisplayWidth = (uint32_t)((float)displayWidth / ratio);
|
|
const uint32_t scaledDisplayHeight = (uint32_t)((float)displayHeight / ratio);
|
|
*renderWidth = scaledDisplayWidth;
|
|
*renderHeight = scaledDisplayHeight;
|
|
|
|
return FFX_OK;
|
|
}
|
|
|
|
FfxErrorCode ffxFsr2ContextEnqueueRefreshPipelineRequest(FfxFsr2Context* context)
|
|
{
|
|
FFX_RETURN_ON_ERROR(
|
|
context,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
|
|
FfxFsr2Context_Private* contextPrivate = (FfxFsr2Context_Private*)context;
|
|
contextPrivate->refreshPipelineStates = true;
|
|
|
|
return FFX_OK;
|
|
}
|
|
|
|
int32_t ffxFsr2GetJitterPhaseCount(int32_t renderWidth, int32_t displayWidth)
|
|
{
|
|
const float basePhaseCount = 8.0f;
|
|
const int32_t jitterPhaseCount = int32_t(basePhaseCount * pow((float(displayWidth) / renderWidth), 2.0f));
|
|
return jitterPhaseCount;
|
|
}
|
|
|
|
FfxErrorCode ffxFsr2GetJitterOffset(float* outX, float* outY, int32_t index, int32_t phaseCount)
|
|
{
|
|
FFX_RETURN_ON_ERROR(
|
|
outX,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
outY,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
phaseCount > 0,
|
|
FFX_ERROR_INVALID_ARGUMENT);
|
|
|
|
const float x = halton((index % phaseCount) + 1, 2) - 0.5f;
|
|
const float y = halton((index % phaseCount) + 1, 3) - 0.5f;
|
|
|
|
*outX = x;
|
|
*outY = y;
|
|
return FFX_OK;
|
|
}
|
|
|
|
FFX_API bool ffxFsr2ResourceIsNull(FfxResource resource)
|
|
{
|
|
return resource.resource == NULL;
|
|
}
|
|
|
|
FfxErrorCode ffxFsr2ContextGenerateReactiveMask(FfxFsr2Context* context, const FfxFsr2GenerateReactiveDescription* params)
|
|
{
|
|
FFX_RETURN_ON_ERROR(
|
|
context,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
params,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
FFX_RETURN_ON_ERROR(
|
|
params->commandList,
|
|
FFX_ERROR_INVALID_POINTER);
|
|
|
|
FfxFsr2Context_Private* contextPrivate = (FfxFsr2Context_Private*)(context);
|
|
|
|
FFX_RETURN_ON_ERROR(
|
|
contextPrivate->device,
|
|
FFX_ERROR_NULL_DEVICE);
|
|
|
|
if (contextPrivate->refreshPipelineStates) {
|
|
|
|
createPipelineStates(contextPrivate);
|
|
contextPrivate->refreshPipelineStates = false;
|
|
}
|
|
|
|
// take a short cut to the command list
|
|
FfxCommandList commandList = params->commandList;
|
|
|
|
FfxPipelineState* pipeline = &contextPrivate->pipelineGenerateReactive;
|
|
|
|
const int32_t threadGroupWorkRegionDim = 8;
|
|
const int32_t dispatchSrcX = (params->renderSize.width + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
const int32_t dispatchSrcY = (params->renderSize.height + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
|
|
// save internal reactive resource
|
|
FfxResourceInternal internalReactive = contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE];
|
|
|
|
FfxComputeJobDescription jobDescriptor = {};
|
|
contextPrivate->contextDescription.callbacks.fpRegisterResource(&contextPrivate->contextDescription.callbacks, ¶ms->colorOpaqueOnly, &contextPrivate->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY]);
|
|
contextPrivate->contextDescription.callbacks.fpRegisterResource(&contextPrivate->contextDescription.callbacks, ¶ms->colorPreUpscale, &contextPrivate->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR]);
|
|
contextPrivate->contextDescription.callbacks.fpRegisterResource(&contextPrivate->contextDescription.callbacks, ¶ms->outReactive, &contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE]);
|
|
|
|
jobDescriptor.uavs[0] = contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE];
|
|
|
|
wcscpy_s(jobDescriptor.srvNames[0], pipeline->srvResourceBindings[0].name);
|
|
wcscpy_s(jobDescriptor.srvNames[1], pipeline->srvResourceBindings[1].name);
|
|
wcscpy_s(jobDescriptor.uavNames[0], pipeline->uavResourceBindings[0].name);
|
|
|
|
jobDescriptor.dimensions[0] = dispatchSrcX;
|
|
jobDescriptor.dimensions[1] = dispatchSrcY;
|
|
jobDescriptor.dimensions[2] = 1;
|
|
jobDescriptor.pipeline = *pipeline;
|
|
|
|
for (uint32_t currentShaderResourceViewIndex = 0; currentShaderResourceViewIndex < pipeline->srvCount; ++currentShaderResourceViewIndex) {
|
|
|
|
const uint32_t currentResourceId = pipeline->srvResourceBindings[currentShaderResourceViewIndex].resourceIdentifier;
|
|
const FfxResourceInternal currentResource = contextPrivate->srvResources[currentResourceId];
|
|
jobDescriptor.srvs[currentShaderResourceViewIndex] = currentResource;
|
|
wcscpy_s(jobDescriptor.srvNames[currentShaderResourceViewIndex], pipeline->srvResourceBindings[currentShaderResourceViewIndex].name);
|
|
}
|
|
|
|
Fsr2GenerateReactiveConstants constants = {};
|
|
constants.scale = params->scale;
|
|
constants.threshold = params->cutoffThreshold;
|
|
constants.binaryValue = params->binaryValue;
|
|
constants.flags = params->flags;
|
|
|
|
jobDescriptor.cbs[0].uint32Size = sizeof(constants);
|
|
memcpy(&jobDescriptor.cbs[0].data, &constants, sizeof(constants));
|
|
wcscpy_s(jobDescriptor.cbNames[0], pipeline->cbResourceBindings[0].name);
|
|
|
|
FfxGpuJobDescription dispatchJob = { FFX_GPU_JOB_COMPUTE };
|
|
dispatchJob.computeJobDescriptor = jobDescriptor;
|
|
|
|
contextPrivate->contextDescription.callbacks.fpScheduleGpuJob(&contextPrivate->contextDescription.callbacks, &dispatchJob);
|
|
|
|
contextPrivate->contextDescription.callbacks.fpExecuteGpuJobs(&contextPrivate->contextDescription.callbacks, commandList);
|
|
|
|
// restore internal reactive
|
|
contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE] = internalReactive;
|
|
|
|
return FFX_OK;
|
|
}
|
|
|
|
static FfxErrorCode generateReactiveMaskInternal(FfxFsr2Context_Private* contextPrivate, const FfxFsr2DispatchDescription* params)
|
|
{
|
|
if (contextPrivate->refreshPipelineStates) {
|
|
|
|
createPipelineStates(contextPrivate);
|
|
contextPrivate->refreshPipelineStates = false;
|
|
}
|
|
|
|
// take a short cut to the command list
|
|
FfxCommandList commandList = params->commandList;
|
|
|
|
FfxPipelineState* pipeline = &contextPrivate->pipelineTcrAutogenerate;
|
|
|
|
const int32_t threadGroupWorkRegionDim = 8;
|
|
const int32_t dispatchSrcX = (params->renderSize.width + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
const int32_t dispatchSrcY = (params->renderSize.height + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
|
|
|
|
FfxComputeJobDescription jobDescriptor = {};
|
|
contextPrivate->contextDescription.callbacks.fpRegisterResource(&contextPrivate->contextDescription.callbacks, ¶ms->colorOpaqueOnly, &contextPrivate->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY]);
|
|
contextPrivate->contextDescription.callbacks.fpRegisterResource(&contextPrivate->contextDescription.callbacks, ¶ms->color, &contextPrivate->srvResources[FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR]);
|
|
|
|
jobDescriptor.uavs[0] = contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE];
|
|
jobDescriptor.uavs[1] = contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_AUTOCOMPOSITION];
|
|
jobDescriptor.uavs[2] = contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR];
|
|
jobDescriptor.uavs[3] = contextPrivate->uavResources[FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR];
|
|
|
|
wcscpy_s(jobDescriptor.uavNames[0], pipeline->uavResourceBindings[0].name);
|
|
wcscpy_s(jobDescriptor.uavNames[1], pipeline->uavResourceBindings[1].name);
|
|
wcscpy_s(jobDescriptor.uavNames[2], pipeline->uavResourceBindings[2].name);
|
|
wcscpy_s(jobDescriptor.uavNames[3], pipeline->uavResourceBindings[3].name);
|
|
|
|
jobDescriptor.dimensions[0] = dispatchSrcX;
|
|
jobDescriptor.dimensions[1] = dispatchSrcY;
|
|
jobDescriptor.dimensions[2] = 1;
|
|
jobDescriptor.pipeline = *pipeline;
|
|
|
|
for (uint32_t currentShaderResourceViewIndex = 0; currentShaderResourceViewIndex < pipeline->srvCount; ++currentShaderResourceViewIndex) {
|
|
|
|
const uint32_t currentResourceId = pipeline->srvResourceBindings[currentShaderResourceViewIndex].resourceIdentifier;
|
|
const FfxResourceInternal currentResource = contextPrivate->srvResources[currentResourceId];
|
|
jobDescriptor.srvs[currentShaderResourceViewIndex] = currentResource;
|
|
wcscpy_s(jobDescriptor.srvNames[currentShaderResourceViewIndex], pipeline->srvResourceBindings[currentShaderResourceViewIndex].name);
|
|
}
|
|
|
|
for (uint32_t currentRootConstantIndex = 0; currentRootConstantIndex < pipeline->constCount; ++currentRootConstantIndex) {
|
|
wcscpy_s(jobDescriptor.cbNames[currentRootConstantIndex], pipeline->cbResourceBindings[currentRootConstantIndex].name);
|
|
jobDescriptor.cbs[currentRootConstantIndex] = globalFsr2ConstantBuffers[pipeline->cbResourceBindings[currentRootConstantIndex].resourceIdentifier];
|
|
jobDescriptor.cbSlotIndex[currentRootConstantIndex] = pipeline->cbResourceBindings[currentRootConstantIndex].slotIndex;
|
|
}
|
|
|
|
FfxGpuJobDescription dispatchJob = { FFX_GPU_JOB_COMPUTE };
|
|
dispatchJob.computeJobDescriptor = jobDescriptor;
|
|
|
|
contextPrivate->contextDescription.callbacks.fpScheduleGpuJob(&contextPrivate->contextDescription.callbacks, &dispatchJob);
|
|
|
|
return FFX_OK;
|
|
}
|