SPECIMEN · 020 · § I · AUTHORING · UNITY HDRP
PROJECT LAVOS · THE STACK
The pipeline is a choice. UNITY · SCRIPTABLE RENDER PIPELINE · C# · 2018

unity hdrp.

SPECIMEN 020 · SECTION I · AUTHORING
Unreal makes the choice for you. Unity makes you make it. Three pipelines ship in the same engine — Built-in for compatibility, URP for breadth, HDRP for ceiling — and the project decides which one it is. The choice is the design.
Built-in
The legacy pipeline. Largest target surface, no SRP, no fancy lighting. Compatibility default.
URP · Universal
Mobile, console, indie. Single-pass forward. The pipeline most shipped Unity games run on.
HDRP · High Definition
Cinematic ceiling. Volumetrics, SSS, anisotropy, ray tracing, the Volume framework. This page.

Three pipelines, one engine. Unity's Scriptable Render Pipeline (SRP) shipped in 2018 as the moment the rendering stack became opt-in. HDRP is the choice when the project's ceiling is cinematic — physically-based volumetric fog, subsurface scattering, anisotropic hair and brushed metal, true area lights, sky systems, eye and translucency shaders, and the framework that ties them all together: Volumes.

A Volume is an authored region of the scene with a set of overrides — exposure, fog density, color grading, bloom, ambient occlusion, dozens more. You stack volumes by priority and proximity. Cameras inside multiple volumes blend their values smoothly. The look isn't painted on; it's composed. Move the camera, the rendering shifts. Add a new volume to a region, every shot inside that region picks up the override without further authoring. The Volume framework is HDRP's signature contribution to the field — a compositional model for cinematic look-dev.

The trade against Unreal is clear in both directions. Unity ships in gigabytes; the iteration loop is shorter; the language is C#, not C++. The Asset Store is shaped differently from the Marketplace; the indie surface is broader. The cinematic ceiling — when you actually need ray-traced reflections through volumetric fog — currently still favours Unreal's Lumen for raw fidelity. But for the slot Unity won — taste-driven mid-budget production, mobile, AR, the lineage from Cuphead through Hollow Knight through Untitled Goose Game — HDRP is the choice you make when you want the cinematic ceiling without leaving the engine that ships your game.

VOLUME PROFILE · 3 GLOBAL VOLUMES · CAMERA BLENDING
60.0 fps · 16.7 ms · HDRP 17
Volume Stack
VolumeProfile_Sterile P · 10
fog · 0.04 · cool blue
exposure · 1.40 · auto
saturation · 0.85
0%
VolumeProfile_Sunset P · 12
fog · 0.10 · amber
exposure · 1.00 · −0.4 EV
bloom · 0.35
0%
VolumeProfile_Mist P · 14
fog · 0.18 · forest
exposure · 0.80 · −0.8 EV
color filter · cyan-shift
0%
Active Overrides
Fog Color
#8aa0c0
Fog Density
0.040
Exposure
1.40
Sun Tint
#dde8ff
Sun Intensity
1.20
Saturation
0.85
Color Filter
neutral
Camera
Position
0.0 · 1.6 · 0.0
Path
orbit · t=0.00
Now Inside
VolumeManager.GetGlobalVolumeWeight() · 3 active globals · blend by priority
Unity 6 · HDRP 17 · SRP Core
VolumeProfile.cs · the override that drives the look
// VolumeOverrides.cs — a HDRP volume profile authored in C#.
// Drop this on a GameObject with a Volume component; HDRP picks
// up the overrides automatically and blends them per camera.
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;

[RequireComponent(typeof(Volume))]
public class VolumeOverrides : MonoBehaviour
{
    [SerializeField] private float fogDensity = 0.04f;
    [SerializeField] private Color fogColor   = new Color(0.54f, 0.62f, 0.75f);
    [SerializeField] private float exposure   = 1.4f;

    private VolumeProfile profile;

    void Awake()
    {
        profile = GetComponent<Volume>().sharedProfile;

        // Fog override — exponential, with custom color tint.
        if (profile.TryGet<Fog>(out var fog))
        {
            fog.enabled.value      = true;
            fog.meanFreePath.value = 1f / fogDensity;
            fog.albedo.value       = fogColor;
        }

        // Exposure override — fixed mode, EV value derived from input.
        if (profile.TryGet<Exposure>(out var ex))
        {
            ex.mode.value     = ExposureMode.Fixed;
            ex.fixedExposure.value = Mathf.Log(exposure, 2f);
        }

        // Color adjustments — saturation pull and a subtle hue shift.
        if (profile.TryGet<ColorAdjustments>(out var color))
        {
            color.saturation.value = -12f;
            color.hueShift.value   = 8f;
        }

        // Bloom — subtle, not the wedding-cake kind.
        if (profile.TryGet<Bloom>(out var bloom))
        {
            bloom.intensity.value = 0.35f;
            bloom.scatter.value   = 0.7f;
        }
    }

    // HDRP's VolumeManager handles the blend. You don't.
    // Camera position + volume priority + falloff radius do the
    // arithmetic every frame.
}
Lineage
2005
Unity 1.0 ships from a small studio in Copenhagen. Cross-platform from the start; positioned as the indie/mobile choice against Unreal's enterprise reach.
2008
Unity 2.0 adds the free indie tier. The barrier-to-entry collapses. A generation of self-taught game developers learns to ship through Unity.
2012–2015
Unity dominates indie and mobile. Cuphead, Hollow Knight, Inside, Untitled Goose Game, Cult of the Lamb all ship on Unity. The aesthetic ceiling rises every year.
2017
The Scriptable Render Pipeline (SRP) is announced. Rendering becomes opt-in: pick the pipeline that matches your project's ceiling.
2018
HDRP and URP ship. The Volume framework debuts. Look-dev becomes compositional rather than baked. Subsurface scattering, anisotropy, and the Lit shader's lighting-model picker land.
2020
HDRP gains real-time ray tracing on supported hardware. Path tracing in the editor becomes a checkbox. The cinematic ceiling closes the gap.
2022
Unity 2022 LTS. HDRP and URP both production-mature. Mobile-to-cinematic on one engine, with the pipeline as the choice.
2024
Unity 6 ships. Modern viewport, GPU resident drawer, render-graph editor mature. The Volume framework remains HDRP's most-imitated contribution.
Adjacent in the stack
URP
The Universal pipeline. The other half of SRP — single-pass forward, mobile-friendly, the most-shipped pipeline.
C#
The language. Higher-level than C++, with a faster iteration loop. Unity's surface to the engine.
Shader Graph
Visual shader authoring. Unity's answer to Unreal's Material Editor. Same node-graph compositional model.
VolumeManager
The framework that blends Volume overrides per camera. The compositional core of HDRP look-dev.
ARFoundation
Unity's mobile AR layer. The reason iOS / Android AR ships through Unity more often than not.
Unreal Engine
The other engine. Same § I slot, different center of gravity — cinematic ceiling vs. the indie surface.
composed, not painted.
SPECIMEN 020 · MMXXVI
§ I · AUTHORING
prev · 019 unreal · ../the stack