d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
119 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: b296444d0c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b296444d0c'
${ noResults }
source-engine/materialsystem/stdshaders/Engine_Post_ps2x.fxc

433 lines
17 KiB
Raw Blame History

// STATIC: "CONVERT_TO_SRGB" "0..1" [ps20b][= g_pHardwareConfig->NeedsShaderSRGBConversion()] [PC]
// STATIC: "CONVERT_TO_SRGB" "0..0" [= 0] [XBOX]
// STATIC: "LINEAR_INPUT" "0..1" [ps20b]
// STATIC: "LINEAR_OUTPUT" "0..1" [ps20b]
// DYNAMIC: "AA_ENABLE" "0..1"
// rem DYNAMIC: "AA_DEBUG_MODE" "0..3"
#define AA_DEBUG_MODE 0
// DYNAMIC: "AA_QUALITY_MODE" "0..0" [ps20]
// DYNAMIC: "AA_QUALITY_MODE" "0..1" [ps20b]
// DYNAMIC: "AA_QUALITY_MODE" "0..1" [ps30]
// DYNAMIC: "AA_REDUCE_ONE_PIXEL_LINE_BLUR" "0..0" [ps20]
// DYNAMIC: "AA_REDUCE_ONE_PIXEL_LINE_BLUR" "0..1" [ps20b]
// DYNAMIC: "AA_REDUCE_ONE_PIXEL_LINE_BLUR" "0..1" [ps30]
// DYNAMIC: "COL_CORRECT_NUM_LOOKUPS" "0..4"
#define HDRTYPE HDR_TYPE_NONE
#include "common_ps_fxc.h"
#if !(defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0))
// Only allow debug modes and high-quality mode if in ps2b or higher (not enough instruction slots in ps20)
#undef AA_DEBUG_MODE
#define AA_DEBUG_MODE 0
#endif
/*
* Engine_Post combines bloom (the final simple addition) with software anti-aliasing
* and colour-correction. Combining them has these benefits:
* (a) saves fillrate+bandwidth (big on PC)
* (b) saves calls to UpdateScreenEffectTexture (big on 360)
* (c) reduces quantization errors caused by multiple passes
* (d) improves AA quality (it works better on sRGB values than linear)
*
*
* Software AA Summary
* -------------------
*
* This AA process works by sampling neighbour pixels (4 or 8 of them):
*
* 5-tap filter: # 9-tap filter: ###
* (AA_QUALITY_MODE 0) ### (AA_QUALITY_MODE 1) ###
* # ###
*
* It then figures out which of these neighbours are 'unlike' the centre pixel.
* This is based on RGB distance, weighted by the maximum luminance of the samples
* (so the difference between 0.1 and 0.2 is the same as between 0.5 and 1.0).
* This detects high-contrast edges in both dark and bright scenes.
*
* It then counts how many 'unlike' samples there are. Some example cases for 5-tap:
*
* O # # # # #
* OOO OOO #OO OOO #O# #O#
* O O O # O #
* Zero One TwoA TwoB Three Four
*
* We then blend towards the average of the unlike neighbours, based on how many
* unlike neighbours there are. The key case is 'TwoA' - this detects stairstep pixels
* on non-axis-aligned edges. In that case, we blend the output colour towards the
* average of the unlike samples by 33%. This yields a 3-pixel transition (0->33->66->100)
* where before there was a 1-pixel transition (0->100).
*
* The 9-tap filter (which works the same as 5-tap, just with more samples and different
* weights) has two advantages over the 5-tap filter:
* - it can differentiate between stairsteps on 45-degree edges and near-horizontal edges
* (so the 5-tap version smudges 45-degree edges more than you want, e.g. chain-link fences)
* - it blurs less texture detail, by virtue of averaging out noise over more samples
*
* One problem case that both filters have to consider is one-pixel-thick lines (this is
* case 'TwoB' above). Sometimes you do want to soften these lines (for slivers of brightly-lit
* geometry in a dark area, e.g. a window frame), but sometimes you do NOT want to soften them
* (for thin geometry which is alternating between 1-pixel and 2-pixel thickness, e.g. cables,
* and also where 1-pixel lines appear in textures, e.g. roof tiles). So, blurring of 1-pixel
* lines is tunable (it defaults to half-blurred as a compromise between the want/don't cases),
* in the 'AA_REDUCE_ONE_PIXEL_LINE_BLUR' section below. Case TwoB is differentiated from TwoA by
* computing the centroid of the unlike samples (the centroid will be at zero for case TwoB,
* but not for TwoA).
*
*/
sampler BaseTextureSampler : register( s0 );
sampler FBTextureSampler : register( s1 );
sampler ColorCorrectionVolumeTexture0 : register( s2 );
sampler ColorCorrectionVolumeTexture1 : register( s3 );
sampler ColorCorrectionVolumeTexture2 : register( s4 );
sampler ColorCorrectionVolumeTexture3 : register( s5 );
float4 psTapOffs_Packed : register( c0 ); // psTapOffs_packed contains 1-pixel offsets: ( +dX, 0, +dY, -dX )
float4 tweakables : register( c1 ); // (x - AA strength/unused) (y - reduction of 1-pixel-line blur)
// (z - edge threshold multipler) (w - tap offset multiplier)
float4 uvTransform : register( c2 ); // Transform BaseTexture UVs for use with the FBTexture
float ColorCorrectionDefaultWeight : register( c3 );
float4 ColorCorrectionVolumeWeights : register( c4 );
float BloomFactor : register( c5 );
float4 GetBloomColor( float2 bloomUV )
{
#if ( LINEAR_INPUT == 1 )
{
// In this case, which is only used on OpenGL, we want sRGB data from this tex2D.
// Hence, we have to undo the sRGB conversion that we are forced to apply by OpenGL
return LinearToGamma( tex2D( BaseTextureSampler, bloomUV ) );
}
#else
{
return tex2D( BaseTextureSampler, bloomUV );
}
#endif
}
float4 PerformColorCorrection( float4 outColor, float2 fbTexCoord )
{
#if ( COL_CORRECT_NUM_LOOKUPS > 0 )
{
// NOTE: This code requires the color correction texture to be 32 units to be correct.
// This code will cause (0,0,0) to be read from 0.5f/32
// and (1,1,1) to be read from 31.5f/32
float4 offsetOutColor = outColor*(31.0f/32.0f) + (0.5f/32.0f);
outColor.rgb = outColor.rgb * ColorCorrectionDefaultWeight;
outColor.rgb += tex3D( ColorCorrectionVolumeTexture0, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.x;
#if ( COL_CORRECT_NUM_LOOKUPS > 1 )
{
outColor.rgb += tex3D( ColorCorrectionVolumeTexture1, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.y;
#if ( COL_CORRECT_NUM_LOOKUPS > 2 )
{
outColor.rgb += tex3D( ColorCorrectionVolumeTexture2, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.z;
#if ( COL_CORRECT_NUM_LOOKUPS > 3 )
{
outColor.rgb += tex3D( ColorCorrectionVolumeTexture3, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.w;
}
#endif
}
#endif
}
#endif
}
#endif
return outColor;
}
float3 PerformAA( float3 baseColor, float2 fbTexCoord, out float3 unlike, out float unlikeSum, out float lerpFactor )
{
float3 a, b, c, d, e, f, g, h;
float3 dA, dB, dC, dD, dE, dF, dG, dH;
float4 deltas, deltas2;
float4 weights, weights2;
float4 lumS;
float maxLumS;
// Set FAST_DELTAS to '1' to use Manhattan distance (in colour-space) rather than Euclidean distance:
const int FAST_DELTAS = 1;
#if AA_QUALITY_MODE == 0
const float COLOUR_DELTA_BASE = (FAST_DELTAS == 0) ? 0.11f : 0.5f;
const float COLOUR_DELTA_CONTRAST = 100;
// Scaling down colour deltas (DELTA_SCALE) reduces the over-blurring of 45-degree edges
// by the 5-tap filter. Conversely, increasing it smooths stairsteps more strongly.
const float DELTA_SCALE = 0.75f;
#else // AA_QUALITY_MODE == 0
const float COLOUR_DELTA_BASE = (FAST_DELTAS == 0) ? 0.24f : 0.65f;
const float COLOUR_DELTA_CONTRAST = 100;
const float DELTA_SCALE = 1.0f;
#endif // AA_QUALITY_MODE == 0
const float MAX_LERP_FACTOR = 0.66f;
const float SQRT3 = 1.73205080757f;
float onePixelLineBlurReduction = tweakables.y;
// psTapOffs_packed contains 1-pixel offsets: ( +dX, 0, +dY, -dX )
float4 texelDelta = psTapOffs_Packed*tweakables.w;
// Allowed ps20 swizzles:
// .xyzw on (+dX,0,+dY,-dX) gives: (+dX, 0) & (-dX, 0) (former with 'add', latter with 'sub')
// .yzxw on (+dX,0,+dY,-dX) gives: ( 0,+dY) & ( 0,-dY)
// .wzyx on (+dX,0,+dY,-dX) gives: (-dX,+dY) & (+dX,-dY)
// .zxyw on (not used)
// NOTE: These don't give us (+dX,+dY) and (-dX,-dY), we need to copy +dY: ( +dX, 0, +dY, -dX ) -> ( +dX, +dY, +dY, -dX )
// NOTE: tex2D() can't swizzle the source register in ps2x, so we have no
// choice but to add each float2 offset to fbTexCoord one at a time :o/
a = tex2D( FBTextureSampler, fbTexCoord + texelDelta.yz ).rgb; // ( 0,+1)
b = tex2D( FBTextureSampler, fbTexCoord + texelDelta.xy ).rgb; // (+1, 0)
c = tex2D( FBTextureSampler, fbTexCoord - texelDelta.yz ).rgb; // ( 0,-1)
d = tex2D( FBTextureSampler, fbTexCoord - texelDelta.xy ).rgb; // (-1, 0)
#if AA_QUALITY_MODE == 1
// 9-tap method (do diagonal neighbours too)
e = tex2D( FBTextureSampler, fbTexCoord + texelDelta.wz ).rgb; // (-1,+1)
f = tex2D( FBTextureSampler, fbTexCoord - texelDelta.wz ).rgb; // (+1,-1)
texelDelta.y = texelDelta.z; // Can't quite get all 8 sample offsets from a single float4 with the allowed swizzles! :o/
g = tex2D( FBTextureSampler, fbTexCoord + texelDelta.xy ).rgb; // (+1,+1)
h = tex2D( FBTextureSampler, fbTexCoord - texelDelta.xy ).rgb; // (-1,-1)
#endif // AA_QUALITY_MODE == 1
// Compute the like<-->unlike weights
dA = a - baseColor;
dB = b - baseColor;
dC = c - baseColor;
dD = d - baseColor;
#if AA_QUALITY_MODE == 1
dE = e - baseColor;
dF = f - baseColor;
dG = g - baseColor;
dH = h - baseColor;
#endif // AA_QUALITY_MODE == 1
#if ( FAST_DELTAS == 0 )
{
// Colour-space Euclidean distance
deltas = float4( dot(dA, dA), dot(dB, dB), dot(dC, dC), dot(dD, dD) );
deltas = DELTA_SCALE*DELTA_SCALE*(deltas / 3);
deltas = sqrt(deltas);
}
#else
{
// Colour-space Manhattan distance
// OPT: to avoid the 'abs', try dividing colours by maxLumS then dotprodding w/ baseColor
deltas.x = dot( abs( dA ), 1 );
deltas.y = dot( abs( dB ), 1 );
deltas.z = dot( abs( dC ), 1 );
deltas.w = dot( abs( dD ), 1 );
deltas *= DELTA_SCALE;
}
#endif
weights = deltas;
#if AA_QUALITY_MODE == 1
#if ( FAST_DELTAS == 0 )
{
deltas2 = float4( dot(dE, dE), dot(dF, dF), dot(dG, dG), dot(dH, dH) );
deltas2 = DELTA_SCALE*DELTA_SCALE*(deltas2 / 3);
deltas2 = sqrt(deltas2);
}
#else
{
deltas2.x = dot( abs( dE ), 1);
deltas2.y = dot( abs( dF ), 1);
deltas2.z = dot( abs( dG ), 1);
deltas2.w = dot( abs( dH ), 1);
deltas2 *= DELTA_SCALE;
}
#endif
weights2 = deltas2;
#endif // AA_QUALITY_MODE == 1
// Adjust weights relative to maximum sample luminance (local, relative contrast: 0.1 Vs 0.2 is the same as 0.5 Vs 1.0)
lumS = float4( dot(a, a), dot(b, b), dot(c, c), dot(d, d) );
lumS.xy = max( lumS.xy, lumS.wz );
lumS.x = max( lumS.x, lumS.y );
maxLumS = max( lumS.x, dot( baseColor, baseColor ) );
#if AA_QUALITY_MODE == 1
lumS = float4( dot(e, e), dot(f, f), dot(g, g), dot(h, h) );
lumS.xy = max( lumS.xy, lumS.wz );
lumS.x = max( lumS.x, lumS.y );
maxLumS = max( lumS.x, maxLumS );
#endif // AA_QUALITY_MODE == 1
float lumScale = 1.0f / sqrt( maxLumS );
weights *= lumScale;
#if AA_QUALITY_MODE == 1
weights2 *= lumScale;
#endif // AA_QUALITY_MODE == 1
// Contrast-adjust weights such that only large contrast differences are taken into account
// (pushes weights to 0.0 for 'like' neighbours and to 1.0 for 'unlike' neighbours)
float colourDeltaBase = tweakables.z*COLOUR_DELTA_BASE;
weights = saturate(colourDeltaBase + COLOUR_DELTA_CONTRAST*(weights - colourDeltaBase));
#if AA_QUALITY_MODE == 1
weights2 = saturate(colourDeltaBase + COLOUR_DELTA_CONTRAST*(weights2 - colourDeltaBase));
#endif // AA_QUALITY_MODE == 1
// Determine the average 'unlike' colour
unlikeSum = dot(weights, 1);
unlike = weights.x*a + weights.y*b + weights.z*c + weights.w*d;
#if AA_QUALITY_MODE == 1
unlikeSum += dot(weights2, 1);
unlike += weights2.x*e + weights2.y*f + weights2.z*g + weights2.w*h;
#endif // AA_QUALITY_MODE == 1
// NOTE: this can cause div-by-zero, but lerpFactor ends up at zero in that case so it doesn't matter
unlike = unlike / unlikeSum;
#if AA_REDUCE_ONE_PIXEL_LINE_BLUR
// Reduce lerpFactor for 1-pixel-thick lines - otherwise you lose texture detail, and it looks
// really weird where geometry (e.g. cables) alternates between being 1 and 2 pixels thick.
// [ The "*2" below is because the values here were tuned to reduce blurring one 1-pixel lines
// by about half (which is a good compromise between the bad cases at either end). So you
// want the controlling convar to default to 0.5 ]
const float ONE_PIXEL_LINE_BIAS_BASE = 0.4f;
const float ONE_PIXEL_LINE_BIAS_CONTRAST = 16.0f;
float2 unlikeCentroid = 0;
unlikeCentroid.x += dot( 1-weights, float4( 0, +1, 0, -1 ) ); // This 2x4 matrix is the transpose of
unlikeCentroid.y += dot( 1-weights, float4( +1, 0, -1, 0 ) ); // the neighbour sample texel offsets
#if AA_QUALITY_MODE == 0
unlikeCentroid /= 4 - unlikeSum;
#else // AA_QUALITY_MODE == 0
unlikeCentroid.x += dot( 1-weights2, float4( -1, +1, +1, -1 ) );
unlikeCentroid.y += dot( 1-weights2, float4( +1, -1, +1, -1 ) );
unlikeCentroid /= 8 - unlikeSum;
#endif // AA_QUALITY_MODE == 0
float onePixelLineBias = 1 - saturate( length(unlikeCentroid) ); // OPTIMIZE: try using distSquared, remove this sqrt
onePixelLineBias = onePixelLineBlurReduction*saturate(ONE_PIXEL_LINE_BIAS_BASE + ONE_PIXEL_LINE_BIAS_CONTRAST*(onePixelLineBias - ONE_PIXEL_LINE_BIAS_BASE));
#if AA_QUALITY_MODE == 0
unlikeSum -= 2*onePixelLineBias*0.4f*saturate( 3 - unlikeSum ); // The 'min' thing avoids this affecting lone/pair pixels
#else // AA_QUALITY_MODE == 0
unlikeSum -= 2*onePixelLineBias*1.9f*saturate( 7 - unlikeSum );
#endif // AA_QUALITY_MODE == 0
#endif // AA_REDUCE_ONE_PIXEL_LINE_BLUR
// Compute the lerp factor we use to blend between 'baseColor' and 'unlike'.
// We want to lerp 'stairstep' pixels (which have 2 unlike neighbours)
// 33% towards the 'unlike' colour, such that these hard, 1-pixel transitions
// (0% -> 100%) become soft, 3-pixel transitions (0% -> 33% -> 66% -> 100%).
float strengthMultiplier = tweakables.x;
#if ( AA_QUALITY_MODE == 0 )
{
lerpFactor = saturate( strengthMultiplier*DELTA_SCALE*( (unlikeSum - 1) / 3 ) );
// Uncomment the following to blend slightly across vertical/horizontal edges (better for 45-degree edges, worse for 90-degree edges)
//lerpFactor = saturate( strengthMultiplier*DELTA_SCALE*( unlikeSum / 6 ) );
}
#else // AA_QUALITY_MODE != 0
{
lerpFactor = saturate( strengthMultiplier*DELTA_SCALE*( (unlikeSum - 3) / 3 ) );
}
#endif
// Clamp the blend factor so that lone dot pixels aren't blurred into oblivion
lerpFactor = min( lerpFactor, MAX_LERP_FACTOR );
baseColor = lerp( baseColor, unlike, lerpFactor );
return baseColor;
}
float4 GenerateAADebugColor( float4 outColor, float3 unlike, float unlikeSum, float lerpFactor )
{
#if ( AA_DEBUG_MODE == 1 )
{
// Debug: Visualize the number of 'unlike' samples
outColor.rgb = 0;
if ( AA_QUALITY_MODE == 0 )
{
if (unlikeSum >= 0.95f) outColor.rgb = float3(1,0,0);
if (unlikeSum >= 1.95f) outColor.rgb = float3(0,1,0);
if (unlikeSum >= 2.95f) outColor.rgb = float3(0,0,1);
}
else
{
if (unlikeSum >= 2.95f) outColor.rgb = float3(1,0,0);
if (unlikeSum >= 3.95f) outColor.rgb = float3(0,1,0);
if (unlikeSum >= 4.95f) outColor.rgb = float3(0,0,1);
}
// Don't sRGB-write
}
#elif ( AA_DEBUG_MODE == 2 )
{
// Debug: Visualize the strength of lerpFactor
outColor.rgb = 0;
outColor.g = lerpFactor;
// Don't sRGB-write
}
#elif ( AA_DEBUG_MODE == 3 )
{
// Debug: Visualize the 'unlike' colour that we blend towards
outColor.rgb = lerp( 0, unlike, saturate(5*lerpFactor) );
// Do sRGB-write (if it's enabled)
outColor = FinalOutput( outColor, 0, PIXEL_FOG_TYPE_NONE, TONEMAP_SCALE_NONE );
}
#endif
return outColor;
}
float2 PerformUVTransform( float2 bloomUVs )
{
// NOTE: 'wz' is used since 'zw' is not a valid swizzle for ps20 shaders
return bloomUVs*uvTransform.wz + uvTransform.xy;
}
struct PS_INPUT
{
float2 baseTexCoord : TEXCOORD0;
#if defined( _X360 ) //avoid a shader patch on 360 due to pixel shader inputs being fewer than vertex shader outputs
float2 ZeroTexCoord : TEXCOORD1;
float2 bloomTexCoord : TEXCOORD2;
#endif
};
float4 main( PS_INPUT i ) : COLOR
{
float2 fbTexCoord = PerformUVTransform( i.baseTexCoord );
float3 baseColor = tex2D( FBTextureSampler, fbTexCoord ).rgb;
#if ( LINEAR_INPUT == 1 )
{
// In this case, which is only used on OpenGL, we want sRGB data from this tex2D.
// Hence, we have to undo the sRGB conversion that we are forced to apply by OpenGL
baseColor = LinearToGamma( baseColor );
}
#endif
float4 outColor = float4( baseColor, 1 );
#if ( AA_ENABLE == 1 )
{
float unlikeSum, lerpFactor;
float3 unlike;
outColor.rgb = PerformAA( outColor.rgb, fbTexCoord, unlike, unlikeSum, lerpFactor );
#if ( AA_DEBUG_MODE > 0 )
{
return GenerateAADebugColor( outColor, unlike, unlikeSum, lerpFactor );
}
#endif
}
#endif
float4 bloomColor = BloomFactor * GetBloomColor( i.baseTexCoord );
outColor.rgb += bloomColor.rgb;
outColor = PerformColorCorrection( outColor, fbTexCoord );
outColor = FinalOutput( outColor, 0, PIXEL_FOG_TYPE_NONE, TONEMAP_SCALE_NONE );
// Go to linear since we're forced to do an sRGB write on OpenGL in ps2b
#if ( LINEAR_OUTPUT == 1 )
{
outColor = GammaToLinear( outColor );
}
#endif
return outColor;
}