升采样(Upsampling)技术

float SceneZ = ReadDepth( _In.UV ); // On lit le vrai Z full size

float2 UV = _In.UV - _dUV;  // Avec Unity, je dois mettre un offset sur les UV d'entrée... Don't ask !

float4 SkyZ;
SkyZ.x = tex2D( _TexDownsampledZBuffer, UV ).x; UV.xy += _dUV.xz;
SkyZ.y = tex2D( _TexDownsampledZBuffer, UV ).x; UV.xy += _dUV.zy;
SkyZ.z = tex2D( _TexDownsampledZBuffer, UV ).x; UV.xy -= _dUV.xz;
SkyZ.w = tex2D( _TexDownsampledZBuffer, UV ).x;UV.xy -= _dUV.zy;

float4 V[4];
V[0] = SampleValue( UV ); UV.xy += _dUV.xz;
V[1] = SampleValue( UV ); UV.xy += _dUV.zy;
V[3] = SampleValue( UV ); UV.xy -= _dUV.xz;
V[2] = SampleValue( UV ); UV.xy -= _dUV.zy;

// Compute bias weights toward each sample based on Z discrepancies
float WeightFactor = 2.0;
float ZInfluenceFactor = 0.001;
float4 DeltaZ = ZInfluenceFactor * abs(SceneZ - SkyZ);
float4 Weights = saturate( WeightFactor / (1.0 + DeltaZ) );

// Default UV interpolants for a normal bilinear interpolation
float2 uv = frac( UV.xy / _dUV.xy );

// This vector gives the bias toward one of the UV corners. It lies in [-1,+1]
// For equal weights, the bias sums to 0 so the UVs won't be influenced and normal bilinear filtering is applied
// Otherwise, the UVs will tend more or less strongly toward one of the corners of the low-resolution pixel where values were sampled
//
// Explicit code would be :
// float2 uv_bias  = Weights.x * float2( -1.0, -1.0 ) // Bias toward top-left
//   + Weights.y * float2( +1.0, -1.0 ) // Bias toward top-right
//   + Weights.z * float2( +1.0, +1.0 ) // Bias toward bottom-right
//   + Weights.w * float2( -1.0, +1.0 ); // Bias toward bottom-left
float2 uv_bias  = float2( Weights.y + Weights.z - Weights.x - Weights.w, Weights.z + Weights.w - Weights.x - Weights.y );

// Now, we need to apply the actual UV bias.
//
// Explicit code would be :
//  uv.x = uv_bias.x < 0.0 ? lerp( uv.x, 0.0, -uv_bias.x ) : lerp( uv.x, 1.0, uv_bias.x );
//  uv.y = uv_bias.y < 0.0 ? lerp( uv.y, 0.0, -uv_bias.y ) : lerp( uv.y, 1.0, uv_bias.y );
//
// Unfortunately, using branching 1) is bad and 2) yields some infinite values for some obscure reason !
// So we need to remove the branching.
// The idea here is to perform biasing toward top-left & bottom-right independently then choose which bias direction
// is actually needed, based on the sign of the uv_bias vector
//
float2 uv_topleft = lerp( uv, 0.0, saturate(-uv_bias) ); // Bias toward top-left corner (works if uv_bias is negative)
float2 uv_bottomright = lerp( uv, 1.0, saturate(uv_bias) ); // Bias toward bottom-right corner (works if uv_bias is positive)
float2 ChooseDirection = saturate( 10000.0 * uv_bias ); // Isolate the sign of the uv_bias vector so negative gives 0 and positive gives 1
uv = lerp( uv_topleft, uv_bottomright, ChooseDirection ); // Final bias will choose the appropriate direction based on the sign of the bias

// Perform normal bilinear filtering with biased UV interpolants
float4 FinalValue = lerp(
lerp( V[0], V[1], uv.x ),
lerp( V[2], V[3], uv.x ),
uv.y );