MINIATURE CAMERA
— TILT SHIFT

Overview

Miniature Camera is a depth-of-field post-processing effect for Unity 6 URP, built entirely on the Render Graph API. It supports two visual modes (depth-based 3D DoF and screen-space linear gradient), three blur algorithms, auto-focus via screen-center raycast, game speed control, and frame-rate simulation for miniature / stop-motion looks.

Everything is configurable from the inspector, the Scene View overlay, or at runtime through a clean scripting API.

Features

Requirements

The Render Graph API (RecordRenderGraph) is required. This package does not support the legacy Execute() path or Unity 2021 / 2022 LTS. Tested on Unity 6.3, 6.4, and 6.5.

Depth Texture must be enabled on your URP Renderer asset: select the Renderer, then under Rendering, check Depth Texture. Without it, the depth buffer is unavailable and the Depth Based blur mode cannot compute focus zones.

Installation

Via Unity Package Manager

1. Open Window > Package Manager
2. Click + then Add package from disk...
3. Navigate to TiltShift/package.json
4. Click Open

Manual

Copy the Assets/TiltShift folder into your project's Assets directory.

Setup after install

1. Select your URP Renderer asset (usually in Settings/)
2. Under Rendering, ensure Depth Texture is enabled
3. Click Add Renderer Feature
4. Select Miniature Camera Render Feature
5. Assign the M_TiltShift material from TiltShift/Runtime/Shaders/
6. Optionally add Miniature Camera Time Control Feature below it for game speed and frame skip

Quick Start

Minimal setup

URP Renderer asset
  Renderer Features
    Miniature Camera Render Feature         <- add this
    Miniature Camera Time Control Feature   <- optional (game speed + frame skip)

Step 1 — Add the feature via the URP Renderer inspector.

Step 2 — Assign the material: Assets/TiltShift/Runtime/Shaders/M_TiltShift.mat

Step 3 — Play. Use the inspector sliders to configure the effect.

Scripting Quick Start

using TiltShift;
using UnityEngine;
using UnityEngine.Rendering.Universal;

public class DoFController : MonoBehaviour
{
    private TiltShiftRenderFeature feature;

    void Start()
    {
        feature = GetTiltShiftFeature();
    }

    void Update()
    {
        float dist = Vector3.Distance(Camera.main.transform.position, target.position);
        feature.SetFocusCenter(dist);
    }

    private TiltShiftRenderFeature GetTiltShiftFeature()
    {
        var urpAsset = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline
            as UniversalRenderPipelineAsset;

        var field = typeof(UniversalRenderPipelineAsset)
            .GetField("m_RendererDataList",
                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);

        var list = field?.GetValue(urpAsset) as ScriptableRendererData[];

        foreach (var data in list)
            foreach (var feat in data.rendererFeatures)
                if (feat is TiltShiftRenderFeature ts) return ts;

        return null;
    }
}

Architecture

URP Renderer Asset
  Renderer Features
    TiltShiftRenderFeature       inspector + scripting API
      TiltShiftSettings          serialized parameters
      TiltShiftPass (internal)   render graph recording
    TiltShiftTimeControlFeature  game speed + frame-rate simulation

    TiltShiftPreset              ScriptableObject assets (.asset files)

Frame execution order per camera

1. URP renders the scene normally
2. TiltShiftPass.RecordRenderGraph() adds blur passes to the graph
3. URP executes the graph — the blur result replaces activeColorTexture
4. TiltShiftTimeControlFeature optionally replaces the frame with a cached one (frame skip)
5. URP presents the final image

TiltShiftRenderFeature

Namespace: TiltShift · Inherits: ScriptableRendererFeature · File: Runtime/TiltShiftRenderFeature.cs

The main entry point. Add this to your URP Renderer asset. It owns all effect settings and exposes the scripting API.

Custom Inspector · Mode / Focus / Blur / Debug

Properties

Lifecycle

Scripting API — Focus (Depth Mode)

Scripting API — Focus (Linear Gradient Mode)

Scripting API — Blur

Scripting API — Mode Switches

Scripting API — Physical Camera

Scripting API — Debug

TiltShiftTimeControlFeature

Namespace: TiltShift · Inherits: ScriptableRendererFeature · File: Runtime/TiltShiftTimeControlFeature.cs

Optional companion feature that combines game speed control (Time.timeScale) with frame-rate simulation (frame skip) for an enhanced miniature / stop-motion camera look. Both sections can be used independently or together.

Add this feature after TiltShiftRenderFeature in the renderer so the blur is included in the cached frame.

Time Control · Game Speed + Frame Skip

