Unity Game Engine Series Part 9: Rendering Pipelines

1. Scriptable Render Pipeline (SRP)

1.1 Built-in vs SRP

Before 2018, Unity had a single, monolithic rendering pipeline — the Built-in Render Pipeline. It was a "one size fits all" solution that tried to serve every use case but excelled at none. The SRP revolution changed this:

1.2 URP vs HDRP Decision Matrix

2. Universal Render Pipeline (URP)

2.1 URP Setup & Renderer Features

URP is Unity's go-to pipeline for the vast majority of projects. It provides excellent visual quality while maintaining the performance headroom needed for mobile, VR, and cross-platform titles.

// Custom URP Renderer Feature — add a full-screen effect
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class GrayscaleRendererFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class Settings
    {
        public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingPostProcessing;
        public Material grayscaleMaterial;
        [Range(0f, 1f)] public float intensity = 1f;
    }

    public Settings settings = new Settings();
    private GrayscaleRenderPass renderPass;

    public override void Create()
    {
        renderPass = new GrayscaleRenderPass(settings);
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        if (settings.grayscaleMaterial == null) return;
        renderer.EnqueuePass(renderPass);
    }

    class GrayscaleRenderPass : ScriptableRenderPass
    {
        private Settings settings;
        private RTHandle tempTexture;

        public GrayscaleRenderPass(Settings settings)
        {
            this.settings = settings;
            this.renderPassEvent = settings.renderPassEvent;
        }

        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CommandBuffer cmd = CommandBufferPool.Get("GrayscaleEffect");

            var cameraColorTarget = renderingData.cameraData.renderer.cameraColorTargetHandle;

            settings.grayscaleMaterial.SetFloat("_Intensity", settings.intensity);

            // Blit: copy screen through grayscale shader
            Blit(cmd, cameraColorTarget, tempTexture, settings.grayscaleMaterial);
            Blit(cmd, tempTexture, cameraColorTarget);

            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
    }
}

2.2 Forward & Forward+ Rendering

URP supports multiple rendering paths that determine how lights interact with objects:

3. High Definition Render Pipeline (HDRP)

3.1 Physically-Based Lighting & Ray Tracing

HDRP is designed for projects where visual fidelity is paramount. It uses physically accurate lighting models, HDR color space, and supports hardware-accelerated ray tracing for photorealistic rendering:

3.2 Beyond Gaming: Film, Automotive & Arch-Viz

HDRP has found significant adoption outside traditional game development:

4. Shader Graph

4.1 Visual Shader Editor

Shader Graph is Unity's node-based visual shader editor. It allows you to create complex shader effects by connecting nodes in a graph, without writing a single line of HLSL code. Think of it as visual programming for GPU effects.

4.2 Toon, Dissolve & Hologram Shader Recipes

Here are the key concepts behind popular Shader Graph effects. While Shader Graph is visual, understanding the node logic helps you design custom shaders:

// Dissolve shader logic (conceptual — represents Shader Graph node flow)
// In Shader Graph, these would be connected as nodes:

// 1. Sample a noise texture (Gradient Noise or imported texture)
//    Input: UV coordinates
//    Output: float noise value (0-1)

// 2. Compare noise with a dissolve threshold (exposed property 0-1)
//    Step(threshold, noiseValue) — outputs 0 or 1
//    This creates the dissolve mask

// 3. Create an edge glow at the dissolve boundary
//    Smoothstep(threshold - edgeWidth, threshold, noiseValue)
//    Subtract the hard Step result to isolate the edge band
//    Multiply by emission color (hot orange/white)

// 4. Apply to material:
//    Alpha = Step result (clips dissolved pixels)
//    Emission = edge glow (makes the dissolve edge glow)
//    Base Color = original texture * Step result

// The equivalent HLSL for a Custom Function node:
/*
void DissolveEffect_float(
    float NoiseValue,
    float Threshold,
    float EdgeWidth,
    float3 EdgeColor,
    out float Alpha,
    out float3 Emission)
{
    Alpha = step(Threshold, NoiseValue);
    float edge = smoothstep(Threshold - EdgeWidth, Threshold, NoiseValue);
    Emission = EdgeColor * (edge - Alpha) * 3.0; // Boost emission
}
*/

