HDR in Unity URP: Bloom, Tone Mapping, and HDR Display Output

Introduction

HDR, Emission, Bloom, Exposure, and Tonemapping are related but different features. Player Settings adds another: HDR Display Output.

Separate brightness during rendering from HDR display output, using an SDR-monitor experiment, diagnostics, and custom-rendering examples.

Sections 1–5 cover internal HDR; 6–8 cover output. Skip advanced sections 9–10 for troubleshooting in section 11 as needed.

Scope: Unity 6.3 LTS (6000.3), URP 17.3, English UI. Documentation review date recorded in the Japanese source: September 15, 2026. This translation does not revalidate every reference.¹

Untested examples: Unity compilation, scene execution, Player builds, HDR-display testing, and benchmarking have not been performed for this article. Observation prompts are not measured results.

1. Two meanings of HDR

HDR means High Dynamic Range. In Unity, distinguish these two uses:²

HDR rendering can end in SDR output. Games for SDR monitors can preserve HDR internally and map it to the display range afterward.²

High Definition Render Pipeline (HDRP) is not required for HDR. URP supports it, and HDRP also needs output configuration.³⁴

2. Why values above 1 matter

A white wall is not an emissive sign

These grayscale shader outputs illustrate scene values, not measured luminance:

White surface:     ( 1,  1,  1)
Emissive surface:  ( 4,  4,  4)
Strong emission:   (16, 16, 16)

Clamping them to 0–1 makes all three (1, 1, 1). Later processing cannot recover the difference.

An HDR buffer preserves differences for Bloom and later output conversion. HDR retains information; it does not simply brighten the image.²

Tone mapping is not clipping

Tone mapping remaps brightness to the output range. For example:

y = x / (1 + x)

This preserves differences within 0–1. It is not Unity's Neutral or ACES formula. Choose URP's operator in the Tonemapping Volume Override.⁵

3. Linear, HDR, gamut, and bit depth

Linear does not enable HDR output. 10-bit storage need not be HDR, and HDR does not make assets wide-gamut.⁶⁷

Set Project Settings > Player > Other Settings > Rendering > Color Space to Linear. This changes lighting and blending in existing Gamma projects; compare and readjust their appearance.⁸⁹

Do not disable sRGB (Color Texture) everywhere. Color textures and data masks differ. Disabling it skips sRGB-to-Linear sampling conversion; choose according to the data.¹⁰

4. Compare HDR on an SDR monitor

Disable HDR display output initially to isolate internal HDR from OS/display settings.

4.1 Check the active URP Asset

An asset assigned to the current Quality level overrides the default. Identify the active asset with GraphicsSettings.currentRenderPipeline.¹¹

Enable its HDR setting and set Post-processing > Grading Mode to High Dynamic Range. Grading Mode controls grading, not display output.¹²

4.2 Configure the camera and Volume

Use one Base Camera without a target RenderTexture. Enable Output > HDR Rendering and Rendering > Post Processing in its Inspector.¹³

Create GameObject > Volume > Global Volume with a new Profile and Weight 1. Include its Layer in the camera's Volume Mask. Disable other Volumes and custom Renderer Features.¹⁴¹³

Add Bloom and Tonemapping. Enable each edited setting's override checkbox:

These are examples, not defaults or universal recommendations. Leave other color/exposure adjustments off.

Bloom Threshold uses gamma-space brightness. Threshold 2 does not directly select Linear shader values above 2.¹⁵

URP includes Volume-based post-processing; do not mix in Post Processing Stack v2.¹⁶

4.3 Build an HDR Unlit Shader Graph

Create a Universal Unlit Shader Graph to avoid lighting effects. Expose a Color property named HDR Color, Mode HDR, connected to Fragment Base Color. Keep Surface Type Opaque.¹⁷¹⁸

HDR Color property
    Mode: HDR
        |
        +-- Fragment / Base Color

Create three materials, with Alpha 1. Enter RGB using the HDR picker's float display:

Each Intensity step doubles RGB: +2 means ×4, +4 means ×16—not ×4. Reopening the picker can change its color/intensity decomposition without changing stored RGB.¹⁹

Assign A, B, C to Cubes at (-1.5, 0, 0), (0, 0, 0), (1.5, 0, 0). Use camera position (0, 0, -6), rotation (0, 0, 0), Orthographic Size 2, a dark solid background, and 16:9 Game View.

4.4 Change one variable at a time

These are observation prompts, not results recorded in Unity:

Look for different values behind apparently identical whites, not just glow.

Bloom also works on 0–1 images with a low Threshold. HDR distinguishes brighter-than-white values.¹⁵

5. Separate Emission, Bloom, exposure, and tone mapping

This conceptual flow is not an exact render-pass schedule:²²⁰²¹

