Use indirect lighting in a custom URP shader

To use indirect lighting in a custom Universal Render Pipeline (URP) shader, follow these steps:

1. Add an #include line inside the HLSLPROGRAM block in your shader file. Refer to the sections on this page for specific include file paths.
2. Use any of the methods from the following sections.

Use reflection probes in a custom URP shader

To use reflection probes or the skybox, use the following #include line:

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/GlobalIllumination.hlsl"

The GlossyEnvironmentReflection function has the following simpler overload, which does not support blending:

half3 GlossyEnvironmentReflection(half3 reflectVector, half perceptualRoughness, half occlusion)

Sample Adaptive Probe Volumes

To sample Adaptive Probe Volumes (APV), use the following #include line:

#include "Packages/com.unity.render-pipelines.core/Runtime/Lighting/ProbeVolume/ProbeVolume.hlsl"

Sample light probes

To sample light probes, use the following #include line:

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/AmbientProbe.hlsl"

Example

The following URP shader code computes diffuse and specular ambient light using the GlossyEnvironmentReflection function.

float3 CustomLightingAmbient(float3 BaseColor, 
                            float3 NormalWS, 
                            float Metallic, 
                            float Smoothness, 
                            float Reflectance, 
                            float AmbientOcclusion, 
                            float PositionWS, 
                            float2 screenspaceUV, 
                            float3 ViewDirWS)
{
    // Diffuse ambient lighting.
    // Sample the sky probe with high roughness and use a normal vector instead of
    // a reflection vector to approximate ambient light
    float3 DiffuseAmbient = GlossyEnvironmentReflection(NormalWS, PositionWS, 1, 1, screenspaceUV);
    // If the surface is metallic, set ambient to zero, otherwise multiply by BaseColor
    DiffuseAmbient *= lerp(BaseColor, float3(0,0,0), Metallic);

    // Specular ambient lighting - reflections
    // Surfaces are more reflective at glancing angles. Compute the fresnel value for reflectance.
    float Fresnel = pow((1 - dot(NormalWS, ViewDirWS)), 5);
    // Reflectance is 100% at the glancing angle
    Reflectance = lerp(Reflectance, 1, Fresnel);
    // If the object is metal, use the base color for reflectance instead.
    float3 ReflectionColor = lerp(float3(Reflectance, Reflectance, Reflectance), BaseColor, Metallic);
    // Compute the reflection vector and use it to sample the sky probe for reflections.
    float3 ReflectionVector = reflect(-ViewDirWS, NormalWS);
    float3 SpecularAmbient = GlossyEnvironmentReflection(ReflectionVector, PositionWS, 1 - Smoothness, 1, screenspaceUV);
    
    return (DiffuseAmbient + SpecularAmbient) * AmbientOcclusion;
}

Shader graph custom function node example

Shader Graph Feature Examples contain examples of custom lighting models.

To learn how to use the GlossyEnvironmentReflection function in a custom function node:

1. In the example scene, open the CustomLightingSimple shader graph.

2. Navigate to the SampleReflectionProbes sub-graph.

3. Inspect the URPReflectionProbe node. The node contains the HLSL code that uses the GlossyEnvironmentReflection function:

   #ifdef SHADERGRAPH_PREVIEW
       reflection = float3(0,0,0);
   #else
       reflection = GlossyEnvironmentReflection(reflectVector, positionWS, roughness, 1.0h, screenspaceUV);
   #endif
   

Additional resources

• Writing custom shaders
• Upgrade custom shaders for URP compatibility
• Reflection probes in URP
• HLSL in Unity
• Adaptive Probe Volumes (APV) in URP
• Light probes
• Shader Graph Feature Examples