Shader "Hidden/Universal Render Pipeline/StencilDeferred" { Properties { _StencilRef ("StencilRef", Int) = 0 _StencilReadMask ("StencilReadMask", Int) = 0 _StencilWriteMask ("StencilWriteMask", Int) = 0 _LitPunctualStencilRef ("LitPunctualStencilWriteMask", Int) = 0 _LitPunctualStencilReadMask ("LitPunctualStencilReadMask", Int) = 0 _LitPunctualStencilWriteMask ("LitPunctualStencilWriteMask", Int) = 0 _SimpleLitPunctualStencilRef ("SimpleLitPunctualStencilWriteMask", Int) = 0 _SimpleLitPunctualStencilReadMask ("SimpleLitPunctualStencilReadMask", Int) = 0 _SimpleLitPunctualStencilWriteMask ("SimpleLitPunctualStencilWriteMask", Int) = 0 _LitDirStencilRef ("LitDirStencilRef", Int) = 0 _LitDirStencilReadMask ("LitDirStencilReadMask", Int) = 0 _LitDirStencilWriteMask ("LitDirStencilWriteMask", Int) = 0 _SimpleLitDirStencilRef ("SimpleLitDirStencilRef", Int) = 0 _SimpleLitDirStencilReadMask ("SimpleLitDirStencilReadMask", Int) = 0 _SimpleLitDirStencilWriteMask ("SimpleLitDirStencilWriteMask", Int) = 0 _ClearStencilRef ("ClearStencilRef", Int) = 0 _ClearStencilReadMask ("ClearStencilReadMask", Int) = 0 _ClearStencilWriteMask ("ClearStencilWriteMask", Int) = 0 } HLSLINCLUDE #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" #include "Packages/com.unity.render-pipelines.universal/Shaders/Utils/Deferred.hlsl" #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl" struct Attributes { float4 positionOS : POSITION; uint vertexID : SV_VertexID; UNITY_VERTEX_INPUT_INSTANCE_ID }; struct Varyings { float4 positionCS : SV_POSITION; float3 screenUV : TEXCOORD1; UNITY_VERTEX_INPUT_INSTANCE_ID UNITY_VERTEX_OUTPUT_STEREO }; #if defined(_SPOT) float4 _SpotLightScale; float4 _SpotLightBias; float4 _SpotLightGuard; #endif Varyings Vertex(Attributes input) { Varyings output = (Varyings)0; UNITY_SETUP_INSTANCE_ID(input); UNITY_TRANSFER_INSTANCE_ID(input, output); UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); float3 positionOS = input.positionOS.xyz; #if defined(_SPOT) // Spot lights have an outer angle than can be up to 180 degrees, in which case the shape // becomes a capped hemisphere. There is no affine transforms to handle the particular cone shape, // so instead we will adjust the vertices positions in the vertex shader to get the tighest fit. [flatten] if (any(positionOS.xyz)) { // The hemisphere becomes the rounded cap of the cone. positionOS.xyz = _SpotLightBias.xyz + _SpotLightScale.xyz * positionOS.xyz; positionOS.xyz = normalize(positionOS.xyz) * _SpotLightScale.w; // Slightly inflate the geometry to fit the analytic cone shape. // We want the outer rim to be expanded along xy axis only, while the rounded cap is extended along all axis. positionOS.xyz = (positionOS.xyz - float3(0, 0, _SpotLightGuard.w)) * _SpotLightGuard.xyz + float3(0, 0, _SpotLightGuard.w); } #endif #if defined(_DIRECTIONAL) || defined(_FOG) || defined(_CLEAR_STENCIL_PARTIAL) || (defined(_SSAO_ONLY) && defined(_SCREEN_SPACE_OCCLUSION)) // Full screen render using a large triangle. output.positionCS = float4(positionOS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0); // Force triangle to be on zfar #elif defined(_SSAO_ONLY) && !defined(_SCREEN_SPACE_OCCLUSION) // Deferred renderer does not know whether there is a SSAO feature or not at the C# scripting level. // However, this is known at the shader level because of the shader keyword SSAO feature enables. // If the keyword was not enabled, discard the SSAO_only pass by rendering the geometry outside the screen. output.positionCS = float4(positionOS.xy, -2, 1.0); // Force triangle to be discarded #else // Light shape geometry is projected as normal. VertexPositionInputs vertexInput = GetVertexPositionInputs(positionOS.xyz); output.positionCS = vertexInput.positionCS; #endif output.screenUV = output.positionCS.xyw; #if UNITY_UV_STARTS_AT_TOP output.screenUV.xy = output.screenUV.xy * float2(0.5, -0.5) + 0.5 * output.screenUV.z; #else output.screenUV.xy = output.screenUV.xy * 0.5 + 0.5 * output.screenUV.z; #endif return output; } TEXTURE2D_X(_CameraDepthTexture); TEXTURE2D_X_HALF(_GBuffer0); TEXTURE2D_X_HALF(_GBuffer1); TEXTURE2D_X_HALF(_GBuffer2); #if _RENDER_PASS_ENABLED #define GBUFFER0 0 #define GBUFFER1 1 #define GBUFFER2 2 #define GBUFFER3 3 FRAMEBUFFER_INPUT_HALF(GBUFFER0); FRAMEBUFFER_INPUT_HALF(GBUFFER1); FRAMEBUFFER_INPUT_HALF(GBUFFER2); FRAMEBUFFER_INPUT_FLOAT(GBUFFER3); #else #ifdef GBUFFER_OPTIONAL_SLOT_1 TEXTURE2D_X_HALF(_GBuffer4); #endif #endif #if defined(GBUFFER_OPTIONAL_SLOT_2) && _RENDER_PASS_ENABLED TEXTURE2D_X_HALF(_GBuffer5); #elif defined(GBUFFER_OPTIONAL_SLOT_2) TEXTURE2D_X(_GBuffer5); #endif #ifdef GBUFFER_OPTIONAL_SLOT_3 TEXTURE2D_X(_GBuffer6); #endif float4x4 _ScreenToWorld[2]; SamplerState my_point_clamp_sampler; float3 _LightPosWS; half3 _LightColor; half4 _LightAttenuation; // .xy are used by DistanceAttenuation - .zw are used by AngleAttenuation *for SpotLights) half3 _LightDirection; // directional/spotLights support half4 _LightOcclusionProbInfo; int _LightFlags; int _ShadowLightIndex; uint _LightLayerMask; int _CookieLightIndex; half4 FragWhite(Varyings input) : SV_Target { return half4(1.0, 1.0, 1.0, 1.0); } Light GetStencilLight(float3 posWS, float2 screen_uv, half4 shadowMask, uint materialFlags) { Light unityLight; bool materialReceiveShadowsOff = (materialFlags & kMaterialFlagReceiveShadowsOff) != 0; #ifdef _LIGHT_LAYERS uint lightLayerMask =_LightLayerMask; #else uint lightLayerMask = DEFAULT_LIGHT_LAYERS; #endif #if defined(_DIRECTIONAL) #if defined(_DEFERRED_MAIN_LIGHT) unityLight = GetMainLight(); // unity_LightData.z is set per mesh for forward renderer, we cannot cull lights in this fashion with deferred renderer. unityLight.distanceAttenuation = 1.0; if (!materialReceiveShadowsOff) { #if defined(_MAIN_LIGHT_SHADOWS_SCREEN) && !defined(_SURFACE_TYPE_TRANSPARENT) float4 shadowCoord = float4(screen_uv, 0.0, 1.0); #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS) float4 shadowCoord = TransformWorldToShadowCoord(posWS.xyz); #else float4 shadowCoord = float4(0, 0, 0, 0); #endif unityLight.shadowAttenuation = MainLightShadow(shadowCoord, posWS.xyz, shadowMask, _MainLightOcclusionProbes); } #if defined(_LIGHT_COOKIES) real3 cookieColor = SampleMainLightCookie(posWS); unityLight.color *= float4(cookieColor, 1); #endif #else unityLight.direction = _LightDirection; unityLight.distanceAttenuation = 1.0; unityLight.shadowAttenuation = 1.0; unityLight.color = _LightColor.rgb; unityLight.layerMask = lightLayerMask; if (!materialReceiveShadowsOff) { #if defined(_ADDITIONAL_LIGHT_SHADOWS) unityLight.shadowAttenuation = AdditionalLightShadow(_ShadowLightIndex, posWS.xyz, _LightDirection, shadowMask, _LightOcclusionProbInfo); #endif } #endif #else PunctualLightData light; light.posWS = _LightPosWS; light.radius2 = 0.0; // only used by tile-lights. light.color = float4(_LightColor, 0.0); light.attenuation = _LightAttenuation; light.spotDirection = _LightDirection; light.occlusionProbeInfo = _LightOcclusionProbInfo; light.flags = _LightFlags; light.layerMask = lightLayerMask; unityLight = UnityLightFromPunctualLightDataAndWorldSpacePosition(light, posWS.xyz, shadowMask, _ShadowLightIndex, materialReceiveShadowsOff); #ifdef _LIGHT_COOKIES // Enable/disable is done toggling the keyword _LIGHT_COOKIES, but we could do a "static if" instead if required. // if(_CookieLightIndex >= 0) { float4 cookieUvRect = GetLightCookieAtlasUVRect(_CookieLightIndex); float4x4 worldToLight = GetLightCookieWorldToLightMatrix(_CookieLightIndex); float2 cookieUv = float2(0,0); #if defined(_SPOT) cookieUv = ComputeLightCookieUVSpot(worldToLight, posWS, cookieUvRect); #endif #if defined(_POINT) cookieUv = ComputeLightCookieUVPoint(worldToLight, posWS, cookieUvRect); #endif half4 cookieColor = SampleAdditionalLightsCookieAtlasTexture(cookieUv); cookieColor = half4(IsAdditionalLightsCookieAtlasTextureRGBFormat() ? cookieColor.rgb : IsAdditionalLightsCookieAtlasTextureAlphaFormat() ? cookieColor.aaa : cookieColor.rrr, 1); unityLight.color *= cookieColor; } #endif #endif return unityLight; } half4 DeferredShading(Varyings input) : SV_Target { UNITY_SETUP_INSTANCE_ID(input); UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input); float2 screen_uv = (input.screenUV.xy / input.screenUV.z); #if _RENDER_PASS_ENABLED float d = LOAD_FRAMEBUFFER_INPUT(GBUFFER3, input.positionCS.xy).x; half4 gbuffer0 = LOAD_FRAMEBUFFER_INPUT(GBUFFER0, input.positionCS.xy); half4 gbuffer1 = LOAD_FRAMEBUFFER_INPUT(GBUFFER1, input.positionCS.xy); half4 gbuffer2 = LOAD_FRAMEBUFFER_INPUT(GBUFFER2, input.positionCS.xy); #else // Using SAMPLE_TEXTURE2D is faster than using LOAD_TEXTURE2D on iOS platforms (5% faster shader). // Possible reason: HLSLcc upcasts Load() operation to float, which doesn't happen for Sample()? float d = SAMPLE_TEXTURE2D_X_LOD(_CameraDepthTexture, my_point_clamp_sampler, screen_uv, 0).x; // raw depth value has UNITY_REVERSED_Z applied on most platforms. half4 gbuffer0 = SAMPLE_TEXTURE2D_X_LOD(_GBuffer0, my_point_clamp_sampler, screen_uv, 0); half4 gbuffer1 = SAMPLE_TEXTURE2D_X_LOD(_GBuffer1, my_point_clamp_sampler, screen_uv, 0); half4 gbuffer2 = SAMPLE_TEXTURE2D_X_LOD(_GBuffer2, my_point_clamp_sampler, screen_uv, 0); #endif #if defined(_DEFERRED_MIXED_LIGHTING) half4 shadowMask = SAMPLE_TEXTURE2D_X_LOD(MERGE_NAME(_, GBUFFER_SHADOWMASK), my_point_clamp_sampler, screen_uv, 0); #else half4 shadowMask = 1.0; #endif #ifdef _LIGHT_LAYERS float4 renderingLayers = SAMPLE_TEXTURE2D_X_LOD(MERGE_NAME(_, GBUFFER_LIGHT_LAYERS), my_point_clamp_sampler, screen_uv, 0); uint meshRenderingLayers = uint(renderingLayers.r * 255.5); #else uint meshRenderingLayers = DEFAULT_LIGHT_LAYERS; #endif half surfaceDataOcclusion = gbuffer1.a; uint materialFlags = UnpackMaterialFlags(gbuffer0.a); half3 color = 0.0.xxx; half alpha = 1.0; #if defined(_DEFERRED_MIXED_LIGHTING) // If both lights and geometry are static, then no realtime lighting to perform for this combination. [branch] if ((_LightFlags & materialFlags) == kMaterialFlagSubtractiveMixedLighting) return half4(color, alpha); // Cannot discard because stencil must be updated. #endif #if defined(USING_STEREO_MATRICES) int eyeIndex = unity_StereoEyeIndex; #else int eyeIndex = 0; #endif float4 posWS = mul(_ScreenToWorld[eyeIndex], float4(input.positionCS.xy, d, 1.0)); posWS.xyz *= rcp(posWS.w); Light unityLight = GetStencilLight(posWS.xyz, screen_uv, shadowMask, materialFlags); [branch] if (!IsMatchingLightLayer(unityLight.layerMask, meshRenderingLayers)) return half4(color, alpha); // Cannot discard because stencil must be updated. #if defined(_SCREEN_SPACE_OCCLUSION) && !defined(_SURFACE_TYPE_TRANSPARENT) AmbientOcclusionFactor aoFactor = GetScreenSpaceAmbientOcclusion(screen_uv); unityLight.color *= aoFactor.directAmbientOcclusion; #if defined(_DIRECTIONAL) && defined(_DEFERRED_FIRST_LIGHT) // What we want is really to apply the mininum occlusion value between the baked occlusion from surfaceDataOcclusion and real-time occlusion from SSAO. // But we already applied the baked occlusion during gbuffer pass, so we have to cancel it out here. // We must also avoid divide-by-0 that the reciprocal can generate. half occlusion = aoFactor.indirectAmbientOcclusion < surfaceDataOcclusion ? aoFactor.indirectAmbientOcclusion * rcp(surfaceDataOcclusion) : 1.0; alpha = occlusion; #endif #endif InputData inputData = InputDataFromGbufferAndWorldPosition(gbuffer2, posWS.xyz); #if defined(_LIT) #if SHADER_API_MOBILE || SHADER_API_SWITCH // Specular highlights are still silenced by setting specular to 0.0 during gbuffer pass and GPU timing is still reduced. bool materialSpecularHighlightsOff = false; #else bool materialSpecularHighlightsOff = (materialFlags & kMaterialFlagSpecularHighlightsOff); #endif BRDFData brdfData = BRDFDataFromGbuffer(gbuffer0, gbuffer1, gbuffer2); color = LightingPhysicallyBased(brdfData, unityLight, inputData.normalWS, inputData.viewDirectionWS, materialSpecularHighlightsOff); #elif defined(_SIMPLELIT) SurfaceData surfaceData = SurfaceDataFromGbuffer(gbuffer0, gbuffer1, gbuffer2, kLightingSimpleLit); half3 attenuatedLightColor = unityLight.color * (unityLight.distanceAttenuation * unityLight.shadowAttenuation); half3 diffuseColor = LightingLambert(attenuatedLightColor, unityLight.direction, inputData.normalWS); half smoothness = exp2(10 * surfaceData.smoothness + 1); half3 specularColor = LightingSpecular(attenuatedLightColor, unityLight.direction, inputData.normalWS, inputData.viewDirectionWS, half4(surfaceData.specular, 1), smoothness); // TODO: if !defined(_SPECGLOSSMAP) && !defined(_SPECULAR_COLOR), force specularColor to 0 in gbuffer code color = diffuseColor * surfaceData.albedo + specularColor; #endif return half4(color, alpha); } half4 FragFog(Varyings input) : SV_Target { UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input); #if _RENDER_PASS_ENABLED float d = LOAD_FRAMEBUFFER_INPUT(GBUFFER3, input.positionCS.xy).x; #else float d = LOAD_TEXTURE2D_X(_CameraDepthTexture, input.positionCS.xy).x; #endif float eye_z = LinearEyeDepth(d, _ZBufferParams); float clip_z = UNITY_MATRIX_P[2][2] * -eye_z + UNITY_MATRIX_P[2][3]; half fogFactor = ComputeFogFactor(clip_z); half fogIntensity = ComputeFogIntensity(fogFactor); return half4(unity_FogColor.rgb, fogIntensity); } half4 FragSSAOOnly(Varyings input) : SV_Target { UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input); float2 screen_uv = (input.screenUV.xy / input.screenUV.z); AmbientOcclusionFactor aoFactor = GetScreenSpaceAmbientOcclusion(screen_uv); half surfaceDataOcclusion = SAMPLE_TEXTURE2D_X_LOD(_GBuffer1, my_point_clamp_sampler, screen_uv, 0).a; // What we want is really to apply the mininum occlusion value between the baked occlusion from surfaceDataOcclusion and real-time occlusion from SSAO. // But we already applied the baked occlusion during gbuffer pass, so we have to cancel it out here. // We must also avoid divide-by-0 that the reciprocal can generate. half occlusion = aoFactor.indirectAmbientOcclusion < surfaceDataOcclusion ? aoFactor.indirectAmbientOcclusion * rcp(surfaceDataOcclusion) : 1.0; return half4(0.0, 0.0, 0.0, occlusion); } ENDHLSL SubShader { Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline"} // 0 - Stencil pass Pass { Name "Stencil Volume" ZTest LEQual ZWrite Off ZClip false Cull Off ColorMask 0 Stencil { Ref [_StencilRef] ReadMask [_StencilReadMask] WriteMask [_StencilWriteMask] CompFront NotEqual PassFront Keep ZFailFront Invert CompBack NotEqual PassBack Keep ZFailBack Invert } HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile_vertex _ _SPOT #pragma vertex Vertex #pragma fragment FragWhite //#pragma enable_d3d11_debug_symbols ENDHLSL } // 1 - Deferred Punctual Light (Lit) Pass { Name "Deferred Punctual Light (Lit)" ZTest GEqual ZWrite Off ZClip false Cull Front Blend One One, Zero One BlendOp Add, Add Stencil { Ref [_LitPunctualStencilRef] ReadMask [_LitPunctualStencilReadMask] WriteMask [_LitPunctualStencilWriteMask] Comp Equal Pass Zero Fail Keep ZFail Keep } HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile_fragment _DEFERRED_STENCIL #pragma multi_compile _POINT _SPOT #pragma multi_compile_fragment _LIT #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS #pragma multi_compile_fragment _ _SHADOWS_SOFT #pragma multi_compile_fragment _ LIGHTMAP_SHADOW_MIXING #pragma multi_compile_fragment _ SHADOWS_SHADOWMASK #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT #pragma multi_compile_fragment _ _DEFERRED_MIXED_LIGHTING #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION #pragma multi_compile_fragment _ _LIGHT_LAYERS #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED #pragma multi_compile_fragment _ _LIGHT_COOKIES #pragma vertex Vertex #pragma fragment DeferredShading //#pragma enable_d3d11_debug_symbols ENDHLSL } // 2 - Deferred Punctual Light (SimpleLit) Pass { Name "Deferred Punctual Light (SimpleLit)" ZTest GEqual ZWrite Off ZClip false Cull Front Blend One One, Zero One BlendOp Add, Add Stencil { Ref [_SimpleLitPunctualStencilRef] ReadMask [_SimpleLitPunctualStencilReadMask] WriteMask [_SimpleLitPunctualStencilWriteMask] CompBack Equal PassBack Zero FailBack Keep ZFailBack Keep } HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile_fragment _DEFERRED_STENCIL #pragma multi_compile _POINT _SPOT #pragma multi_compile_fragment _SIMPLELIT #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS #pragma multi_compile_fragment _ _SHADOWS_SOFT #pragma multi_compile_fragment _ LIGHTMAP_SHADOW_MIXING #pragma multi_compile_fragment _ SHADOWS_SHADOWMASK #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT #pragma multi_compile_fragment _ _DEFERRED_MIXED_LIGHTING #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION #pragma multi_compile_fragment _ _LIGHT_LAYERS #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED #pragma multi_compile_fragment _ _LIGHT_COOKIES #pragma vertex Vertex #pragma fragment DeferredShading //#pragma enable_d3d11_debug_symbols ENDHLSL } // 3 - Deferred Directional Light (Lit) Pass { Name "Deferred Directional Light (Lit)" ZTest NotEqual ZWrite Off Cull Off Blend One SrcAlpha, Zero One BlendOp Add, Add Stencil { Ref [_LitDirStencilRef] ReadMask [_LitDirStencilReadMask] WriteMask [_LitDirStencilWriteMask] Comp Equal Pass Keep Fail Keep ZFail Keep } HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile_fragment _DEFERRED_STENCIL #pragma multi_compile _DIRECTIONAL #pragma multi_compile_fragment _LIT #pragma multi_compile_fragment _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN #pragma multi_compile_fragment _ _DEFERRED_MAIN_LIGHT #pragma multi_compile_fragment _ _DEFERRED_FIRST_LIGHT #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS #pragma multi_compile_fragment _ _SHADOWS_SOFT #pragma multi_compile_fragment _ LIGHTMAP_SHADOW_MIXING #pragma multi_compile_fragment _ SHADOWS_SHADOWMASK #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT #pragma multi_compile_fragment _ _DEFERRED_MIXED_LIGHTING #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION #pragma multi_compile_fragment _ _LIGHT_LAYERS #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED #pragma multi_compile_fragment _ _LIGHT_COOKIES #pragma vertex Vertex #pragma fragment DeferredShading //#pragma enable_d3d11_debug_symbols ENDHLSL } // 4 - Deferred Directional Light (SimpleLit) Pass { Name "Deferred Directional Light (SimpleLit)" ZTest NotEqual ZWrite Off Cull Off Blend One SrcAlpha, Zero One BlendOp Add, Add Stencil { Ref [_SimpleLitDirStencilRef] ReadMask [_SimpleLitDirStencilReadMask] WriteMask [_SimpleLitDirStencilWriteMask] Comp Equal Pass Keep Fail Keep ZFail Keep } HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile_fragment _DEFERRED_STENCIL #pragma multi_compile _DIRECTIONAL #pragma multi_compile_fragment _SIMPLELIT #pragma multi_compile_fragment _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN #pragma multi_compile_fragment _ _DEFERRED_MAIN_LIGHT #pragma multi_compile_fragment _ _DEFERRED_FIRST_LIGHT #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS #pragma multi_compile_fragment _ _SHADOWS_SOFT #pragma multi_compile_fragment _ LIGHTMAP_SHADOW_MIXING #pragma multi_compile_fragment _ SHADOWS_SHADOWMASK #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT #pragma multi_compile_fragment _ _DEFERRED_MIXED_LIGHTING #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION #pragma multi_compile_fragment _ _LIGHT_LAYERS #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED #pragma multi_compile_fragment _ _LIGHT_COOKIES #pragma vertex Vertex #pragma fragment DeferredShading //#pragma enable_d3d11_debug_symbols ENDHLSL } // 5 - Legacy fog Pass { Name "Fog" ZTest NotEqual ZWrite Off Cull Off Blend OneMinusSrcAlpha SrcAlpha, Zero One BlendOp Add, Add HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile _FOG #pragma multi_compile FOG_LINEAR FOG_EXP FOG_EXP2 #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED #pragma vertex Vertex #pragma fragment FragFog //#pragma enable_d3d11_debug_symbols ENDHLSL } // 6 - Clear stencil partial // This pass clears stencil between camera stacks rendering. // This is because deferred renderer encodes material properties in the 4 highest bits of the stencil buffer, // but we don't want to keep this information between camera stacks. Pass { Name "ClearStencilPartial" ColorMask 0 ZTest NotEqual ZWrite Off Cull Off Stencil { Ref [_ClearStencilRef] ReadMask [_ClearStencilReadMask] WriteMask [_ClearStencilWriteMask] Comp NotEqual Pass Zero Fail Keep ZFail Keep } HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile _CLEAR_STENCIL_PARTIAL #pragma vertex Vertex #pragma fragment FragWhite ENDHLSL } // 7 - SSAO Only // This pass only runs when there is no fullscreen deferred light rendered (no directional light). It will adjust indirect/baked lighting with realtime occlusion // by rendering just before deferred shading pass. // This pass is also completely discarded from vertex shader when SSAO renderer feature is not enabled. Pass { Name "SSAOOnly" ZTest NotEqual ZWrite Off Cull Off Blend One SrcAlpha, Zero One BlendOp Add, Add HLSLPROGRAM #pragma exclude_renderers gles gles3 glcore #pragma target 4.5 #pragma multi_compile_vertex _SSAO_ONLY #pragma multi_compile_vertex _ _SCREEN_SPACE_OCCLUSION #pragma vertex Vertex #pragma fragment FragSSAOOnly //#pragma enable_d3d11_debug_symbols ENDHLSL } } FallBack "Hidden/Universal Render Pipeline/FallbackError" }