// Hologram shader logic
// Combines multiple effects for a sci-fi holographic look:

// 1. Fresnel Effect — bright edges based on view angle
//    FresnelEffect(Normal, ViewDir, Power)
//    Makes object edges glow brighter (rim light effect)

// 2. Scanlines — horizontal lines scrolling over the surface
//    sin(ScreenPosition.y * frequency + Time * speed)
//    Step(0.5, sinResult) creates sharp scanline bands

// 3. Vertex displacement — subtle jitter
//    Offset vertices along normal by noise * small amount
//    Creates holographic "glitch" instability

// 4. Transparency — object is semi-transparent
//    Alpha = Fresnel * BaseAlpha + ScanlineAlpha
//    Surface type: Transparent, Blend mode: Additive

// 5. Color — single hologram tint (cyan, blue, or green)
//    Multiply all outputs by hologram color

5. HLSL Shader Programming

5.1 Vertex & Fragment Shader Structure

While Shader Graph handles most needs, understanding HLSL (High Level Shading Language) is essential for advanced effects, debugging shader issues, and writing custom lighting models. Every shader runs in two stages:

// Complete URP-compatible HLSL shader
Shader "Custom/ToonShader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BaseColor ("Base Color", Color) = (1, 1, 1, 1)
        _ShadowColor ("Shadow Color", Color) = (0.3, 0.3, 0.5, 1)
        _ShadowThreshold ("Shadow Threshold", Range(0, 1)) = 0.5
        _ShadowSmoothness ("Shadow Smoothness", Range(0, 0.5)) = 0.02
        _RimColor ("Rim Color", Color) = (1, 1, 1, 1)
        _RimPower ("Rim Power", Range(1, 10)) = 4
        _RimThreshold ("Rim Threshold", Range(0, 1)) = 0.5
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForward" }

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE

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

            // Vertex input structure
            struct Attributes
            {
                float4 positionOS : POSITION;    // Object-space position
                float3 normalOS : NORMAL;         // Object-space normal
                float2 uv : TEXCOORD0;           // UV coordinates
            };

            // Vertex-to-fragment interpolated data
            struct Varyings
            {
                float4 positionCS : SV_POSITION;  // Clip-space position
                float2 uv : TEXCOORD0;
                float3 normalWS : TEXCOORD1;      // World-space normal
                float3 positionWS : TEXCOORD2;    // World-space position
                float3 viewDirWS : TEXCOORD3;     // View direction
            };

            // Shader properties
            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            CBUFFER_START(UnityPerMaterial)
                float4 _MainTex_ST;
                float4 _BaseColor;
                float4 _ShadowColor;
                float _ShadowThreshold;
                float _ShadowSmoothness;
                float4 _RimColor;
                float _RimPower;
                float _RimThreshold;
            CBUFFER_END

            // Vertex shader
            Varyings vert(Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                output.positionWS = TransformObjectToWorld(input.positionOS.xyz);
                output.normalWS = TransformObjectToWorldNormal(input.normalOS);
                output.uv = TRANSFORM_TEX(input.uv, _MainTex);
                output.viewDirWS = GetWorldSpaceNormalizeViewDir(output.positionWS);
                return output;
            }

            // Fragment shader — toon lighting
            half4 frag(Varyings input) : SV_Target
            {
                // Sample base texture
                half4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.uv);

                // Get main directional light
                Light mainLight = GetMainLight();
                float3 lightDir = mainLight.direction;

                // Toon shading — step function for hard shadow edge
                float NdotL = dot(normalize(input.normalWS), lightDir);
                float shadow = smoothstep(
                    _ShadowThreshold - _ShadowSmoothness,
                    _ShadowThreshold + _ShadowSmoothness,
                    NdotL
                );

                // Blend between shadow and lit color
                float3 lighting = lerp(_ShadowColor.rgb, float3(1,1,1), shadow);

                // Rim lighting (Fresnel)
                float rimDot = 1.0 - dot(normalize(input.viewDirWS), normalize(input.normalWS));
                float rim = smoothstep(_RimThreshold, 1.0, pow(rimDot, _RimPower));

                // Final color
                float3 finalColor = texColor.rgb * _BaseColor.rgb * lighting * mainLight.color;
                finalColor += rim * _RimColor.rgb;

                return half4(finalColor, 1.0);
            }
            ENDHLSL
        }
    }
}

