386 lines
14 KiB
HLSL
386 lines
14 KiB
HLSL
|
#ifndef UNIVERSAL_TEMPORAL_AA
|
||
|
|
#define UNIVERSAL_TEMPORAL_AA
|
||
|
|
|
||
|
|
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
|
||
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
||
|
|
#include "Packages/com.unity.render-pipelines.universal/Shaders/PostProcessing/Common.hlsl"
|
||
|
|
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
|
||
|
|
|
||
|
|
#ifndef TAA_YCOCG
|
||
|
|
#define TAA_YCOCG 1
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifndef TAA_GAMMA_SPACE_POST
|
||
|
|
#if UNITY_NO_LINEAR_COLORSPACE
|
||
|
|
#define TAA_GAMMA_SPACE_POST 1
|
||
|
|
else
|
||
|
|
#define TAA_GAMMA_SPACE_POST 0
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifndef TAA_PERCEPTUAL_SPACE
|
||
|
|
#define TAA_PERCEPTUAL_SPACE 1
|
||
|
|
#endif
|
||
|
|
|
||
|
|
TEXTURE2D_X(_TaaMotionVectorTex);
|
||
|
|
TEXTURE2D_X(_TaaAccumulationTex);
|
||
|
|
|
||
|
|
CBUFFER_START(TemporalAAData)
|
||
|
|
float4 _TaaMotionVectorTex_TexelSize; // (1/w, 1/h, w, h)
|
||
|
|
float4 _TaaAccumulationTex_TexelSize; // (1/w, 1/h, w, h)
|
||
|
|
|
||
|
|
float _TaaFilterWeights[9];
|
||
|
|
|
||
|
|
half _TaaFrameInfluence;
|
||
|
|
half _TaaVarianceClampScale;
|
||
|
|
CBUFFER_END
|
||
|
|
|
||
|
|
// Per-pixel camera backwards velocity
|
||
|
|
half2 GetVelocityWithOffset(float2 uv, half2 depthOffsetUv)
|
||
|
|
{
|
||
|
|
// Unity motion vectors are forward motion vectors in screen UV space
|
||
|
|
half2 offsetUv = SAMPLE_TEXTURE2D_X(_TaaMotionVectorTex, sampler_LinearClamp, uv + _TaaMotionVectorTex_TexelSize.xy * depthOffsetUv).xy;
|
||
|
|
return -offsetUv;
|
||
|
|
}
|
||
|
|
|
||
|
|
void AdjustBestDepthOffset(inout half bestDepth, inout half bestX, inout half bestY, float2 uv, half currX, half currY)
|
||
|
|
{
|
||
|
|
// Half precision should be fine, as we are only concerned about choosing the better value along sharp edges, so it's
|
||
|
|
// acceptable to have banding on continuous surfaces
|
||
|
|
half depth = SAMPLE_TEXTURE2D_X(_CameraDepthTexture, sampler_PointClamp, uv.xy + _BlitTexture_TexelSize.xy * half2(currX, currY)).r;
|
||
|
|
|
||
|
|
#if UNITY_REVERSED_Z
|
||
|
|
depth = 1.0 - depth;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
bool isBest = depth < bestDepth;
|
||
|
|
bestDepth = isBest ? depth : bestDepth;
|
||
|
|
bestX = isBest ? currX : bestX;
|
||
|
|
bestY = isBest ? currY : bestY;
|
||
|
|
}
|
||
|
|
|
||
|
|
float GetLuma(float3 color)
|
||
|
|
{
|
||
|
|
#if TAA_YCOCG
|
||
|
|
// We work in YCoCg hence the luminance is in the first channel.
|
||
|
|
return color.x;
|
||
|
|
#else
|
||
|
|
return Luminance(color.xyz);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
float PerceptualWeight(float3 c)
|
||
|
|
{
|
||
|
|
#if TAA_PERCEPTUAL_SPACE
|
||
|
|
return rcp(GetLuma(c) + 1.0);
|
||
|
|
#else
|
||
|
|
return 1;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
float PerceptualInvWeight(float3 c)
|
||
|
|
{
|
||
|
|
#if TAA_PERCEPTUAL_SPACE
|
||
|
|
return rcp(1.0 - GetLuma(c));
|
||
|
|
#else
|
||
|
|
return 1;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 WorkingToPerceptual(float4 c)
|
||
|
|
{
|
||
|
|
float scale = PerceptualWeight(c.xyz);
|
||
|
|
return c * scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 PerceptualToWorking(float4 c)
|
||
|
|
{
|
||
|
|
float scale = PerceptualInvWeight(c.xyz);
|
||
|
|
return c * scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
half4 PostFxSpaceToLinear(float4 src)
|
||
|
|
{
|
||
|
|
// gamma 2.0 is a good enough approximation
|
||
|
|
#if TAA_GAMMA_SPACE_POST
|
||
|
|
return half4(src.xyz * src.xyz, src.w);
|
||
|
|
#else
|
||
|
|
return src;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
half4 LinearToPostFxSpace(float4 src)
|
||
|
|
{
|
||
|
|
#if TAA_GAMMA_SPACE_POST
|
||
|
|
return half4(sqrt(src.xyz), src.w);
|
||
|
|
#else
|
||
|
|
return src;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
// Working Space: The color space that we will do the calculation in.
|
||
|
|
// Scene: The incoming/outgoing scene color. Either linear or gamma space
|
||
|
|
half4 SceneToWorkingSpace(half4 src)
|
||
|
|
{
|
||
|
|
half4 linColor = PostFxSpaceToLinear(src);
|
||
|
|
#if TAA_YCOCG
|
||
|
|
half4 dst = half4(RGBToYCoCg(linColor.xyz), linColor.w);
|
||
|
|
#else
|
||
|
|
half4 dst = src;
|
||
|
|
#endif
|
||
|
|
return dst;
|
||
|
|
}
|
||
|
|
|
||
|
|
half4 WorkingSpaceToScene(half4 src)
|
||
|
|
{
|
||
|
|
#if TAA_YCOCG
|
||
|
|
half4 linColor = half4(YCoCgToRGB(src.xyz), src.w);
|
||
|
|
#else
|
||
|
|
half4 linColor = src;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
half4 dst = LinearToPostFxSpace(linColor);
|
||
|
|
return dst;
|
||
|
|
}
|
||
|
|
|
||
|
|
half4 SampleColorPoint(float2 uv, float2 texelOffset)
|
||
|
|
{
|
||
|
|
return SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_PointClamp, uv + _BlitTexture_TexelSize.xy * texelOffset);
|
||
|
|
}
|
||
|
|
|
||
|
|
half4 SampleColorLinear(float2 uv, float2 texelOffset)
|
||
|
|
{
|
||
|
|
return SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv + _BlitTexture_TexelSize.xy * texelOffset);
|
||
|
|
}
|
||
|
|
|
||
|
|
void AdjustColorBox(inout half4 boxMin, inout half4 boxMax, inout half4 moment1, inout half4 moment2, float2 uv, half currX, half currY)
|
||
|
|
{
|
||
|
|
half4 color = SceneToWorkingSpace(SampleColorPoint(uv, float2(currX, currY)));
|
||
|
|
boxMin = min(color, boxMin);
|
||
|
|
boxMax = max(color, boxMax);
|
||
|
|
moment1 += color;
|
||
|
|
moment2 += color * color;
|
||
|
|
}
|
||
|
|
|
||
|
|
half4 ApplyHistoryColorLerp(half4 workingAccumColor, half4 workingCenterColor, float t)
|
||
|
|
{
|
||
|
|
half4 perceptualAccumColor = WorkingToPerceptual(workingAccumColor);
|
||
|
|
half4 perceptualCenterColor = WorkingToPerceptual(workingCenterColor);
|
||
|
|
|
||
|
|
half4 perceptualDstColor = lerp(perceptualAccumColor, perceptualCenterColor, t);
|
||
|
|
half4 workingDstColor = PerceptualToWorking(perceptualDstColor);
|
||
|
|
|
||
|
|
return workingDstColor;
|
||
|
|
}
|
||
|
|
|
||
|
|
// From Filmic SMAA presentation[Jimenez 2016]
|
||
|
|
// A bit more verbose that it needs to be, but makes it a bit better at latency hiding
|
||
|
|
// (half version based on HDRP impl)
|
||
|
|
half4 SampleBicubic5TapHalf(TEXTURE2D_X(sourceTexture), float2 UV, float4 sourceTexture_TexelSize)
|
||
|
|
{
|
||
|
|
const float2 sourceTextureSize = sourceTexture_TexelSize.zw;
|
||
|
|
const float2 sourceTexelSize = sourceTexture_TexelSize.xy;
|
||
|
|
|
||
|
|
float2 samplePos = UV * sourceTextureSize;
|
||
|
|
float2 tc1 = floor(samplePos - 0.5) + 0.5;
|
||
|
|
half2 f = samplePos - tc1;
|
||
|
|
half2 f2 = f * f;
|
||
|
|
half2 f3 = f * f2;
|
||
|
|
|
||
|
|
half c = 0.5;
|
||
|
|
|
||
|
|
half2 w0 = -c * f3 + 2.0 * c * f2 - c * f;
|
||
|
|
half2 w1 = (2.0 - c) * f3 - (3.0 - c) * f2 + 1.0;
|
||
|
|
half2 w2 = -(2.0 - c) * f3 + (3.0 - 2.0 * c) * f2 + c * f;
|
||
|
|
half2 w3 = c * f3 - c * f2;
|
||
|
|
|
||
|
|
half2 w12 = w1 + w2;
|
||
|
|
float2 tc0 = sourceTexelSize * (tc1 - 1.0);
|
||
|
|
float2 tc3 = sourceTexelSize * (tc1 + 2.0);
|
||
|
|
float2 tc12 = sourceTexelSize * (tc1 + w2 / w12);
|
||
|
|
|
||
|
|
half4 s0 = SceneToWorkingSpace(SAMPLE_TEXTURE2D_X(sourceTexture, sampler_LinearClamp, float2(tc12.x, tc0.y)));
|
||
|
|
half4 s1 = SceneToWorkingSpace(SAMPLE_TEXTURE2D_X(sourceTexture, sampler_LinearClamp, float2(tc0.x, tc12.y)));
|
||
|
|
half4 s2 = SceneToWorkingSpace(SAMPLE_TEXTURE2D_X(sourceTexture, sampler_LinearClamp, float2(tc12.x, tc12.y)));
|
||
|
|
half4 s3 = SceneToWorkingSpace(SAMPLE_TEXTURE2D_X(sourceTexture, sampler_LinearClamp, float2(tc3.x, tc12.y)));
|
||
|
|
half4 s4 = SceneToWorkingSpace(SAMPLE_TEXTURE2D_X(sourceTexture, sampler_LinearClamp, float2(tc12.x, tc3.y)));
|
||
|
|
|
||
|
|
half cw0 = (w12.x * w0.y);
|
||
|
|
half cw1 = (w0.x * w12.y);
|
||
|
|
half cw2 = (w12.x * w12.y);
|
||
|
|
half cw3 = (w3.x * w12.y);
|
||
|
|
half cw4 = (w12.x * w3.y);
|
||
|
|
|
||
|
|
s0 *= cw0;
|
||
|
|
s1 *= cw1;
|
||
|
|
s2 *= cw2;
|
||
|
|
s3 *= cw3;
|
||
|
|
s4 *= cw4;
|
||
|
|
|
||
|
|
half4 historyFiltered = s0 + s1 + s2 + s3 + s4;
|
||
|
|
half weightSum = cw0 + cw1 + cw2 + cw3 + cw4;
|
||
|
|
|
||
|
|
half4 filteredVal = historyFiltered * rcp(weightSum);
|
||
|
|
|
||
|
|
return filteredVal;
|
||
|
|
}
|
||
|
|
|
||
|
|
// From Playdead's TAA
|
||
|
|
// (half version of HDRP impl)
|
||
|
|
//
|
||
|
|
// Small color-volume min size seems to produce flicker/noise in YCoCg space, that can't be seen in RGB,
|
||
|
|
// when using low precision (RGB111110f) color textures.
|
||
|
|
half4 ClipToAABBCenter(half4 history, half4 minimum, half4 maximum)
|
||
|
|
{
|
||
|
|
// note: only clips towards aabb center (but fast!)
|
||
|
|
half4 center = 0.5 * (maximum + minimum);
|
||
|
|
half4 extents = max(0.5 * (maximum - minimum), HALF_MIN); // Epsilon to avoid precision issues with empty volume.
|
||
|
|
|
||
|
|
// This is actually `distance`, however the keyword is reserved
|
||
|
|
half4 offset = history - center;
|
||
|
|
half3 v_unit = offset.xyz / extents.xyz;
|
||
|
|
half3 absUnit = abs(v_unit);
|
||
|
|
half maxUnit = Max3(absUnit.x, absUnit.y, absUnit.z);
|
||
|
|
if (maxUnit > 1.0)
|
||
|
|
return center + (offset / maxUnit);
|
||
|
|
else
|
||
|
|
return history;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Based on HDRP
|
||
|
|
half4 FilterColor(float2 uv, float weights[9])
|
||
|
|
{
|
||
|
|
half4 filtered = weights[0] * PostFxSpaceToLinear(SampleColorPoint(uv, float2(0.0, 0.0f)));
|
||
|
|
|
||
|
|
filtered += weights[1] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(0.0f, 1.0)));
|
||
|
|
filtered += weights[2] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(1.0f, 0.0f)));
|
||
|
|
filtered += weights[3] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(-1.0f, 0.0f)));
|
||
|
|
filtered += weights[4] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(0.0f, -1.0f)));
|
||
|
|
|
||
|
|
filtered += weights[5] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(-1.0f, 1.0f)));
|
||
|
|
filtered += weights[6] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(1.0f, -1.0f)));
|
||
|
|
filtered += weights[7] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(1.0f, 1.0f)));
|
||
|
|
filtered += weights[8] * PostFxSpaceToLinear(SampleColorPoint(uv,float2(-1.0f, -1.0f)));
|
||
|
|
#if TAA_YCOCG
|
||
|
|
return half4(RGBToYCoCg(filtered.xyz), filtered.w);
|
||
|
|
#else
|
||
|
|
return filtered;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
// clampQuality:
|
||
|
|
// 0: Cross (5 taps)
|
||
|
|
// 1: 3x3 (9 taps)
|
||
|
|
// 2: Variance + MinMax 3x3 (9 taps)
|
||
|
|
// 3: Variance Clipping
|
||
|
|
//
|
||
|
|
// motionQuality:
|
||
|
|
// 0: None
|
||
|
|
// 1: 5 taps
|
||
|
|
// 2: 9 taps
|
||
|
|
// historyQuality:
|
||
|
|
// 0: Bilinear
|
||
|
|
// 1: Bilinear + discard history for UVs out of buffer
|
||
|
|
// 2: Bicubic (5 taps)
|
||
|
|
half4 DoTemporalAA(Varyings input, int clampQuality, int motionQuality, int historyQuality, int centralFiltering)
|
||
|
|
{
|
||
|
|
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
||
|
|
|
||
|
|
// uv is exactly on input pixel center (x + 0.5, y + 0.5)
|
||
|
|
float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord);
|
||
|
|
|
||
|
|
half4 colorCenter;
|
||
|
|
if(centralFiltering >= 1)
|
||
|
|
colorCenter = FilterColor(uv, _TaaFilterWeights);
|
||
|
|
else
|
||
|
|
colorCenter = SceneToWorkingSpace(SampleColorPoint( uv, float2(0,0))); // Point == Linear as uv == input pixel center.
|
||
|
|
|
||
|
|
half4 boxMax = colorCenter;
|
||
|
|
half4 boxMin = colorCenter;
|
||
|
|
half4 moment1 = colorCenter;
|
||
|
|
half4 moment2 = colorCenter * colorCenter;
|
||
|
|
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, 0.0f, -1.0f);
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, -1.0f, 0.0f);
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, 1.0f, 0.0f);
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, 0.0f, 1.0f);
|
||
|
|
|
||
|
|
if (clampQuality >= 1)
|
||
|
|
{
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, -1.0f, -1.0f);
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, 1.0f, -1.0f);
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, -1.0f, 1.0f);
|
||
|
|
AdjustColorBox(boxMin, boxMax, moment1, moment2, uv, 1.0f, 1.0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(clampQuality >= 2)
|
||
|
|
{
|
||
|
|
half perSample = 1 / half(9);
|
||
|
|
half4 mean = moment1 * perSample;
|
||
|
|
half4 stdDev = sqrt(abs(moment2 * perSample - mean * mean));
|
||
|
|
|
||
|
|
half devScale = _TaaVarianceClampScale;
|
||
|
|
half4 devMin = mean - devScale * stdDev;
|
||
|
|
half4 devMax = mean + devScale * stdDev;
|
||
|
|
|
||
|
|
// Ensure that the variance color box is not worse than simple neighborhood color box.
|
||
|
|
boxMin = max(boxMin, devMin);
|
||
|
|
boxMax = min(boxMax, devMax);
|
||
|
|
}
|
||
|
|
|
||
|
|
half bestOffsetX = 0.0f;
|
||
|
|
half bestOffsetY = 0.0f;
|
||
|
|
half bestDepth = 1.0f;
|
||
|
|
if (motionQuality >= 1)
|
||
|
|
{
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, 0.0f, 0.0f);
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, 1.0f, 0.0f);
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, 0.0f, -1.0f);
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, -1.0f, 0.0f);
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, 0.0f, 1.0f);
|
||
|
|
}
|
||
|
|
if (motionQuality >= 2)
|
||
|
|
{
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, -1.0f, -1.0f);
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, 1.0f, -1.0f);
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, -1.0f, 1.0f);
|
||
|
|
AdjustBestDepthOffset(bestDepth, bestOffsetX, bestOffsetY, uv, 1.0f, 1.0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
half2 depthOffsetUv = half2(bestOffsetX, bestOffsetY);
|
||
|
|
half2 velocity = GetVelocityWithOffset(uv, depthOffsetUv);
|
||
|
|
|
||
|
|
float2 historyUv = uv + velocity * float2(1, 1);
|
||
|
|
half4 accumulation = (historyQuality >= 2) ?
|
||
|
|
SampleBicubic5TapHalf(_TaaAccumulationTex, historyUv, _TaaAccumulationTex_TexelSize.xyzw) :
|
||
|
|
SceneToWorkingSpace(SAMPLE_TEXTURE2D_X(_TaaAccumulationTex, sampler_LinearClamp, historyUv));
|
||
|
|
|
||
|
|
half4 clampedAccumulation = (clampQuality >= 3) ? ClipToAABBCenter(accumulation, boxMin, boxMax) : clamp(accumulation, boxMin, boxMax);
|
||
|
|
|
||
|
|
// Discard (some) history when outside of history buffer (e.g. camera jump)
|
||
|
|
half frameInfluence = ((historyQuality >= 1) && any(abs(uv - 0.5 + velocity) > 0.5)) ? 1 : _TaaFrameInfluence;
|
||
|
|
|
||
|
|
half4 workingColor = ApplyHistoryColorLerp(clampedAccumulation, colorCenter, frameInfluence);
|
||
|
|
|
||
|
|
half4 dstSceneColor = WorkingSpaceToScene(workingColor);
|
||
|
|
|
||
|
|
#if _ENABLE_ALPHA_OUTPUT
|
||
|
|
return max(dstSceneColor, 0.0);
|
||
|
|
#else
|
||
|
|
// NOTE: The compiler should eliminate .w computation since it doesn't affect the output.
|
||
|
|
return half4(max(dstSceneColor.xyz, 0.0), 1.0);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
half4 DoCopy(Varyings input)
|
||
|
|
{
|
||
|
|
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
|
||
|
|
|
||
|
|
float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord.xy);
|
||
|
|
half4 color = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_PointClamp, uv);
|
||
|
|
|
||
|
|
return color;
|
||
|
|
}
|
||
|
|
#endif
|