Shader "OnTileUberPost"
{
HLSLINCLUDE
#pragma multi_compile_local_fragment _ _HDR_GRADING _TONEMAP_ACES _TONEMAP_NEUTRAL
#pragma multi_compile_local_fragment _ _FILM_GRAIN
#pragma multi_compile_local_fragment _ _DITHERING
#pragma multi_compile_local_fragment _ _GAMMA_20 _LINEAR_TO_SRGB_CONVERSION
#pragma multi_compile_local_fragment _ _USE_FAST_SRGB_LINEAR_CONVERSION
#pragma multi_compile_local_fragment _ _ENABLE_ALPHA_OUTPUT
#include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Filtering.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/ScreenCoordOverride.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/Debug/DebuggingFullscreen.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/DynamicScalingClamping.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl"
TEXTURE2D(_InternalLut);
TEXTURE2D(_UserLut);
TEXTURE2D(_BlueNoise_Texture);
TEXTURE2D(_Grain_Texture);
float4 _Lut_Params;
float4 _UserLut_Params;
half4 _Vignette_Params1;
float4 _Vignette_Params2;
#ifdef USING_STEREO_MATRICES
float4 _Vignette_ParamsXR;
#endif
float2 _Grain_Params;
float4 _Grain_TilingParams;
float4 _Dithering_Params;
float4 _HDROutputLuminanceParams;
#define VignetteColor _Vignette_Params1.xyz
#ifdef USING_STEREO_MATRICES
#define VignetteCenterEye0 _Vignette_ParamsXR.xy
#define VignetteCenterEye1 _Vignette_ParamsXR.zw
#else
#define VignetteCenter _Vignette_Params2.xy
#endif
#define VignetteIntensity _Vignette_Params2.z
#define VignetteSmoothness _Vignette_Params2.w
#define VignetteRoundness _Vignette_Params1.w
#define LutParams _Lut_Params.xyz
#define PostExposure _Lut_Params.w
#define UserLutParams _UserLut_Params.xyz
#define UserLutContribution _UserLut_Params.w
#define GrainIntensity _Grain_Params.x
#define GrainResponse _Grain_Params.y
#define GrainScale _Grain_TilingParams.xy
#define GrainOffset _Grain_TilingParams.zw
#define DitheringScale _Dithering_Params.xy
#define DitheringOffset _Dithering_Params.zw
#define AlphaScale 1.0
#define AlphaBias 0.0
#define MinNits _HDROutputLuminanceParams.x
#define MaxNits _HDROutputLuminanceParams.y
#define PaperWhite _HDROutputLuminanceParams.z
#define OneOverPaperWhite _HDROutputLuminanceParams.w
half4 UberPost(half4 inputColor, float2 uv)
{
half3 color = inputColor.rgb;
// Gamma space... Just do the rest of Uber in linear and convert back to sRGB at the end
#if UNITY_COLORSPACE_GAMMA
{
color = GetSRGBToLinear(color);
inputColor = GetSRGBToLinear(inputColor);
}
#endif
// To save on variants we use an uniform branch for vignette. This may have performance impact on lower end platforms
UNITY_BRANCH
if (VignetteIntensity > 0)
{
#ifdef USING_STEREO_MATRICES
// With XR, the views can use asymmetric FOV which will have the center of each
// view be at a different location.
const float2 VignetteCenter = unity_StereoEyeIndex == 0 ? VignetteCenterEye0 : VignetteCenterEye1;
#endif
color = ApplyVignette(color, uv, VignetteCenter, VignetteIntensity, VignetteRoundness, VignetteSmoothness, VignetteColor);
}
// Color grading is always enabled when post-processing/uber is active
{
color = ApplyColorGrading(color, PostExposure, TEXTURE2D_ARGS(_InternalLut, sampler_LinearClamp), LutParams, TEXTURE2D_ARGS(_UserLut, sampler_LinearClamp), UserLutParams, UserLutContribution, PaperWhite, OneOverPaperWhite);
}
#if _FILM_GRAIN
{
color = ApplyGrain(color, uv, TEXTURE2D_ARGS(_Grain_Texture, sampler_LinearRepeat), GrainIntensity, GrainResponse, GrainScale, GrainOffset, OneOverPaperWhite);
}
#endif
// When Unity is configured to use gamma color encoding, we ignore the request to convert to gamma 2.0 and instead fall back to sRGB encoding
#if _GAMMA_20 && !UNITY_COLORSPACE_GAMMA
{
color = LinearToGamma20(color);
inputColor = LinearToGamma20(inputColor);
}
// Back to sRGB
#elif UNITY_COLORSPACE_GAMMA || _LINEAR_TO_SRGB_CONVERSION
{
color = GetLinearToSRGB(color);
inputColor = LinearToSRGB(inputColor);
}
#endif
#if _DITHERING
{
color = ApplyDithering(color, uv, TEXTURE2D_ARGS(_BlueNoise_Texture, sampler_PointRepeat), DitheringScale, DitheringOffset, PaperWhite, OneOverPaperWhite);
}
#endif
#if _ENABLE_ALPHA_OUTPUT
// Saturate is necessary to avoid issues when additive blending pushes the alpha over 1.
return half4(color, saturate(inputColor.a));
#else
return half4(color, 1);
#endif
}
ENDHLSL
SubShader
{
Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline"}
Pass
{
Name "OnTileUberPost"
LOD 100
ZTest Always ZWrite Off Cull Off
HLSLPROGRAM
#pragma vertex Vert
#pragma fragment FragUberPost
// Declares the framebuffer input as a texture 2d containing half.
FRAMEBUFFER_INPUT_X_HALF(0);
half4 FragUberPost(Varyings input) : SV_Target
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = input.texcoord;
// NOTE: Hlsl specifies missing input.a to fill 1 (0 for .rgb).
// InputColor is a "bottom" layer for alpha output.
half4 inputColor = LOAD_FRAMEBUFFER_X_INPUT(0, input.positionCS.xy);
return UberPost(inputColor, uv);
}
ENDHLSL
}
Pass
{
Name "OnTileUberPostMSSoftware"
LOD 100
ZTest Always ZWrite Off Cull Off
HLSLPROGRAM
#pragma vertex Vert
#pragma fragment FragUberPostMSSoftware
#pragma target 5.0
#pragma multi_compile _ _MSAA_2 _MSAA_4
#if defined(_MSAA_2)
#define MSAA_SAMPLES 2
#elif defined(_MSAA_4)
#define MSAA_SAMPLES 4
#else
#define MSAA_SAMPLES 1
#endif
// Declares the framebuffer input as a texture 2d containing half.
FRAMEBUFFER_INPUT_X_HALF_MS(0);
half4 MSAAShaderResolveInputAttachment0(float2 pos, const int msaaSamples)
{
half4 inputColor = half4(0.0, 0.0, 0.0, 0.0);
UNITY_UNROLL
for (int i = 0; i < msaaSamples; ++i) {
half4 col = LOAD_FRAMEBUFFER_INPUT_X_MS(0, i, pos);
inputColor = inputColor + col;
}
return inputColor / msaaSamples;
}
// Run run at fragment frequency and perform a software resolve of the MSAA
// color samples and then run the post-process shader the average result. Faster but not as correct
// as running it per-sample. The resultant output can either be written to a non MSAA surface as it has
// been resolved or to a MSAA surface where all the samples will end up the same which some hardware
// resolve operations will optimize due to detecting no difference in a fragment.
half4 FragUberPostMSSoftware(Varyings input) : SV_Target0
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = input.texcoord;
// NOTE: Hlsl specifies missing input.a to fill 1 (0 for .rgb).
// InputColor is a "bottom" layer for alpha output.
half4 inputColor = MSAAShaderResolveInputAttachment0(input.positionCS.xy, MSAA_SAMPLES);
return UberPost(inputColor, uv);
}
ENDHLSL
}
Pass
{
Name "OnTileUberPostTextureReadVersion"
LOD 100
ZTest Always ZWrite Off Cull Off
HLSLPROGRAM
#pragma vertex Vert
#pragma fragment FragUberPostTextureReadVersion
#pragma target 5.0
#pragma enable_d3d11_debug_symbols
#pragma debug
// Fallback shader to use when we can't keep things on tile, so usually in the editor when dealing with
// MSAA source targets to a non MSAA destination we can't perform a software resolve in the shader and
// so have to fall back to resolving the color target and reading it in as a texture.
// Where we have a MSAA destination we can avoid this.
half4 FragUberPostTextureReadVersion(Varyings input) : SV_Target0
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = SCREEN_COORD_APPLY_SCALEBIAS(UnityStereoTransformScreenSpaceTex(input.texcoord));
half4 inputColor = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv);
return UberPost(inputColor, uv);
}
ENDHLSL
}
// Visibility Mesh Versions ------------------------------------------------------------------------------------
Pass
{
Name "OnTileUberPostVisMesh"
LOD 100
ZTest Always ZWrite Off Cull Off
HLSLPROGRAM
#include "Packages/com.unity.render-pipelines.universal/Shaders/XR/XRVisibilityMeshHelper.hlsl"
#pragma vertex VertVisibilityMeshXR
#pragma fragment FragUberPost
// Declares the framebuffer input as a texture 2d containing half.
FRAMEBUFFER_INPUT_X_HALF(0);
half4 FragUberPost(Varyings input) : SV_Target
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = input.texcoord;
// NOTE: Hlsl specifies missing input.a to fill 1 (0 for .rgb).
// InputColor is a "bottom" layer for alpha output.
half4 inputColor = LOAD_FRAMEBUFFER_X_INPUT(0, input.positionCS.xy);
return UberPost(inputColor, uv);
}
ENDHLSL
}
Pass
{
Name "OnTileUberPostMSSoftwareVisMesh"
LOD 100
ZTest Always ZWrite Off Cull Off
HLSLPROGRAM
#include "Packages/com.unity.render-pipelines.universal/Shaders/XR/XRVisibilityMeshHelper.hlsl"
#pragma vertex VertVisibilityMeshXR
#pragma fragment FragUberPostMSSoftware
#pragma target 5.0
#pragma multi_compile _ _MSAA_2 _MSAA_4
#if defined(_MSAA_2)
#define MSAA_SAMPLES 2
#elif defined(_MSAA_4)
#define MSAA_SAMPLES 4
#else
#define MSAA_SAMPLES 1
#endif
// Declares the framebuffer input as a texture 2d containing half.
FRAMEBUFFER_INPUT_X_HALF_MS(0);
half4 MSAAShaderResolveInputAttachment0(float2 pos, const int msaaSamples)
{
half4 inputColor = half4(0.0, 0.0, 0.0, 0.0);
UNITY_UNROLL
for (int i = 0; i < msaaSamples; ++i) {
half4 col = LOAD_FRAMEBUFFER_INPUT_X_MS(0, i, pos);
inputColor = inputColor + col;
}
return inputColor / msaaSamples;
}
// Run at fragment frequency and perform a software resolve of the MSAA
// color samples and then run the post-process shader the average result. Faster but not as correct
// as running it per-sample. The resultant output can either be written to a non MSAA surface as it has
// been resolved or to a MSAA surface where all the samples will end up the same which some hardware
// resolve operations will optimize due to detecting no difference in a fragment.
half4 FragUberPostMSSoftware(Varyings input) : SV_Target0
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = input.texcoord;
// NOTE: Hlsl specifies missing input.a to fill 1 (0 for .rgb).
// InputColor is a "bottom" layer for alpha output.
half4 inputColor = MSAAShaderResolveInputAttachment0(input.positionCS.xy, MSAA_SAMPLES);
return UberPost(inputColor, uv);
}
ENDHLSL
}
Pass
{
Name "OnTileUberPostTextureReadVersionVisMesh"
LOD 100
ZTest Always ZWrite Off Cull Off
HLSLPROGRAM
#include "Packages/com.unity.render-pipelines.universal/Shaders/XR/XRVisibilityMeshHelper.hlsl"
#pragma vertex VertVisibilityMeshXR
#pragma fragment FragUberPostTextureReadVersion
#pragma target 5.0
#pragma debug
// Fallback shader to use when we can't keep things on tile, so usually in the editor when dealing with
// MSAA source targets to a non MSAA destination we can't perform a software resolve in the shader and
// so have to fall back to resolving the color target and reading it in as a texture.
// Where we have a MSAA destination we can avoid this.
half4 FragUberPostTextureReadVersion(Varyings input) : SV_Target0
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = SCREEN_COORD_APPLY_SCALEBIAS(UnityStereoTransformScreenSpaceTex(input.texcoord));
half4 inputColor = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_LinearClamp, uv);
return UberPost(inputColor, uv);
}
ENDHLSL
}
}
}