Shaders and lighting
    -> HDR scene color
    -> Image effects such as Bloom
    -> Post Exposure and color adjustments
    -> Tone mapping
    -> SDR or HDR display output

Emission is not Bloom

Emission represents a Lit material's self-emission; Bloom spreads bright image regions. Increasing Emission does not enable Bloom.²²¹⁵

Emission does not guarantee nearby illumination; check the GI setup and method. An additional Light can illuminate an emissive sign's surroundings.²²

This class-field declaration enables an HDR color picker, not camera HDR:²³

[SerializeField, ColorUsage(false, true)]
private Color emissionColor = Color.white;

Post Exposure comes after HDR effects

Post Exposure in Color Adjustments runs after HDR effects, before tone mapping. Raising it is not equivalent to raising Bloom's input.²⁰

Choose the emitter, Bloom extraction, or processed-image exposure control according to your goal.

Compare Neutral and ACES by appearance

Neutral minimizes hue/saturation changes. ACES approximates the reference ACES tone mapper, with stronger contrast and hue/saturation changes.⁵

For stylized emission, compare Neutral with ACES. Choose the intended look; ACES is not automatically better.

6. Enable HDR display output

URP HDR output requires Linear, an HDR-capable environment, and HDR in the active URP Asset. Check Player Other Settings:²¹³

A monitor alone is insufficient: check OS HDR settings, GPU, driver, and Graphics API.⁷

Start Windows testing with a D3D12 Player. Unity 6.3 URP also lists D3D11 and Vulkan. D3D11 HDR is Player-only, not available in the Editor or exclusive fullscreen. Use borderless fullscreen.²¹

HDR output still maps to the display range rather than sending scene values unchanged.²¹

7. Inspect HDR output in code

7.1 Read output and request status

Read HDROutputSettings.main: available includes the main display and project settings; active reports current HDR output. Availability is not a monitor-hardware-only test.²⁴²⁵

HDRModeChangeRequested reports a pending request, not current output. This diagnostic blocks further requests while one is pending; the caller checks completion later.²⁶²⁷

Save HdrOutputProbe.cs and attach it to a GameObject. It uses UnityEngine only. The source revision checked Unity 6.3 API/C# declarations, not compilation or execution. HDRModeChangeRequested is a property, without ().²⁸²⁹

using UnityEngine;

[DisallowMultipleComponent]
public sealed class HdrOutputProbe : MonoBehaviour
{
    private void Start()
    {
        LogStatus();
    }

    [ContextMenu("HDR/Log Status")]
    public void LogStatus()
    {
        var hdr = HDROutputSettings.main;
        if (hdr == null)
        {
            Debug.LogWarning("Could not retrieve HDR output settings.", this);
            return;
        }

        bool available = hdr.available;
        bool active = hdr.active;
        Debug.Log(
            $"ColorSpace={QualitySettings.activeColorSpace}, " +
            $"HDR available={available}, active={active}",
            this);

        // Do not read request status or luminance data when HDR is unavailable.
        if (!available)
        {
            Debug.Log("Skipped HDR details because HDR is unavailable.", this);
            return;
        }

        Debug.Log(
            $"API automaticHDRTonemapping={hdr.automaticHDRTonemapping}, " +
            $"HDRModeChangeRequested={hdr.HDRModeChangeRequested}",
            this);

        if (!active)
        {
            Debug.Log("HDR output is inactive. Skipped luminance data.", this);
            return;
        }

        // These are API values, not the effective settings of the URP Volume.
        Debug.Log(
            $"API paperWhiteNits={hdr.paperWhiteNits:F1} nits, " +
            $"minToneMapLuminance={hdr.minToneMapLuminance} nits, " +
            $"maxToneMapLuminance(10%)={hdr.maxToneMapLuminance} nits, " +
            $"maxFullFrameToneMapLuminance(100%)=" +
            $"{hdr.maxFullFrameToneMapLuminance} nits",
            this);
    }

    [ContextMenu("HDR/Request On")]
    public void RequestOn() => RequestMode(true);

    [ContextMenu("HDR/Request Off")]
    public void RequestOff() => RequestMode(false);

    private void RequestMode(bool enable)
    {
        if (!Application.isPlaying)
        {
            Debug.LogWarning("Call this method while the application is playing.", this);
            return;
        }

        var hdr = HDROutputSettings.main;
        // Check availability for both enabling and disabling HDR.
        if (hdr == null || !hdr.available)
        {
            Debug.LogWarning(
                "Cannot request an HDR output mode change in this environment.",
                this);
            return;
        }

        // Do not send another request, including a reversal, while one is pending.
        if (hdr.HDRModeChangeRequested)
        {
            Debug.LogWarning("An HDR output mode change request is still pending.", this);
            return;
        }

        if (hdr.active == enable)
        {
            Debug.Log($"HDR output is already in the requested state: {enable}", this);
            return;
        }

        hdr.RequestHDRModeChange(enable);
        Debug.Log(
            $"Requested HDR output change: {enable}. " +
            "Call LogStatus later to check the pending state and active output.",
            this);
    }
}

