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.
295 lines
13 KiB
C++
295 lines
13 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.
|
|
|
|
#ifndef FFX_FSR2_ACCUMULATE_H
|
|
#define FFX_FSR2_ACCUMULATE_H
|
|
|
|
FfxFloat32 GetPxHrVelocity(FfxFloat32x2 fMotionVector)
|
|
{
|
|
return length(fMotionVector * DisplaySize());
|
|
}
|
|
#if FFX_HALF
|
|
FFX_MIN16_F GetPxHrVelocity(FFX_MIN16_F2 fMotionVector)
|
|
{
|
|
return length(fMotionVector * FFX_MIN16_F2(DisplaySize()));
|
|
}
|
|
#endif
|
|
|
|
void Accumulate(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT FfxFloat32x3 fHistoryColor, FfxFloat32x3 fAccumulation, FFX_PARAMETER_IN FfxFloat32x4 fUpsampledColorAndWeight)
|
|
{
|
|
// Aviod invalid values when accumulation and upsampled weight is 0
|
|
fAccumulation = ffxMax(FSR2_EPSILON.xxx, fAccumulation + fUpsampledColorAndWeight.www);
|
|
|
|
#if FFX_FSR2_OPTION_HDR_COLOR_INPUT
|
|
//YCoCg -> RGB -> Tonemap -> YCoCg (Use RGB tonemapper to avoid color desaturation)
|
|
fUpsampledColorAndWeight.xyz = RGBToYCoCg(Tonemap(YCoCgToRGB(fUpsampledColorAndWeight.xyz)));
|
|
fHistoryColor = RGBToYCoCg(Tonemap(YCoCgToRGB(fHistoryColor)));
|
|
#endif
|
|
|
|
const FfxFloat32x3 fAlpha = fUpsampledColorAndWeight.www / fAccumulation;
|
|
fHistoryColor = ffxLerp(fHistoryColor, fUpsampledColorAndWeight.xyz, fAlpha);
|
|
|
|
fHistoryColor = YCoCgToRGB(fHistoryColor);
|
|
|
|
#if FFX_FSR2_OPTION_HDR_COLOR_INPUT
|
|
fHistoryColor = InverseTonemap(fHistoryColor);
|
|
#endif
|
|
}
|
|
|
|
void RectifyHistory(
|
|
const AccumulationPassCommonParams params,
|
|
RectificationBox clippingBox,
|
|
FFX_PARAMETER_INOUT FfxFloat32x3 fHistoryColor,
|
|
FFX_PARAMETER_INOUT FfxFloat32x3 fAccumulation,
|
|
FfxFloat32 fLockContributionThisFrame,
|
|
FfxFloat32 fTemporalReactiveFactor,
|
|
FfxFloat32 fLumaInstabilityFactor)
|
|
{
|
|
FfxFloat32 fScaleFactorInfluence = ffxMin(20.0f, ffxPow(FfxFloat32(1.0f / length(DownscaleFactor().x * DownscaleFactor().y)), 3.0f));
|
|
|
|
const FfxFloat32 fVecolityFactor = ffxSaturate(params.fHrVelocity / 20.0f);
|
|
const FfxFloat32 fBoxScaleT = ffxMax(params.fDepthClipFactor, ffxMax(params.fAccumulationMask, fVecolityFactor));
|
|
FfxFloat32 fBoxScale = ffxLerp(fScaleFactorInfluence, 1.0f, fBoxScaleT);
|
|
|
|
FfxFloat32x3 fScaledBoxVec = clippingBox.boxVec * fBoxScale;
|
|
FfxFloat32x3 boxMin = clippingBox.boxCenter - fScaledBoxVec;
|
|
FfxFloat32x3 boxMax = clippingBox.boxCenter + fScaledBoxVec;
|
|
FfxFloat32x3 boxCenter = clippingBox.boxCenter;
|
|
FfxFloat32 boxVecSize = length(clippingBox.boxVec);
|
|
|
|
boxMin = ffxMax(clippingBox.aabbMin, boxMin);
|
|
boxMax = ffxMin(clippingBox.aabbMax, boxMax);
|
|
|
|
if (any(FFX_GREATER_THAN(boxMin, fHistoryColor)) || any(FFX_GREATER_THAN(fHistoryColor, boxMax))) {
|
|
|
|
const FfxFloat32x3 fClampedHistoryColor = clamp(fHistoryColor, boxMin, boxMax);
|
|
|
|
FfxFloat32x3 fHistoryContribution = ffxMax(fLumaInstabilityFactor, fLockContributionThisFrame).xxx;
|
|
|
|
const FfxFloat32 fReactiveFactor = params.fDilatedReactiveFactor;
|
|
const FfxFloat32 fReactiveContribution = 1.0f - ffxPow(fReactiveFactor, 1.0f / 2.0f);
|
|
fHistoryContribution *= fReactiveContribution;
|
|
|
|
// Scale history color using rectification info, also using accumulation mask to avoid potential invalid color protection
|
|
fHistoryColor = ffxLerp(fClampedHistoryColor, fHistoryColor, ffxSaturate(fHistoryContribution));
|
|
|
|
// Scale accumulation using rectification info
|
|
const FfxFloat32x3 fAccumulationMin = ffxMin(fAccumulation, FFX_BROADCAST_FLOAT32X3(0.1f));
|
|
fAccumulation = ffxLerp(fAccumulationMin, fAccumulation, ffxSaturate(fHistoryContribution));
|
|
}
|
|
}
|
|
|
|
void WriteUpscaledOutput(FfxInt32x2 iPxHrPos, FfxFloat32x3 fUpscaledColor)
|
|
{
|
|
StoreUpscaledOutput(iPxHrPos, fUpscaledColor);
|
|
}
|
|
|
|
void FinalizeLockStatus(const AccumulationPassCommonParams params, FfxFloat32x2 fLockStatus, FfxFloat32 fUpsampledWeight)
|
|
{
|
|
// we expect similar motion for next frame
|
|
// kill lock if that location is outside screen, avoid locks to be clamped to screen borders
|
|
FfxFloat32x2 fEstimatedUvNextFrame = params.fHrUv - params.fMotionVector;
|
|
if (IsUvInside(fEstimatedUvNextFrame) == false) {
|
|
KillLock(fLockStatus);
|
|
}
|
|
else {
|
|
// Decrease lock lifetime
|
|
const FfxFloat32 fLifetimeDecreaseLanczosMax = FfxFloat32(JitterSequenceLength()) * FfxFloat32(fAverageLanczosWeightPerFrame);
|
|
const FfxFloat32 fLifetimeDecrease = FfxFloat32(fUpsampledWeight / fLifetimeDecreaseLanczosMax);
|
|
fLockStatus[LOCK_LIFETIME_REMAINING] = ffxMax(FfxFloat32(0), fLockStatus[LOCK_LIFETIME_REMAINING] - fLifetimeDecrease);
|
|
}
|
|
|
|
StoreLockStatus(params.iPxHrPos, fLockStatus);
|
|
}
|
|
|
|
|
|
FfxFloat32x3 ComputeBaseAccumulationWeight(const AccumulationPassCommonParams params, FfxFloat32 fThisFrameReactiveFactor, FfxBoolean bInMotionLastFrame, FfxFloat32 fUpsampledWeight, LockState lockState)
|
|
{
|
|
// Always assume max accumulation was reached
|
|
FfxFloat32 fBaseAccumulation = fMaxAccumulationLanczosWeight * FfxFloat32(params.bIsExistingSample) * (1.0f - fThisFrameReactiveFactor) * (1.0f - params.fDepthClipFactor);
|
|
|
|
fBaseAccumulation = ffxMin(fBaseAccumulation, ffxLerp(fBaseAccumulation, fUpsampledWeight * 10.0f, ffxMax(FfxFloat32(bInMotionLastFrame), ffxSaturate(params.fHrVelocity * FfxFloat32(10)))));
|
|
|
|
fBaseAccumulation = ffxMin(fBaseAccumulation, ffxLerp(fBaseAccumulation, fUpsampledWeight, ffxSaturate(params.fHrVelocity / FfxFloat32(20))));
|
|
|
|
return fBaseAccumulation.xxx;
|
|
}
|
|
|
|
FfxFloat32 ComputeLumaInstabilityFactor(const AccumulationPassCommonParams params, RectificationBox clippingBox, FfxFloat32 fThisFrameReactiveFactor, FfxFloat32 fLuminanceDiff)
|
|
{
|
|
const FfxFloat32 fUnormThreshold = 1.0f / 255.0f;
|
|
const FfxInt32 N_MINUS_1 = 0;
|
|
const FfxInt32 N_MINUS_2 = 1;
|
|
const FfxInt32 N_MINUS_3 = 2;
|
|
const FfxInt32 N_MINUS_4 = 3;
|
|
|
|
FfxFloat32 fCurrentFrameLuma = clippingBox.boxCenter.x;
|
|
|
|
#if FFX_FSR2_OPTION_HDR_COLOR_INPUT
|
|
fCurrentFrameLuma = fCurrentFrameLuma / (1.0f + ffxMax(0.0f, fCurrentFrameLuma));
|
|
#endif
|
|
|
|
fCurrentFrameLuma = round(fCurrentFrameLuma * 255.0f) / 255.0f;
|
|
|
|
const FfxBoolean bSampleLumaHistory = (ffxMax(ffxMax(params.fDepthClipFactor, params.fAccumulationMask), fLuminanceDiff) < 0.1f) && (params.bIsNewSample == false);
|
|
FfxFloat32x4 fCurrentFrameLumaHistory = bSampleLumaHistory ? SampleLumaHistory(params.fReprojectedHrUv) : FFX_BROADCAST_FLOAT32X4(0.0f);
|
|
|
|
FfxFloat32 fLumaInstability = 0.0f;
|
|
FfxFloat32 fDiffs0 = (fCurrentFrameLuma - fCurrentFrameLumaHistory[N_MINUS_1]);
|
|
|
|
FfxFloat32 fMin = abs(fDiffs0);
|
|
|
|
if (fMin >= fUnormThreshold)
|
|
{
|
|
for (int i = N_MINUS_2; i <= N_MINUS_4; i++) {
|
|
FfxFloat32 fDiffs1 = (fCurrentFrameLuma - fCurrentFrameLumaHistory[i]);
|
|
|
|
if (sign(fDiffs0) == sign(fDiffs1)) {
|
|
|
|
// Scale difference to protect historically similar values
|
|
const FfxFloat32 fMinBias = 1.0f;
|
|
fMin = ffxMin(fMin, abs(fDiffs1) * fMinBias);
|
|
}
|
|
}
|
|
|
|
const FfxFloat32 fBoxSize = clippingBox.boxVec.x;
|
|
const FfxFloat32 fBoxSizeFactor = ffxPow(ffxSaturate(fBoxSize / 0.1f), 6.0f);
|
|
|
|
fLumaInstability = FfxFloat32(fMin != abs(fDiffs0)) * fBoxSizeFactor;
|
|
fLumaInstability = FfxFloat32(fLumaInstability > fUnormThreshold);
|
|
|
|
fLumaInstability *= 1.0f - ffxMax(params.fAccumulationMask, ffxPow(fThisFrameReactiveFactor, 1.0f / 6.0f));
|
|
}
|
|
|
|
//shift history
|
|
fCurrentFrameLumaHistory[N_MINUS_4] = fCurrentFrameLumaHistory[N_MINUS_3];
|
|
fCurrentFrameLumaHistory[N_MINUS_3] = fCurrentFrameLumaHistory[N_MINUS_2];
|
|
fCurrentFrameLumaHistory[N_MINUS_2] = fCurrentFrameLumaHistory[N_MINUS_1];
|
|
fCurrentFrameLumaHistory[N_MINUS_1] = fCurrentFrameLuma;
|
|
|
|
StoreLumaHistory(params.iPxHrPos, fCurrentFrameLumaHistory);
|
|
|
|
return fLumaInstability * FfxFloat32(fCurrentFrameLumaHistory[N_MINUS_4] != 0);
|
|
}
|
|
|
|
FfxFloat32 ComputeTemporalReactiveFactor(const AccumulationPassCommonParams params, FfxFloat32 fTemporalReactiveFactor)
|
|
{
|
|
FfxFloat32 fNewFactor = ffxMin(0.99f, fTemporalReactiveFactor);
|
|
|
|
fNewFactor = ffxMax(fNewFactor, ffxLerp(fNewFactor, 0.4f, ffxSaturate(params.fHrVelocity)));
|
|
|
|
fNewFactor = ffxMax(fNewFactor * fNewFactor, ffxMax(params.fDepthClipFactor * 0.1f, params.fDilatedReactiveFactor));
|
|
|
|
// Force reactive factor for new samples
|
|
fNewFactor = params.bIsNewSample ? 1.0f : fNewFactor;
|
|
|
|
if (ffxSaturate(params.fHrVelocity * 10.0f) >= 1.0f) {
|
|
fNewFactor = ffxMax(FSR2_EPSILON, fNewFactor) * -1.0f;
|
|
}
|
|
|
|
return fNewFactor;
|
|
}
|
|
|
|
AccumulationPassCommonParams InitParams(FfxInt32x2 iPxHrPos)
|
|
{
|
|
AccumulationPassCommonParams params;
|
|
|
|
params.iPxHrPos = iPxHrPos;
|
|
const FfxFloat32x2 fHrUv = (iPxHrPos + 0.5f) / DisplaySize();
|
|
params.fHrUv = fHrUv;
|
|
|
|
const FfxFloat32x2 fLrUvJittered = fHrUv + Jitter() / RenderSize();
|
|
params.fLrUv_HwSampler = ClampUv(fLrUvJittered, RenderSize(), MaxRenderSize());
|
|
|
|
params.fMotionVector = GetMotionVector(iPxHrPos, fHrUv);
|
|
params.fHrVelocity = GetPxHrVelocity(params.fMotionVector);
|
|
|
|
ComputeReprojectedUVs(params, params.fReprojectedHrUv, params.bIsExistingSample);
|
|
|
|
params.fDepthClipFactor = ffxSaturate(SampleDepthClip(params.fLrUv_HwSampler));
|
|
|
|
const FfxFloat32x2 fDilatedReactiveMasks = SampleDilatedReactiveMasks(params.fLrUv_HwSampler);
|
|
params.fDilatedReactiveFactor = fDilatedReactiveMasks.x;
|
|
params.fAccumulationMask = fDilatedReactiveMasks.y;
|
|
params.bIsResetFrame = (0 == FrameIndex());
|
|
|
|
params.bIsNewSample = (params.bIsExistingSample == false || params.bIsResetFrame);
|
|
|
|
return params;
|
|
}
|
|
|
|
void Accumulate(FfxInt32x2 iPxHrPos)
|
|
{
|
|
const AccumulationPassCommonParams params = InitParams(iPxHrPos);
|
|
|
|
FfxFloat32x3 fHistoryColor = FfxFloat32x3(0, 0, 0);
|
|
FfxFloat32x2 fLockStatus;
|
|
InitializeNewLockSample(fLockStatus);
|
|
|
|
FfxFloat32 fTemporalReactiveFactor = 0.0f;
|
|
FfxBoolean bInMotionLastFrame = FFX_FALSE;
|
|
LockState lockState = { FFX_FALSE , FFX_FALSE };
|
|
if (params.bIsExistingSample && !params.bIsResetFrame) {
|
|
ReprojectHistoryColor(params, fHistoryColor, fTemporalReactiveFactor, bInMotionLastFrame);
|
|
lockState = ReprojectHistoryLockStatus(params, fLockStatus);
|
|
}
|
|
|
|
FfxFloat32 fThisFrameReactiveFactor = ffxMax(params.fDilatedReactiveFactor, fTemporalReactiveFactor);
|
|
|
|
FfxFloat32 fLuminanceDiff = 0.0f;
|
|
FfxFloat32 fLockContributionThisFrame = 0.0f;
|
|
UpdateLockStatus(params, fThisFrameReactiveFactor, lockState, fLockStatus, fLockContributionThisFrame, fLuminanceDiff);
|
|
|
|
// Load upsampled input color
|
|
RectificationBox clippingBox;
|
|
FfxFloat32x4 fUpsampledColorAndWeight = ComputeUpsampledColorAndWeight(params, clippingBox, fThisFrameReactiveFactor);
|
|
|
|
const FfxFloat32 fLumaInstabilityFactor = ComputeLumaInstabilityFactor(params, clippingBox, fThisFrameReactiveFactor, fLuminanceDiff);
|
|
|
|
|
|
FfxFloat32x3 fAccumulation = ComputeBaseAccumulationWeight(params, fThisFrameReactiveFactor, bInMotionLastFrame, fUpsampledColorAndWeight.w, lockState);
|
|
|
|
if (params.bIsNewSample) {
|
|
fHistoryColor = YCoCgToRGB(fUpsampledColorAndWeight.xyz);
|
|
}
|
|
else {
|
|
RectifyHistory(params, clippingBox, fHistoryColor, fAccumulation, fLockContributionThisFrame, fThisFrameReactiveFactor, fLumaInstabilityFactor);
|
|
|
|
Accumulate(params, fHistoryColor, fAccumulation, fUpsampledColorAndWeight);
|
|
}
|
|
|
|
fHistoryColor = UnprepareRgb(fHistoryColor, Exposure());
|
|
|
|
FinalizeLockStatus(params, fLockStatus, fUpsampledColorAndWeight.w);
|
|
|
|
// Get new temporal reactive factor
|
|
fTemporalReactiveFactor = ComputeTemporalReactiveFactor(params, fThisFrameReactiveFactor);
|
|
|
|
StoreInternalColorAndWeight(iPxHrPos, FfxFloat32x4(fHistoryColor, fTemporalReactiveFactor));
|
|
|
|
// Output final color when RCAS is disabled
|
|
#if FFX_FSR2_OPTION_APPLY_SHARPENING == 0
|
|
WriteUpscaledOutput(iPxHrPos, fHistoryColor);
|
|
#endif
|
|
StoreNewLocks(iPxHrPos, 0);
|
|
}
|
|
|
|
#endif // FFX_FSR2_ACCUMULATE_H
|