From File to Pixel · Part 05: The Engine

11 Forward vs Deferred Rendering

The rendering path determines how the engine evaluates lighting: in a single pass per object (Forward) or in two passes where geometry and lighting are fully separated (Deferred). The choice drives G-Buffer memory usage, light count scalability, transparency handling, and MSAA compatibility.

Rendering Path Decision Matrix

12 Unity URP — Render Graph Architecture

Unity 6 unified URP around a Render Graph system — a frame-graph abstraction that tracks resource lifetimes, automatically manages transient allocations, and enables native async compute scheduling. Custom passes now live in RecordRenderGraph instead of the old Execute pattern.

Pass Structure · ScriptableRendererFeature

// Unity 6 URP — Render Graph custom pass
public class MyBlurPass : ScriptableRenderPass
{
    // Declare pass data struct — passed between Record and Execute
    class PassData
    {
        public TextureHandle source;
        public TextureHandle dest;
        public Material      blurMaterial;
        public int           iterations;
    }

    public override void RecordRenderGraph(
        RenderGraph          renderGraph,
        ContextContainer     frameData)
    {
        var resourceData = frameData.Get<UniversalResourceData>();

        // Describe transient texture — allocated/freed by RenderGraph
        var desc = renderGraph.GetTextureDesc(resourceData.activeColorTexture);
        desc.name = "_BlurTemp";
        TextureHandle tempTex = renderGraph.CreateTexture(desc);

        // Add a raster render pass
        using var builder = renderGraph.AddRasterRenderPass<PassData>(
            "My Blur Pass", out var passData);

        passData.source       = resourceData.activeColorTexture;
        passData.dest         = tempTex;
        passData.blurMaterial = m_BlurMaterial;
        passData.iterations   = m_Iterations;

        // Declare resource access — RenderGraph validates and schedules
        builder.UseTexture(passData.source, AccessFlags.Read);
        builder.SetRenderAttachment(passData.dest, 0, AccessFlags.Write);

        // Execution lambda — runs on render thread
        builder.SetRenderFunc((PassData data, RasterGraphContext ctx) =>
        {
            for (int i = 0; i < data.iterations; i++)
                Blitter.BlitTexture(ctx.cmd, data.source,
                    new Vector4(1,1,0,0), data.blurMaterial, 0);
        });
    }
}

// URP ForwardLit pass — shader setup
// SRP Batcher requires ALL per-material data in UnityPerMaterial CBUFFER:
CBUFFER_START(UnityPerMaterial)
    float4 _BaseColor;
    float4 _BaseMap_ST;
    float  _Roughness;
    float  _Metallic;
    float  _OcclusionStrength;
CBUFFER_END

13 Unity HDRP — Advanced Pipeline

HDRP is a physically-based pipeline targeting high-end PC and current-gen console. From 2026 it enters maintenance mode — no new features, bug fixes only. All novel HDRP features (PLU, Physical Sky, SSR, real-time GI) are being ported to URP. This section documents the current stable HDRP architecture for existing projects.

// HDRP custom shader — uses SurfaceDescription struct
// ShaderGraph API exposed as HLSL via CustomFunction node

void MySurface_float(
    float2 uv,
    out float3 Albedo,
    out float  Smoothness,
    out float  Metallic,
    out float3 Normal,
    out float3 Emission)
{
    float4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
    Albedo     = baseMap.rgb * _BaseColor.rgb;
    Smoothness = baseMap.a * _Smoothness;
    Metallic   = _Metallic;
    Normal     = UnpackNormalScale(
        SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, uv), _NormalScale);
    Emission   = _EmissionColor.rgb * _EmissionIntensity;
}

// HDRP stacking layers for SSS (Skin, Foliage)
// SubsurfaceScattering material type writes a separate
// thickness map into GBuffer — lighting pass reads it for
// screen-space transmission evaluation

14 Unreal Engine — Nanite · Lumen · RDG

Unreal 5's three architectural pillars — Nanite, Lumen, and the Render Dependency Graph — represent a shift toward fully GPU-driven, software-defined rendering. Understanding how they interact is essential for custom shader work in UE5.

Nanite — Software Rasterizer for Micro-Polygons