It logs at startup. Use its context menu in Play Mode, or public methods from Player UI Buttons. Install only one HdrOutputProbe.cs, not both pasted and supplied copies.

7.2 Guard both on and off requests

RequestHDRModeChange is documented to throw when HDR is unavailable. false is not exempt. Both directions use hdr == null || !hdr.available.²⁶

HDRModeChangeRequested and paperWhiteNits also document unavailable-environment exceptions. Read details after checking available, and luminance only when active.²⁷³⁰

Pending-request blocking and same-state skipping are sample policies, not mandatory Unity rules. Checking pending status first avoids treating an unfinished transition as complete.

available=true does not guarantee runtime switching everywhere. Returning from a request does not prove completion; call LogStatus() later to check pending status and active.²⁶²⁵

The sample lacks polling, timeouts, and disconnection recovery. Production UI needs availability rechecks, pending-state input restrictions, and completion updates. Save settings after confirming output, not logging a request.

7.3 Interpret API values correctly

API identifies HDR output settings, not photometer measurements or effective camera-Volume settings.²⁸³¹

maxToneMapLuminance is not an unconditional display peak. (10%) and (100%) are log labels, not API names.²⁸

paperWhiteNits is documented for automatic HDR tone mapping with active HDR output; reading it does not prove URP uses it. automaticHDRTonemapping=false does not imply that the URP Tonemapping Volume is disabled.³⁰³²³¹

URP Volumes can override Paper White and luminance limits. Check output status in logs and artistic settings in the camera's Volumes. The probe does not change automatic tone mapping or Paper White.³¹⁵

available=true, active=false means available but inactive. available=false proves neither hardware failure nor an SDR-only monitor. These examples are not captured logs.²⁴²⁵

8. Paper White and highlight limits

1 nit = 1 cd/m² is a luminance unit, not a relative shader color value.²⁸

Paper White controls reference white, including UI white—not the display's maximum brightness.²¹

For illustration, ordinary white might be 200 nits and highlights reach 1000 nits; UI need not reach the maximum. These are not universal recommendations. Shader 1.0 is not inherently 1 or 200 nits; conversion and settings determine that relationship.³¹

HDR Tonemapping adds these controls. Both Neutral and ACES support Paper White.⁵

Disable Detect Paper White for manual white in either mode. Neutral exposes Min Nits/Max Nits when Detect Brightness Limits is off; ACES uses a preset. White controls overlap, but range controls differ.⁵

An ACES 1000-nit preset does not make UI white 1000 nits. Compare UI and emission, checking Inspector overrides rather than preset names.⁵²¹

Display reports can be inaccurate. Consider user calibration across highlights, menus, subtitles, and loading screens.⁵

9. Advanced: preserve HDR data

9.1 Avoid saturating HDR color

saturate in HLSL and Shader Graph clamps to 0–1: useful for masks, destructive for HDR color before tone mapping.³³

// Expressions inside a shader, not a complete Shader file.
float3 hdrColor = baseColor * intensity;

// Outputting this as scene color loses differences above 1.
float3 clippedColor = saturate(hdrColor);

Treat masks and interpolation weights separately from colors that need an HDR range.

9.2 Avoid duplicate color conversions

New Shader Graph HDR Color Nodes use Linear; old graphs may retain compatibility behavior. Unlike color textures, they may not need conversion. Check the input space before adding .linear or pow.³⁴

9.3 Choose an appropriate RenderTexture

Intermediate RenderTexture clipping is irreversible. These formats describe raw scene-linear color before display encoding, not final HDR signals:³⁵

UNorm is not always SDR: HDR10 can use PQ-encoded 10-bit UNorm. Storage format and signal encoding both matter.⁷

URP's 64-bit HDR Precision increases precision and bandwidth cost. HDR Alpha Processing requires 64-bit; 32-bit HDR does not necessarily include alpha.¹²

A target RenderTexture hides some camera HDR controls and determines target settings. Camera HDR alone does not guarantee a suitable format.¹³

9.4 Match the custom-pass stage

Post-processed HDR output may not mean scene-linear color. At or after AfterRenderingPostProcessing, account for gamut and luminance conversion.³¹

For post-processing overlays or custom UI, check white levels and duplicate conversion. A float RenderTexture cannot prevent a doubled output transform.³⁶

9.5 EXR cannot recover discarded values

Unity can encode EXR, but the source must retain HDR data. EXR cannot restore values already lost to tone mapping or clamping.³⁷