5.2 Custom Lighting Models

// Custom lighting function for Shader Graph (Custom Function node)
// Save as .hlsl file and reference in a Custom Function node

// Cel/Toon lighting with configurable bands
void CelShading_float(
    float3 Normal,
    float3 LightDirection,
    float3 LightColor,
    float Bands,          // Number of shading bands (2 = light/dark, 3 = light/mid/dark)
    float Smoothness,     // Edge softness between bands
    out float3 Output)
{
    float NdotL = dot(Normal, LightDirection);
    float lightIntensity = (NdotL + 1.0) * 0.5; // Remap -1..1 to 0..1

    // Quantize to discrete bands
    lightIntensity = floor(lightIntensity * Bands) / Bands;

    // Optional: smooth the band transitions
    // lightIntensity = smoothstep(0, Smoothness, frac(lightIntensity * Bands));

    Output = LightColor * lightIntensity;
}

6. Lighting Systems

6.1 Light Types & Modes

Lighting modes determine when lighting is calculated:

6.2 Global Illumination, Light Probes & Reflection Probes

Global Illumination (GI) simulates how light bounces between surfaces. Without GI, a room lit by a window would have harsh light on one side and pure black everywhere else. GI adds realistic indirect illumination — the red wall reflecting red light onto the white ceiling, for example.

// Configuring lightmapping via script
using UnityEditor;
using UnityEngine;

public class LightmapConfigurator
{
    [MenuItem("Lighting/Setup Production Lightmaps")]
    public static void ConfigureProductionLightmaps()
    {
        // Access Lightmap settings
        LightmapEditorSettings.lightmapper = LightmapEditorSettings.Lightmapper.ProgressiveGPU;

        // Resolution: texels per unit (higher = better quality, longer bake)
        LightmapEditorSettings.bakeResolution = 40; // Production quality
        LightmapEditorSettings.padding = 2;

        // Bounces: how many times light bounces between surfaces
        LightmapEditorSettings.maxBounces = 4; // 2-3 for most scenes, 4+ for interiors

        // Environment lighting
        RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox;
        RenderSettings.ambientIntensity = 1.0f;

        // Light Probes: capture indirect lighting for dynamic objects
        // Place Light Probe Groups in areas where dynamic objects move
        // Denser probes near light transitions (doorways, shadows)

        Debug.Log("Lightmap settings configured for production bake.");
    }
}

// Runtime: Light Probe usage for dynamic objects
public class DynamicObjectLighting : MonoBehaviour
{
    // Light Probes automatically affect objects with:
    // - MeshRenderer.lightProbeUsage = LightProbeUsage.BlendProbes
    // This interpolates between nearby probes for smooth indirect lighting
    // on dynamic (non-static) objects

    // Reflection Probes: capture reflections for PBR materials
    // - Place at eye height in each distinct area
    // - Set to Baked for static environments
    // - Set to Realtime (expensive!) only for dynamic reflections
    // - Use Box Projection for indoor probes (parallax-correct reflections)
}

7. History: From Fixed Function to SRP

Exercises & Self-Assessment

Conclusion & Next Steps

You now understand Unity's rendering architecture from pipeline selection to shader authoring to professional lighting. Here are the key takeaways from Part 9:

• Choose URP for 90%+ of projects — it covers mobile, VR, PC, and consoles with excellent performance. Only choose HDRP for photorealistic or high-end PC/console projects
• SRP Batcher is the single most impactful rendering optimization — always enable it in URP/HDRP projects
• Shader Graph handles most shader needs visually. Use Sub Graphs for reusable effects. Drop into HLSL only when Shader Graph cannot express what you need
• HLSL knowledge is essential for understanding what happens under the hood, debugging shader issues, and writing custom lighting models
• Lighting modes (Baked, Real-time, Mixed) are not mutually exclusive — most production scenes use Mixed lighting with baked GI and real-time shadows
• Light Probes and Reflection Probes bridge the gap between baked environments and dynamic objects — never skip them
• Profile GPU time — rendering is typically the bottleneck. Use the Frame Debugger and GPU Profiler to identify expensive passes