Director's Script and Graphic Explication for Game Cinematics

Creating a Director's Script and Graphic Explication for Game Cinematics

We develop director's scripts and graphic explications for game cinematics. Our approach is not just a table with timecodes but a detailed technical description of each shot: from Cinemachine settings to color grading parameters. Over 5 years, we've prepared documentation for 30+ projects—from mobile RPGs to PC action games. We work with Unity, Unreal Engine, Cinemachine, ShaderGraph—any stack. Our documentation is used by both technical artists and editors, eliminating misinterpretations.

If your art director reworks visuals "by eye" and your editor guesses which transition to apply, you're losing time and budget. A director's script with explication removes these guesses. Based on our experience, the lack of explication increases the number of revisions by 3x.

A director's script is a document that translates the literary script into concrete technical and visual solutions for each shot: shot size, camera movement, transitions, timecodes. The literary script answers "what happens", while the director's script answers "how it's shot and why exactly that way".

How We Create the Director's Script

The classic format is a two-column table with timecodes, shot sizes, camera movements, and transitions. Left column: shot number, shot size (close/medium/long), camera movement, transition type. Right column: character action, dialogue, technical notes (VFX, Sound FX, musical moment).

For game cinematics, we add a third column—technical constraints: which Cinemachine settings for this shot, whether animation from the library is needed, dependency on gameplay state. This immediately accounts for technical constraints.

Which Decisions Are Documented?

Choice of shot sizes. Each size carries meaning: close-up for emotion, medium for dialogue, long for scale. We document the logic of shot changes: why the transition from long to close-up happens exactly here, what it adds to the scene.

Editing rhythm. The number of shots per second directly controls energy. Action: cut every 1–2 seconds, minimal transitions. Emotional reveal: one shot for 5–8 seconds, long hold. For each cut we specify the transition type: hard cut, dissolve, match cut, smash cut.

Match cut and visual rhyme. One of the most powerful techniques: a shape or movement at the end of one shot is repeated at the beginning of the next. For example, a sunrise → a waving flag. In the script, such moments are explicitly marked—otherwise the editor might miss them.

What the Graphic Explication Includes

The explication is a separate document explaining the visual language of the clip. It includes:

• Lighting solution: for each location—light character (hard/soft), color temperature, key light direction, role of fill and rim. Not "dark atmosphere", but "overhead directional with color temperature 4200K, no fill, aggressive rim with orange tint".
• Color language: connection of color to narrative (which color belongs to the antagonist, how the palette changes with emotional shift). Specific Lift/Gamma/Gain parameters or LUT.
• Camera movement style: static for objective observer, handheld for involvement, dolly for epicness. We specify the movement type for each shot and rationale for the choice.

Why Explication Is Critical in Game Production

In game production, cinematics are created by a distributed team: animators, environment artists, technical artists, technical directors. Without a single document, each person does things "their own way"—the final clip looks pieced together. The explication is the single source of truth. "Why does this character have no shadow? Because the explication states that the revelation scene should look 'outside the real world'." Without the document, a week later someone might rewrite that decision as a bug.

Comparison: With Explication vs Without

How We Work: Step by Step

1. Analysis of script and storyboard—gather requirements, discuss visual style.
2. Development of director's script—fill the table with timecodes, movements, transitions.
3. Creation of explication—describe lighting, color, camera, justify each decision.
4. Review and revisions—usually 1–2 iterations, then we go to final.
5. Handover of documentation—ready files in a convenient format (PDF, Google Docs, Excel).

What's Included in the Work

• Director's script in tabular format with timecodes.
• Graphic explication (lighting, color, camera).
• Technical notes on Cinemachine, animations, VFX.
• Consultation on implementation (via chat or call).
• Guarantee: we revise the document if something is missed.
• We provide turnkey documentation—from script to final explication.

Timeframes and Cost

Cost is calculated individually based on volume and complexity. A director's script with explication reduces the number of iterations by 3x compared to working without documentation. Contact us to discuss your project—we will evaluate the tasks and offer the optimal solution. Get a consultation for your project—we will help determine the necessary scope of documentation.

Cinematics and Video for Games

A cutscene that looks great in the editor can turn into a slideshow in the production build: characters freeze, camera jerks, lighting doesn't match gameplay. We've encountered this dozens of times on projects for PC and mobile platforms. A proper pipeline for creating game cinematics is built from the start, not in the final week. Below is how we structure this process.

What's Included in the Service

• Storyboarding and previs – animatic with timing, storyboard, narrative alignment before production begins
• In-engine cinematics – Timeline, Cinemachine (Unity), Sequencer (Unreal)
• Rendered cutscenes – pre-rendered video with engine integration
• Procedural generation of environments and animation – for large-scale content projects
• Technical art for cinematics – camera rigs, custom Timeline tracks

Why Are In-Engine Cutscenes More Advantageous Than Pre-Rendered?

In-engine cutscenes use actual assets, respond to player state (character customization, dynamic lighting) and do not require separate video file storage. The trade-off is the complexity of the production pipeline. But for 70% of modern projects, this approach is justified: disk space savings (up to 90% for multi-cutscene games) and the ability to adapt to different resolutions without re-rendering.

