Game Cinematic and Video Production Services

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.