WARNING — Time.timeScale is global.
The Game Speed section modifies Time.timeScale and optionally Time.fixedDeltaTime, which affect every gameplay system that reads scaled time: Physics (Rigidbody, collisions, joints), Animator and Animation components, Particle Systems, Coroutines using WaitForSeconds (use WaitForSecondsRealtime to bypass), NavMesh agents, Audio pitch (when tied to time), any custom script reading Time.deltaTime. Values are saved on activation and restored when the feature is disabled or destroyed.

Settings — Game Speed

Settings — Frame Skip

When linkFpsToGameSpeed is enabled, the effective FPS is simulatedFps * gameSpeed, clamped to [4, 30]. For example, simulatedFps = 12 and gameSpeed = 0.5 produces a 6 fps look.

How Frame Skip Works

On a render frame (once every 1/effectiveFps seconds): the current rendered image is blitted into a persistent cache (RTHandle).

On a skip frame (every other frame): the cached image is blitted back over the current frame, holding it frozen.

The GPU still renders every frame. Only the final presented image is frozen. The frame skip uses Time.unscaledTime for its interval, so it is unaffected by game speed changes.

PassData

private class PassData
{
    public RenderTargetIdentifier cacheRT;     // from RTHandle.rt, safe outside SetRenderFunc
    public TextureHandle          cameraColor; // converted to RTI inside SetRenderFunc only
    public bool                   isSkipFrame;
}

TextureHandle to RenderTargetIdentifier conversion via op_Implicit requires the Render Graph Resource Registry, which is only active inside SetRenderFunc(). Converting a TextureHandle in RecordRenderGraph() throws InvalidOperationException. Store TextureHandle fields in PassData and cast inside SetRenderFunc.

TiltShiftSettings

Namespace: TiltShift · Attribute: [Serializable] · File: Runtime/TiltShiftSettings.cs

Holds all effect parameters as serializable fields. Lives as a nested field inside TiltShiftRenderFeature and is serialized to the Renderer asset.

Tilt Shift Render Feature · Inspector

Mode

Focus Zone — Depth Mode

Auto mode reuses the Relative mode zone parameters (focusNearPercent, focusFarPercent, transitionPercent) to define the shape of the focus zone around the dynamically computed focus distance.

Focus Zone — Linear Gradient Mode

Physical Camera

Blur

Depth Protection

Performance

Debug

Computed Properties

// Sample count for the current BlurQuality
// Low=3, Medium=5, High=9, Ultra=13
int GaussianSampleCount { get; }

// Iteration count for the current BlurQuality
// Low=2, Medium=3, High=4, Ultra=6
int KawaseIterations { get; }

// Circle of Confusion formula returning blur radius in pixels.
// CoC = (f * f) / (N * (d - f)) / sensorHeight * screenHeight * 0.5
float ComputePhysicalBlurSize(float focusDistanceMeters, float screenHeightPixels);

TiltShiftPreset

Namespace: TiltShift · Inherits: ScriptableObject · File: Runtime/TiltShiftPreset.cs · Create Menu: Right-click > Create > Miniature Camera > Preset

A serialized snapshot of TiltShiftSettings stored as a .asset file.

Preset dropdown · 5 built-in presets

Properties

Methods

// Copies all values from the given settings into this preset.
void CaptureFrom(TiltShiftSettings settings);

// Applies all stored values to the given settings.
void ApplyTo(TiltShiftSettings settings);

Usage

// Save current state
var preset = ScriptableObject.CreateInstance<TiltShiftPreset>();
preset.presetName = "My Cinematic";
preset.CaptureFrom(feature.settings);
AssetDatabase.CreateAsset(preset, "Assets/MyPreset.asset");

// Apply at runtime
myPreset.ApplyTo(feature.settings);

Built-in Presets

Generate via Tools > Miniature Camera > Create Default Presets.

TiltShiftPass (internal)

Namespace: TiltShift · Visibility: internal · Inherits: ScriptableRenderPass · File: Runtime/TiltShiftPass.cs

Handles the render graph integration. Not meant for direct use — controlled through TiltShiftRenderFeature.

Shader Property IDs

All Shader.PropertyToID() calls are cached as static readonly int fields to avoid per-frame string hashing.

Shader Keywords

Render Graph Passes

Kawase and Dual Kawase passes use AddBlitPass with pre-cloned materials. At construction time, 6 permanent copies of the base material are created, each with a different _KawaseOffset value baked in. Each AddBlitPass call receives its own clone, so every iteration is genuinely independent. Without cloning, all passes would share a single material reference and read the last offset value written on CPU, making all iterations produce identical results.

Enumerations

BlurMode