10. Advanced: memory and performance

HDR need not double color-buffer storage: 32-bit HDR exists. At fixed resolution, 32 to 64 bits doubles an uncompressed buffer's raw size.³⁵

At 3840 × 2160:

32 bits/pixel:
3840 × 2160 × 4 bytes / 1024² ≈ 31.64 MiB

64 bits/pixel:
3840 × 2160 × 8 bytes / 1024² ≈ 63.28 MiB

These theoretical sizes cover one color buffer, not depth, MSAA, copies, history, or alignment. They are not measured application memory.

Compare HDR, precision, resolution, and Bloom separately, including high-quality Bloom filtering's added cost and benefit.¹⁵

On the same hardware and resolution, toggle HDR, 32/64-bit precision, and Bloom individually. Record GPU time and appearance.

11. Troubleshooting

These are starting points, not diagnoses:

Use Window > Analysis > Render Pipeline Debugger > Lighting > HDR Debug Mode to inspect gamut and regions above Paper White, rather than relying only on the final image.³⁸

Conclusion

Track where brightness is created, preserved, and converted for display. Compare 1, 4, and 16 with internal HDR, Bloom, and tone mapping; then inspect display output and Paper White.

Separate rendering from display-path problems, ordinary white from highlights, and always check SDR too.

1. Unity Manual, Universal RP package — Unity 6.3. ↩

2. Unity Manual, Introduction to high dynamic range (HDR). ↩

3. Unity Manual, Enable HDR Output in URP. ↩

4. Unity HDRP 17.3 documentation, HDR Output. ↩

5. Unity Manual, Tonemapping Volume Override reference for URP. ↩

6. Unity Manual, Color spaces. ↩

7. Microsoft Learn, Use DirectX with Advanced Color on high/standard dynamic range displays. See the distinctions between storage formats and encoding, and between bit depth, gamut, and dynamic range. ↩

8. Unity Manual, Set the project color space. ↩

9. Unity Manual, Differences between linear and gamma color spaces. ↩

10. Unity Manual, Disable sRGB sampling for a texture. ↩

11. Unity Scripting API, QualitySettings.renderPipeline, GraphicsSettings.currentRenderPipeline. ↩

12. Unity Manual, URP Asset reference. ↩

13. Unity Manual, Camera component reference for URP. ↩

14. Unity Manual, Add post-processing in URP. ↩

15. Unity Manual, Bloom Volume Override reference for URP. ↩

16. Unity Manual, Post-processing in URP. ↩

17. Unity Shader Graph 17.3 documentation, Property Types. ↩

18. Unity Shader Graph 17.3 documentation, Your first Shader Graph. ↩

19. Unity Manual, HDR color picker reference. ↩

20. Unity Manual, Color Adjustments Volume Override reference for URP. ↩

21. Unity Manual, HDR Output in URP. ↩

22. Unity Manual, Lit shader reference for URP. ↩

23. Unity Scripting API, ColorUsageAttribute. ↩

24. Unity Scripting API, HDROutputSettings.available. ↩

25. Unity Scripting API, HDROutputSettings.active. ↩

26. Unity Scripting API, HDROutputSettings.RequestHDRModeChange — Unity 6.0. The Japanese revision used the Unity 6.0 member page for exception conditions and request behavior, and checked the declaration against the Unity 6.3 class reference and C# reference source. It could not retrieve the 6.3 member page. Behavior in a Unity 6.3 runtime remains untested; this adaptation has not revalidated it. ↩

27. Unity Scripting API, HDROutputSettings.HDRModeChangeRequested — Unity 6.0. The Japanese revision used the Unity 6.0 member page for exception conditions and checked the property declaration against the Unity 6.3 class reference and C# reference source. This is not a Unity 6.3 runtime test. ↩

28. Unity Scripting API, HDROutputSettings. ↩

29. Unity Technologies, UnityCsReference / 6000.3 / Graphics.bindings.cs. Used in the Japanese revision to check public property and method declarations in HDROutputSettings, not native implementation details or runtime behavior. ↩

30. Unity Scripting API, HDROutputSettings.paperWhiteNits — Unity 6.3. ↩

31. Unity Manual, Troubleshoot custom render passes with HDR output in URP. ↩

32. Unity Scripting API, HDROutputSettings.automaticHDRTonemapping — Unity 6.3. ↩

33. Unity Shader Graph 17.3 documentation, Saturate Node. ↩

34. Unity Shader Graph 17.3 documentation, Color Node. ↩

35. Unity Scripting API, GraphicsFormat. ↩

36. Unity Manual, Implement a custom HDR overlay in URP. ↩

37. Unity Scripting API, ImageConversion.EncodeToEXR. ↩

38. Unity Manual, HDR Output debug views in URP. ↩