unity-shaders-rendering

What this skill does

# Unity Shaders and Rendering

## Overview

Reference for Unity's rendering systems, shader development, lighting configuration, and visual effects. Covers all three render pipelines, Shader Graph, hand-written shaders, and VFX Graph.

## Render Pipeline Comparison

| Feature | Built-in RP | URP | HDRP |
|---------|------------|-----|------|
| Target | Legacy projects | Mobile, VR, wide range | High-end PC/console |
| Shader language | Surface shaders + HLSL | HLSL (no surface shaders) | HLSL |
| Shader Graph | Yes | Yes | Yes |
| SRP Batcher | No | Yes | Yes |
| Render Features | No | Yes (ScriptableRendererFeature) | Custom Pass |
| Post-processing | Post Processing Stack v2 | Volume system (built-in) | Volume system (built-in) |
| Ray tracing | No | No (probe-based) | Yes (DXR) |
| Performance | Moderate | Optimized for scale | Highest fidelity |

**Recommendation:** Use URP for new projects unless targeting high-end visuals exclusively (HDRP). Built-in RP is legacy -- migrate when possible.

## Shader Graph

### Getting Started

1. Right-click in Project: Create > Shader Graph > URP > Lit Shader Graph
2. Double-click to open Shader Graph editor
3. Build node network connecting to Master Stack outputs
4. Create a Material using the shader, assign to renderers

### Master Stack Outputs (URP Lit)

| Output | Type | Purpose |
|--------|------|---------|
| Base Color | Color (RGB) | Albedo/diffuse color |
| Normal | Vector3 | Tangent-space normal map |
| Metallic | Float (0-1) | Metal vs. dielectric |
| Smoothness | Float (0-1) | Roughness inverse |
| Emission | Color (RGB) | Self-illumination |
| Alpha | Float (0-1) | Transparency |
| Alpha Clip Threshold | Float | Cutoff for alpha testing |

### Common Node Patterns

| Effect | Key Nodes |
|--------|-----------|
| **Dissolve** | Noise > Step > Alpha Clip + Edge emission |
| **Scrolling UV** | Time > Multiply > Add to UV |
| **Fresnel glow** | Fresnel Effect > Multiply color > Emission |
| **Triplanar mapping** | Triplanar node (avoids UV stretching) |
| **Color shift** | Lerp between colors using parameter or time |
| **Vertex displacement** | Noise > Multiply > Add to Position |
| **Outline** | Two-pass: inverted hull in custom render feature |

### Shader Graph Sub Graphs

Extract reusable node groups into Sub Graphs (Create > Shader Graph > Sub Graph). Use for shared noise functions, UV transformations, or custom lighting models.

## Hand-Written Shaders (ShaderLab + HLSL)

### URP Shader Structure

```hlsl
Shader "Custom/SimpleUnlit"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color ("Color", Color) = (1,1,1,1)
    }

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

        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

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

            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            CBUFFER_START(UnityPerMaterial)
                float4 _MainTex_ST;
                half4 _Color;
            CBUFFER_END

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
                OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
                return OUT;
            }

            half4 frag(Varyings IN) : SV_Target
            {
                half4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
                return tex * _Color;
            }
            ENDHLSL
        }
    }
}
```

**Key differences from Built-in shaders:**
- Use `HLSLPROGRAM`/`ENDHLSL` (not `CGPROGRAM`/`ENDCG`)
- Include URP shader library, not UnityCG.cginc
- Use `TEXTURE2D`/`SAMPLER` macros (not `sampler2D`)
- Wrap properties in `CBUFFER_START(UnityPerMaterial)` for SRP Batcher compatibility

## Lighting

### Light Types

| Type | Use For | Shadow Cost |
|------|---------|-------------|
| Directional | Sun, global illumination | Low (cascaded shadow maps) |
| Point | Torches, lamps | Medium |
| Spot | Flashlights, stage lights | Medium |
| Area (baked only) | Soft window light, panels | High (bake only) |

### Lighting Modes

| Mode | Description | Best For |
|------|-------------|----------|
| Realtime | Computed every frame | Dynamic objects, few lights |
| Baked | Pre-computed into lightmaps | Static environments |
| Mixed | Baked indirect + realtime direct | Best balance |

### Lightmap Baking Tips

- Set lightmap resolution based on scene scale (10-40 texels/unit for indoor)
- Use Light Probes for dynamic objects in baked scenes
- Use Reflection Probes for metallic/reflective surfaces
- Enable GPU Lightmapper for faster bake times
- Mark objects as Contribute GI in the Static flags

## Post-Processing (Volume System)

```text
Setup:
1. Add a Volume (Global or Local) to the scene
2. Create a Volume Profile asset
3. Add overrides: Bloom, Color Adjustments, Tonemapping, etc.
4. Camera must have Post Processing enabled (URP Camera settings)
```

| Effect | Performance | Notes |
|--------|-------------|-------|
| Bloom | Low | Use threshold to control intensity |
| Color Adjustments | Very Low | Saturation, contrast, color filter |
| Tonemapping | Very Low | ACES for cinematic look |
| Vignette | Very Low | Frame darkening |
| Ambient Occlusion (SSAO) | Medium | Disable on mobile |
| Depth of Field | High | Use Bokeh only for cinematics |
| Motion Blur | Medium | Can cause motion sickness in VR |

## VFX Graph vs Particle System

| Feature | Particle System (Shuriken) | VFX Graph |
|---------|---------------------------|-----------|
| Execution | CPU | GPU (compute shader) |
| Particle count | Thousands | Millions |
| Complexity | Component-based, simple | Node-based, complex |
| Platform | All | Compute shader capable only |
| Integration | Physics, collision | Limited physics |

Use Particle System for gameplay-integrated effects (physics collisions, small counts). Use VFX Graph for visual spectacles (rain, fire, magic, ambient particles).

## URP Render Features

Extend URP rendering with custom ScriptableRendererFeatures:

```csharp
public class OutlineFeature : ScriptableRendererFeature
{
    OutlinePass _pass;

    public override void Create()
    {
        _pass = new OutlinePass();
        _pass.renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData data)
    {
        renderer.EnqueuePass(_pass);
    }
}
```

Common uses: custom outlines, screen-space effects, render texture generation, stencil-based effects.

## Additional Resources

### Reference Files
- **`references/shader-recipes.md`** -- Complete shader implementations: toon/cel shading, water, dissolve, hologram, force field, procedural skybox, stencil portal, vertex animation, custom lighting models
- **`references/lighting-vfx-detail.md`** -- Advanced lighting setups, GI troubleshooting, VFX Graph cookbook (fire, smoke, electricity, portals), Scriptable Render Pipeline customization, custom render passes