🎞 Rendering Output

📖 Definition

Movie Render Queue (MRQ): Unreal's high-quality offline renderer. You hand it one or more Level Sequences as render jobs, attach settings that control quality and output, and it renders each frame with full anti-aliasing, correct motion blur, and resolved effects, then saves the result as an image sequence or video. It is the correct and only path to final frames.

💡 Where this sits in the pipeline

In the Story-to-Screen pipeline, this is the output stage: the shot is assembled, and now Unreal produces the frames that leave the engine and enter post. The Phase 7 Output page maps this handoff, and its headline is the same as this lesson's: final frames come from the Movie Render Queue, never the viewport.

💡 Preview and final are two different passes

flowchart LR
    SEQ[Level Sequence
from Lesson 2] --> PV[Editor preview
real-time approximation]
    SEQ --> MRQ[Movie Render Queue
offline render]
    PV --> BT[blocking & timing
fast, rough]
    MRQ --> FR[final frames
clean, on disk]
    FR --> POST[into post]
    style PV fill:#fff3cd,stroke:#ffc107
    style MRQ fill:#ede7f6,stroke:#7e57c2
    style FR fill:#e8f5e9,stroke:#4CAF50
                    

The same Level Sequence feeds both. The preview is for your eyes while you work; the Movie Render Queue is for the audience.

The settings that shape a render

• Output. Where and how big: the output directory, the file name pattern, the resolution (for example 1920x1080 or 3840x2160), and the frame rate. The frame range comes from the sequence's playback range by default.
• Image format. What kind of file each frame becomes: a PNG, JPG, or BMP image, an EXR image, or a video file. This is covered in detail in Section 5.
• Anti-Aliasing. The sample counts that determine how clean each frame is, plus the warm-up settings. This is Section 3.
• Rendering feature settings. Optional toggles such as the Path Tracer, high-quality shadows, or extra render passes. Path tracing is Section 4.

✅ Pro Tip: save your settings as a preset

Once you have a settings stack you like (resolution, format, sample counts, warm-up), save it as a preset. Every future job can load that preset in one click, so your whole project renders with consistent quality and you never re-type sample counts shot by shot.

📖 Definition

Spatial samples render the frame multiple times at a single instant, each jittered by a fraction of a pixel, to smooth edges (spatial anti-aliasing). Temporal samples render the frame at several sub-steps across the frame's shutter interval and accumulate them, which builds accurate motion blur and averages out time-varying noise. The total renders accumulated into one output frame is spatial × temporal.

⚠️ The classic first-frame flicker

If your render starts too bright and then darkens over the first second, or the opening frames look grainy and then clean up, you almost certainly need more warm-up frames. This is eye adaptation and temporal history catching up. Raising the warm-up count so those systems settle before frame 0 removes the flicker.

📖 Two ways to compute light

The deferred renderer is Unreal's default, real-time-derived path. It rasterizes the scene into buffers of surface data (color, normal, roughness, depth) and then computes lighting from those buffers, using fast, high-quality approximations such as Lumen global illumination and screen-space reflections. Path tracing instead traces many light rays per pixel that bounce through the scene, converging on a physically accurate, ground-truth image. It is far slower and needs hardware ray tracing.

💡 Which renderer should a shot use?

flowchart TD
    Q{Does the shot need
physically exact light?}
    Q -->|No: most cinematics| DEF[Deferred renderer
fast, Lumen + Nanite]
    Q -->|Yes: hero shot, archviz,
ground-truth reference| PT{RTX-class GPU
available?}
    PT -->|Yes| USE[Path tracing
accept longer renders]
    PT -->|No| DEF
    style DEF fill:#eef3ff,stroke:#667eea
    style USE fill:#fce4ec,stroke:#e91e63
                    

Most shots stay on the deferred renderer, which with Lumen and Nanite is production quality. Reach for path tracing only when a shot genuinely needs ground-truth light and you have the hardware and render time to spend.

💡 Path tracing and samples are the same idea again

Notice that path tracing also gets cleaner with more samples: its characteristic look at low sample counts is noise (grain), not the stair-stepping of aliasing, and both are cured by accumulating more samples. This is why MRQ's sample settings matter even more for path-traced renders, and why a path-traced hero frame can take minutes rather than milliseconds.

