One of the most important elements in modern video games, especially large open-world environments, is creating believable character animation. With games ever more realistic and immersive, moving, interacting, and emoting characters in a natural and varied way presents significant technical and artistic challenges to developers.
The Scale of Open Worlds
Open-world games offer players vast spaces to explore, with more freedom than linear, level-based games. This means there can be huge varieties of terrain, weather effects, day/night cycles, and potential character actions. Developers often turn to character animation services to animate characters capable of traversing deserts, snowy mountains, dense cities, and more—often within the same game.
The sheer scale of open worlds makes animation difficult. Artists can’t manually control every character’s movement through these massive environments. Instead, animation systems must allow AI-driven characters to move realistically through space based on factors like:
- Terrain type.
- Navigation goals.
- Social interactions.
- Dynamic obstacles.
- And more.
Open worlds also have a greater number of character models. Rather than animating a few recurring hero and enemy archetypes, developers must animate crowds of NPCs with unique roles, clothing, gear, and behaviors.
This complexity stretched the limits of animation pipelines built for linear games with fixed contexts. New tools and workflows are necessary to bring these worlds to life.
Contextual, Adaptive Animations
In linear games, animators can tightly control the context in which a character’s action takes place. In open worlds, however, places and contexts constantly change through players, AI, physics, and other phenomena of the game.
So many studios build very robust procedural animation systems that offer a lot more adaptive animations. These systems blend animation clips dynamically as a function of gameplay context using biomechanical models.
For instance, as walking uphill and then preparing for strong winds, the character could change each action in a continuous animation without milestone animation triggers. Based on the character’s balance, momentum, positioning, etc., movements adapt.
However, machine learning is also applied to achieve animation systems that mimic human fluidity. We show that neural networks can be trained on hours of motion capture data to learn naturalistic models for blending animations from high-level input parameters.
Yet, building robust models for every character in an open world is still very hard, and there are often compromises to make. It is critical that these systems [of getting these systems right] are right for the suspension of disbelief.
Consistent Quality at Scale
Maintaining quality animation at scale is hugely challenging. Some open-world games have over 60-100 hours of character animation. Unlike film and TV, which take years to develop 1 to 2 hours of footage, games condense vast amounts of animation into short production cycles.
It is just not feasible to review, revise, and polish this animation by hand. Therefore, developers must rely on procedural techniques, often generating and refining animations using underlying models, physics, metadata, and automation.
However, if the underlying models are poor, this can result in mechanical movements. Tuning procedural animation systems requires extensive iteration and motion capture data to capture nuanced details of human and animal movement in diverse situations.
These models must also account for variations in characters’ age, height, weight, injuries/disabilities, etc. Custom-tuning each model is time-intensive and is often reserved for main characters, while secondary models reuse base configurations.
There are also massive data storage and processing challenges. High-fidelity animation data can quickly bloat budgets and runtime performance if not carefully optimized. Next-gen hardware will expand possibilities here.
Emotional Expressivity
Beyond physical locomotion, developers aim to infuse more personality and emotional expressivity into open-world characters.
However, hand-animating the full range of human emotion across countless unique character models is monumentally challenging. Most open-world NPCs still exhibit fairly simple and repetitive reactions.
Some studios use performance capture with professional actors to author highly complex facial animation rigs. These are later mapped onto different NPCs to transmit intricate emotional expressions via detailed muscle activations.
But these rigs require extensive optimization to run efficiently in-game. Simpler rigs with morph targets and blend shapes still dominate for quality/performance balance.
Advanced procedural techniques show promise for dynamically increasing emotional range. For example, neural networks are being trained on emotive facial capture data to generate new expressions that respond intelligently to changing gameplay situations.
Speech animation also remains a notorious challenge. Due to the manual effort required, few games achieve truly convincing lip sync across diverse dialogue. Procedural methods utilizing audio waveforms and vise mes (mouth shapes that correspond to phonemes) can automate decent 1:1 lip sync, but they often lack nuance.
As with body animation, machine learning may eventually enable more automated emotional refinement. However, huge amounts of data are necessary, and missteps here can quickly lead to uncanny valley territory if the underlying models aren’t extensively validated.
Animation Review and Revision
The game animation pipelines have long review and revision cycles that exist in no other medium.
Initially, early in the development, animators blocked out primary gameplay sequences by using simple placeholder animations. They get iteratively refined with other programming, design and art teams in coordination with the subsequent review stages.
New features are added, with late-cycle revisions common and animation tweaks necessary to polish up integrations. Layered variant versions of many animations exist, such as multiple carrying, idling, or conversation animations, to increase the variety.
These cycles are hugely challenging in managing the sheer volume of character animation data. Version control systems for sophisticated code are sophisticated and track the full evolution of assets from blocking to final polish.
Some studios even utilize layering animation systems. This enables developers to compose and tweak complex animations non-destructively by blending multiple movement layers. Base animations are not overwritten; thus, the iteration speed is improved.
Automation is being used more and more in review and QA processes to surface visual artifacts that are difficult to see manually across gigantic datasets. Taking this a step further, AI algorithms can analyze animations, break them down into a series of frames or key shots, flag them yourself, and provide potential problem clips for human review.
Animation revision continues long after launch as well. Modern games are modern for a reason, and that’s because they usually come with the latest content and mechanics, and they need animation tweaks to keep things going smoothly.
Optimizing Gameplay Responsiveness
Slow, mushy controls can ruin a game, especially in open-world action titles. Animation is deeply tied to control responsiveness.
Gameplay programmers must architect flexible animation state machines that enable crisp transitions between movements. For example, characters should transition seamlessly from running to dodging to attacking based on player input.
Responsiveness challenges grow with more complex move sets. Character controllers must juggle many animation layers: locomotion, actions, facial animation, cloth physics, hit reactions, and more. These all intersect in intricate ways.
Tuning to feel right requires extensive prototyping and playtesting. One common technique is creating fast-twitch “flinch” animations to react to attacks. These provide visual feedback faster than complex hit reaction physics.
Network latency in online open-world games also impacts controls. If packets are delayed, character actions may lag behind button presses. Programmers employ latency mitigation and prediction techniques, but some mushiness is often unavoidable.
Certain genres, like fighting games, require extremely precise frame counting and move timing. Other open-world games simplify moves to trade off fidelity for responsiveness. Each game requires a different animation approaches.
Animation Compression
Vast open game worlds bloat storage and memory requirements. Developers use various compression techniques to optimize animation data size.
Keyframe reduction eliminates non-essential in-betweens. Curve simplification approximates splines using fewer points. Texture compression shrinks animation map sizes.
Data formats like MPEG4 enable compression ratios over 10:1 with minimal quality loss. Some formats also support procedural synthesis, generating high-frequency secondary animations from low-frequency basis curves.
Runtime decompression must be fast enough to avoid gameplay hitching. Developers may choose less efficient but faster codecs over smaller/slower ones. Quality, performance, and efficiency involve delicate balancing.
New hardware decompression abilities in next-gen consoles and GPUs will expand possibilities for more advanced compressed animation. This may enable richer procedural animation via compute shaders without runtime penalties.
Animation Streaming
Realistically, such worlds cannot fit all their animation data into memory at once. As a result, assets are loaded/unloaded dynamically according to gameplay context, developers use various streaming schemes.
However, complex cutscene interactions are often loaded from disk on demand and are low-frequency animations. A mix of active memory and dynamic streams from storage pools is used more frequently.
Predictive schemes preload animations that will be needed later to hide latencies. Blending layers for upcoming terrain types or dialogue animations from upcoming quests gives.
It minimizes pop-ins or delays during the playback. Yet it relies on strategic pooling tuned to the scene content and gameplay. The generic solutions don’t fit well with bespoke open-world design.
High-speed storage and data decompression are enabled by next-gen hardware to boost streaming capacities. As throughput goes faster, performance is less of a concern when preloading, so animation variety and fidelity can be made more aggressive.
Conclusion
Combined with the interactive nature of modern games, animation complexity is now requiring an unprecedented level of complexity. Stretch pipeline open-world games are built for more constrained projects.
Fortunately, new procedural techniques, smarter streaming, and more computing power have opened up new possibilities. However, much design and engineering ingenuity is still needed to overcome limitations.
The best animation systems should disappear, letting players roam around in rich and beautiful worlds. But when the technology fails, the illusions of life fail.