Timeline Architecture

Timeline in Unity is not just an animation tool but a full time management system for any game object. Each PlayableDirector manages a TimelineAsset containing tracks:

Custom tracks via PlayableBehaviour + PlayableAsset are key for complex cutscenes. For example, a track for controlling post-processing overrides, smooth DOF blend, or synchronizing subtitles with audio tracks. Over the years, we've implemented over 20 custom tracks for specific tasks.

Cinemachine: Virtual Cameras

Cinemachine fundamentally changes the approach to camera work. Instead of a single camera with keyframes, it's a system of virtual cameras (CinemachineVirtualCamera, CinemachineFreeLook, CinemachineStateDrivenCamera) between which the main camera smoothly transitions according to blend rules.

For cinematics, the most interesting are:

• CinemachineVirtualCamera – the main tool. Each virtual camera has its own Body (how the camera follows the target) and Aim (how the camera looks at the target). Combinations:
  • Transposer + Composer: camera follows the character, keeping them in frame
  • OrbitalTransposer + POV: third-person player camera
  • DoNothing + DoNothing: fully static camera, controlled by keyframes
• Dolly Track (CinemachinePathBase + CinemachineTrackedDolly) – camera moves along a spline. Designer sets the path in the scene, animator controls position on the path via Timeline.
• Camera Blend in CinemachineBrain: transition between virtual cameras can be Cut, Ease In/Out, Linear, or via custom AnimationCurve. For dialogue scenes, the standard is Cut between lines, Ease for emotional transitions.

Problems and Solutions

Jitter when following a character – a common problem when physics update frequency (FixedUpdate) doesn't match rendering. Solution: CinemachineVirtualCamera > Body > Binding Mode: World Space + enable Stabilize Roll. If insufficient, a custom CinemachineExtension with additional position smoothing. Tested on projects with 30-60 FPS.

Lighting mismatch between gameplay and cutscene – occurs when switching between Unity scenes or using different Lighting Settings. In URP/HDRP, solved via Volume Profile Override on CinemachineVirtualCamera or via Timeline ControlTrack to activate the required Volume.

Lip sync – for dialogue scenes with voiceover, we use Salsa LipSync (Unity) or native Audio2Face (Unreal + MetaHuman). Basic level is viseme-driven animation via AnimationTrack with keyframes per line.

How Does Sequencer in Unreal Engine Simplify the Workflow?

Unreal's Sequencer is a functional analog of Timeline, but with several differences. For cinematic-level cutscenes, Sequencer is more convenient:

• Movie Render Queue instead of Play Mode for final render – provides path tracing, motion blur with subsampling, and consistent frame-by-frame results
• Level Sequence Actor allows nesting Subsequences – convenient for large projects where different parts of a cutscene are worked on in parallel
• Control Rig integration: direct FK/IK rig control in Sequencer without switching to Animation Blueprint

For MetaHuman characters, Sequencer is the main tool: facial animations via Face AR or Performance Capture are written directly into the Sequencer track.

Pre-Rendered Video: When and Why

Pre-rendered cutscenes are justified for intros/outros where quality matters more than interactivity. We render via Unity Recorder or Movie Render Queue (Unreal), final editing and color correction in DaVinci Resolve.

Engine integration: .mp4/.webm via VideoPlayer (Unity) or Media Framework (Unreal). Important for mobile platforms – video may not be hardware-decoded on all target devices; we check codec support in advance (H.264 – safe choice, H.265 – better quality but not all Android support it).

Cutscene Production Process

For each project, we go through these stages:

Timelines are approximate and depend on scene complexity (number of characters, length, platform). Pricing is calculated individually – we'll evaluate your project free of charge upon request.

Procedural Generation: Wave Function Collapse for Assets and Animation

For projects with large amounts of content (roguelike, open world), manual creation of every level is impractical. Wave Function Collapse (WFC) is a tiled generation algorithm based on the principle of entropy (the name is metaphorical, the algorithm is deterministic). The gist: each grid cell can be one of N tiles; the algorithm iteratively "collapses" cells by selecting a tile based on compatibility rules with neighbors.

Practical application in Unity: the mxgmn/WaveFunctionCollapse library or a custom implementation for a specific game. Compatibility rules are set either manually (JSON describing which tiles can neighbor) or learned from example levels.

BSP (Binary Space Partitioning) – a classic algorithm for dungeon levels. Simpler to implement but less flexible in results. For roguelikes, it's a good choice.

For cinematics, procedural generation is also applied in another context: procedural camera animation (handheld camera shake, breathing idle) via Cinemachine Noise or custom Perlin noise-based controllers – adds cinematic liveliness without manual keyframing every movement.

Why Entrust Cinematic Creation to Us?

With 10+ years in game development, we've implemented cinematics for over 50 projects – from mobile platforms to PC and consoles. Certified Unity (Unity Certified Developer) and Unreal Engine (Unreal Authorized Training Partner) specialists. We guarantee stable cutscene performance on all target devices.

Contact us for an evaluation of your script. Order turnkey cinematic development – from storyboarding to final build.