Nanite replaces the traditional mesh LOD system. Geometry is stored as a hierarchical cluster DAG. At runtime, a compute shader determines the visible cluster set for the current view, rasterizes clusters in software using hardware rasterization only as a fallback for large triangles. Result: unlimited polygon budgets — the engine automatically selects cluster detail matching approximately one cluster per screen pixel.

Lumen — Dynamic Global Illumination

Lumen maintains a multi-level scene representation: Screen-Space Radiance Cache (fastest, this frame), Mesh Distance Fields (surface hits at distance), and Lumen Scene Cards (albedo/emissive/normal precomputed into atlas). Ray hits are accumulated via Software Ray Tracing against SDF, or Hardware Ray Tracing against actual triangles on supported hardware.

Render Dependency Graph (RDG)

UE5's RDG is a frame-graph system equivalent to Unity's Render Graph. All rendering passes declare their resource accesses. The RDG compiles the dependency graph, inserts automatic barriers, aliases transient resource memory, and schedules async compute passes to overlap with graphics.

// UE5 RDG — custom compute pass
void FMyPass::AddPass(
    FRDGBuilder&    GraphBuilder,
    FRDGTextureRef  InputTexture,
    FRDGTextureRef  OutputTexture)
{
    // Declare shader
    TShaderMapRef<FMyComputeShader> ComputeShader(GetGlobalShaderMap(GMaxRHIFeatureLevel));

    // Set shader parameters — RDG tracks resource access
    FMyComputeShader::FParameters* PassParameters =
        GraphBuilder.AllocParameters<FMyComputeShader::FParameters>();
    PassParameters->InputTexture  = InputTexture;
    PassParameters->OutputTexture = GraphBuilder.CreateUAV(OutputTexture);
    PassParameters->ViewUniformBuffer = View.ViewUniformBuffer;

    // Add pass — RDG inserts barriers automatically
    FIntVector GroupCount = FComputeShaderUtils::GetGroupCount(
        FIntPoint(OutputTexture->Desc.Extent), 8);

    GraphBuilder.AddPass(
        RDG_EVENT_NAME("MyComputePass"),
        PassParameters,
        ERDGPassFlags::Compute,
        [ComputeShader, PassParameters, GroupCount](FRHIComputeCommandList& RHICmdList)
        {
            FComputeShaderUtils::Dispatch(RHICmdList, ComputeShader,
                *PassParameters, GroupCount);
        });
}

// USF shader (UE5 custom shader file)
// Must go in Engine/Shaders/Private/ or plugin Shaders/ folder
#include "/Engine/Public/Platform.ush"

RWTexture2D<float4> OutputTexture;
Texture2D           InputTexture;

[numthreads(8, 8, 1)]
void MainCS(uint3 ThreadId : SV_DispatchThreadID)
{
    float4 col = InputTexture.Load(int3(ThreadId.xy, 0));
    OutputTexture[ThreadId.xy] = col * 0.5f;
}

15 API Decision Matrix

Choosing a graphics API is a platform, toolchain, and team decision — not a performance one. Modern engines abstract the API layer. This matrix captures the real-world constraints that drive the choice.

16 Profiling Tools Reference

What to Profile First — Decision Tree

• Frame time over budget → Is it CPU-bound or GPU-bound? Use stat unit in Unity/Unreal — if GPU time is the max, you're GPU-bound.
• GPU-bound → Is it ALU-bound or bandwidth-bound? NSight/RGP: SM utilisation vs L2 cache miss rate. If cache misses are high — bandwidth. If SMs are fully busy — ALU.
• ALU-bound → Profile occupancy. Low occupancy + high register count → reduce registers or increase thread count.
• Bandwidth-bound → Profile texture cache hit rate. Improve access locality. Reduce texture resolution or use BC compression.
• Mobile: bandwidth reading high → Check render pass storeOp. A STORE on depth that should be DONT_CARE is the most common mobile bandwidth bug.

17 Performance Rules — Quick Reference

18 Series Summary

Five parts, 18 chapters, one consistent theme: the hardware determines the tradeoffs, the architecture determines the cost, and the code is just the expression of that understanding.