public enum BlurMode
{
    DepthBased     = 0,  // Focus zone driven by the depth buffer
    LinearGradient = 1   // Screen-space focus band (photo tilt-shift look)
}

BlurEngine

public enum BlurEngine
{
    Gaussian   = 0,  // Separable Gaussian, highest quality, supports depth protection
    Kawase     = 1,  // Kawase, faster, good for mid-range hardware
    DualKawase = 2   // Dual Kawase, fastest, works at half resolution
}

BlurQuality

public enum BlurQuality
{
    Low    = 0,  // Gaussian: 3 samples  / Kawase: 2 iterations
    Medium = 1,  // Gaussian: 5 samples  / Kawase: 3 iterations
    High   = 2,  // Gaussian: 9 samples  / Kawase: 4 iterations (default)
    Ultra  = 3   // Gaussian: 13 samples / Kawase: 6 iterations
}

BokehShape

public enum BokehShape
{
    Disabled   = 0,  // Standard elliptical blur
    Circle     = 1,  // 8-direction radial sampling
    Hexagonal  = 2   // 6-direction sampling (vintage lens look)
}

DepthCalculationMode

public enum DepthCalculationMode
{
    Absolute       = 0,  // Direct world-unit values
    Relative       = 1,  // Percentages of focus distance (recommended)
    CameraRelative = 2,  // Normalized between near/far clip planes
    Auto           = 3   // Raycast from screen center (dynamic)
}

TransitionCurve

public enum TransitionCurve
{
    Linear    = 0,  // Uniform gradient
    Smooth    = 1,  // Smoothstep, natural look (recommended)
    Quadratic = 2,  // x squared, slow start then fast
    Cubic     = 3   // x cubed, very gradual edges
}

RenderScale

public enum RenderScale
{
    Full    = 1,  // Full resolution, best quality
    Half    = 2,  // Half resolution, balanced
    Quarter = 4   // Quarter resolution, fastest
}

Scripting API

Getting the Feature Reference

There is no static singleton. Locate the feature through reflection on the active renderer:

public static TiltShiftRenderFeature GetFeature()
{
    var urpAsset = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline
        as UniversalRenderPipelineAsset;
    if (urpAsset == null) return null;

    var list = typeof(UniversalRenderPipelineAsset)
        .GetField("m_RendererDataList",
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
        ?.GetValue(urpAsset) as ScriptableRendererData[];

    if (list == null) return null;

    foreach (var data in list)
        if (data != null)
            foreach (var feat in data.rendererFeatures)
                if (feat is TiltShiftRenderFeature ts) return ts;

    return null;
}

Call this once in Start() and cache the result.

Focus Tracking

void Update()
{
    float distance = Vector3.Distance(cam.transform.position, target.position);
    feature.SetFocusCenter(distance);
}

Cinematic Focus Pull

IEnumerator FocusPull(float from, float to, float duration)
{
    float t = 0f;
    while (t < 1f)
    {
        t += Time.deltaTime / duration;
        feature.SetFocusCenter(Mathf.SmoothStep(from, to, t));
        yield return null;
    }
}

Preset Switching

[SerializeField] private TiltShiftPreset portraitPreset;
[SerializeField] private TiltShiftPreset landscapePreset;

void OnDialogueStart() => portraitPreset.ApplyTo(feature.settings);
void OnDialogueEnd()   => landscapePreset.ApplyTo(feature.settings);

Physical Camera

feature.SetPhysicalCamera(
    enabled:      true,
    fStop:        1.4f,   // wide open, very shallow DoF
    focalLength:  85f,    // portrait telephoto
    sensorHeight: 24f     // full-frame sensor
);

Preset System

Creating a Preset from the Inspector

1. Click Save as Preset in the Miniature Camera inspector
2. Choose a save location
3. The preset is saved as a .asset file and auto-assigned

Creating a Preset from Code

var preset = ScriptableObject.CreateInstance<TiltShiftPreset>();
preset.presetName = "My Cinematic";
preset.description = "Hero shot";
preset.CaptureFrom(feature.settings);
AssetDatabase.CreateAsset(preset, "Assets/TiltShift/Presets/MyCinematic.asset");
AssetDatabase.SaveAssets();

Applying a Preset

From the inspector: drag a .asset file into the Preset field — it applies immediately. From code: myPreset.ApplyTo(feature.settings);

Built-in Presets

Located in Assets/TiltShift/Presets/. Generate them via Tools > Miniature Camera > Create Default Presets.

Shader Passes Reference

The S_TiltShift shader has 6 passes:

All passes read from _MainTex (the source texture provided by the blit or unsafe pass).

Performance Guide

Blur Engine Comparison

Gaussian Iterations

Each additional iteration roughly doubles the effective blur radius:

Render Scale

Use Half at 4K to reduce the blur to 1080p workload with minimal visible quality loss.

Platform Recommendations

Unity Profiler · GPU timing

Troubleshooting

Effect not visible

• Check that Depth Texture is enabled on the URP Renderer asset (under Rendering)
• Check that the M_TiltShift material is assigned in the feature inspector
• Confirm the feature is enabled in the URP Renderer asset
• Verify blurSizeH and blurSizeV are greater than 0
• In Depth Based mode, check that focusDistance and the near/far values cover objects in the scene

URP Renderer · Enable Depth Texture

Debug Mode — visualize focus zones

Toggle debugMode on the feature to paint the scene with focus-zone colors: green for the sharp focus band, red for the near blur, blue for the far blur. Invaluable to tune focusDistance and the transition widths.

Debug Overlay · Green / Red / Blue zones

InvalidOperationException: Current Render Graph Resource Registry is not set

A TextureHandle was implicitly converted to RenderTargetIdentifier outside of SetRenderFunc(). Store TextureHandle fields in PassData and perform the cast (RenderTargetIdentifier)handle only inside the SetRenderFunc lambda.

ZBinningJob errors in the console

These are cascading URP internal errors triggered by a failing render pass. Fix the primary error above and they go away.

Blur bleeds over foreground objects

Enable Depth Protection and raise depthThreshold (try 1.0 to 2.0). This only works with BlurEngine.Gaussian and BlurMode.DepthBased.

Bokeh shape not visible

Bokeh requires blurEngine == Gaussian. The radius also needs to be at least 8 pixels to show the shape clearly.

Kawase Ultra looks worse than Kawase Low

This was a bug where _KawaseOffset was set during RecordRenderGraph but all passes shared the same material reference, so every pass ended up using the last offset value. The fix uses 6 pre-cloned materials, each with a different _KawaseOffset baked in at construction time. Update to the latest version to get the fix.

Frame Skip stuttering feels too regular

Add a small random variation from code:

timeControlFeature.settings.simulatedFps = Mathf.RoundToInt(12f + Random.Range(-1f, 1f));

Time Control: game feels broken after enabling Game Speed

The Game Speed section of TiltShiftTimeControlFeature modifies Time.timeScale, which is global. Every system reading Time.deltaTime will slow down: physics, animations, particles, coroutines (WaitForSeconds), NavMesh, etc. This is by design for the miniature effect, but it will break gameplay that expects normal speed. Use during non-interactive sequences or dedicated cinematic cameras only. If the value gets stuck after a crash, reset it manually: Time.timeScale = 1f; Time.fixedDeltaTime = 0.02f;.

Time Control: fixedDeltaTime not restored

If adjustFixedDeltaTime is on and the application crashes or the domain reloads unexpectedly while the feature is active, Time.fixedDeltaTime may stay at a scaled value. Add a safety reset:

[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
static void ResetTime()
{
    Time.timeScale      = 1f;
    Time.fixedDeltaTime = 0.02f;
}

Scene View shows the effect

Set settings.applyToSceneView = false. This is the default. The feature checks cameraData.isSceneViewCamera and skips if the setting is off.

Changelog

v1.0.0

• Gaussian, Kawase, Dual Kawase blur engines
• Depth Based and Linear Gradient blur modes
• Absolute, Relative, Camera Relative, and Auto depth calculation modes
• Auto Focus — DepthCalculationMode.Auto raycasts from screen center to dynamically focus on whatever the camera is looking at. Works with perspective, orthographic, zoom, and camera movement. Configurable layer mask, max distance, and smoothing.
• Physical camera simulation using the Circle of Confusion formula
• Depth protection with bilateral sample rejection
• Bokeh shapes: Circle and Hexagonal
• Transition curves: Linear, Smooth, Quadratic, Cubic
• Render Scale at Full, Half, and Quarter resolution
• Time Control — unified Renderer Feature combining game speed (Time.timeScale, 0.01x–10x) and frame-rate simulation in a single inspector, with fixedDeltaTime scaling and global-state warnings
• Link to Game Speed option that automatically scales simulated FPS with game speed
• Time Control section in the Scene View overlay with game speed and frame skip controls
• Preset system with ScriptableObject assets and inspector buttons (5 built-in presets)
• Full scripting API with automatic value clamping
• Custom inspector with collapsible sections
• Scene View overlay for quick access to common settings
• Debug mode with focus zone color overlay
• Auto Focus debug raycast visualization in Scene View
• Unity 6 URP Render Graph support via RecordRenderGraph
• Kawase and Dual Kawase passes use pre-cloned materials with baked _KawaseOffset values