The formats you will choose between

• PNG (image sequence). Lossless, 8-bit, widely compatible. A solid default for previews and for shots that do not need heavy grading.
• JPG (image sequence). Lossy and small. Fine for quick dailies, poor for final work because it discards data.
• EXR (image sequence). The professional choice. OpenEXR stores high dynamic range, floating-point color, so highlights that blew out on screen are still recoverable, and it can hold multiple render passes in one file. This is what you hand a colorist or compositor.
• Video (a single file, such as ProRes or a movie container). Convenient for a one-off preview you want to play immediately, but it commits the whole render to one file.

💡 Why an image sequence, not a single video

flowchart LR
    MRQ[Movie Render Queue] --> SEQ[EXR / PNG image sequence
frame_0001, frame_0002, ...]
    SEQ --> POST[Post: grade & composite
Resolve, Nuke, After Effects]
    POST --> ENC[Encode final video
H.264 / ProRes]
    style SEQ fill:#e8f5e9,stroke:#4CAF50
    style ENC fill:#ede7f6,stroke:#7e57c2
                    

An image sequence is robust and flexible: if a render crashes at frame 900 you keep the first 899 and resume, the high dynamic range of EXR survives into color grading, and post tools expect sequences. You encode to a compressed video only at the very end, after the picture is finished.

The six steps of a render

1. Finish the sequence. Confirm the playback range, camera cuts, and timing are final in Sequencer. Rendering an unfinished cut just wastes time.
2. Open the Movie Render Queue and add the Level Sequence as a render job.
3. Set output. Choose the directory, resolution, and frame rate, and pick an image format (EXR or PNG for final work).
4. Set quality. Choose spatial and temporal sample counts, and a warm-up frame count high enough that the first frame is settled. Enable the Path Tracer only if the shot needs it.
5. Render. Press Render (Local) and let MRQ write the image sequence to disk. Batch multiple jobs to render a whole scene unattended.
6. Hand off to post. Take the image sequence into a grading or editing tool, finish the picture, and encode the final video.

✅ Pro Tip: test small before you commit

Before a long final render, do a cheap test pass: render a short slice of the range at low sample counts, or a single frame, to confirm the framing, exposure, and warm-up are right. Catching a wrong setting on one test frame is far better than discovering it after an overnight batch.

🎬 Exercise: render a five second shot

1. Open MRQ. With your sequence open, click the Render button in Sequencer (the clapperboard), or open Window then Cinematics then Movie Render Queue.
2. Add the job. Your sequence should appear as a job. If not, use the plus button and pick it.
3. Add settings. Click the job's settings and add an Output entry (set a folder and 1920x1080) and an Image Sequence PNG entry.
4. Set anti-aliasing. Add an Anti-Aliasing entry. Try 8 temporal samples and 2 spatial samples, and set an engine warm-up count of around 30 frames.
5. Render. Press Render (Local). A window shows progress frame by frame, then closes.
6. Check the output. Open the folder you chose. You will find one PNG per frame, numbered in order. That numbered sequence is your deliverable.

✅ Reach exercise: compare quality levels

Render one frame twice: once at 1 temporal and 1 spatial sample, and once at 8 temporal and 4 spatial. Open both. The difference in edge smoothness and motion blur, and in render time, is the entire point of anti-aliasing sampling made visible. If your GPU supports it, enable the Path Tracer and render that same frame a third time to see a physically accurate version.

🔑 Key Takeaways

• Final frames come from the Movie Render Queue, never a viewport screenshot; MRQ renders offline and writes files
• An MRQ queue holds render jobs (one per sequence), each with settings for output, image format, anti-aliasing, and features
• Each frame accumulates spatial × temporal samples: spatial smooths edges, temporal builds motion blur; more samples mean cleaner but slower
• Warm-up frames let eye adaptation and temporal history settle before frame 0, removing first-frame flicker and grain
• The deferred renderer is fast with approximations; path tracing is accurate but slow and needs ray-tracing hardware
• Render an EXR or PNG image sequence for robustness and high dynamic range, then encode to video in post