Eyes Animator

About Eyes Animator – Unity Editor Tool & Plugin

Eyes Animator Unity Asset Overview

In character animation, nothing breaks player immersion faster than dead, static eyes. While body language can be captured perfectly with motion capture, realistic eye behavior—such as tracking targets, micro-saccades, and natural blinking—is incredibly difficult and tedious to animate by hand. The Eyes Animator asset solves this problem by providing a highly optimized, procedural animation system designed to handle eye movement dynamically at runtime.

Honestly, from an architectural standpoint, this tool is highly efficient. Instead of forcing you to rely on heavy skeletal rigs or baking hundreds of repetitive animations, it intercepts the eye transforms or blendshape values and calculates natural gazing behaviors procedurally. The core architecture relies on a central component, `EyesAnimator`, which acts as the controller. It samples target positions, calculates angular limits to prevent unnatural eye-strain rotations, and applies a combination of spring physics and noise algorithms to simulate organic movement. It operates completely independently of your animation state machine, meaning it integrates cleanly alongside existing setups like Animator, Playables API, or Inversed Kinematics (IK) solutions.

Core Technical Features & Highlights

The asset is built to be lightweight, production-ready, and highly adaptable. Here are the core features that make it stand out from basic script-based look-at solutions:

• Saccadic Movement Simulation: Human eyes don't move smoothly when scanning an environment; they perform rapid, involuntary jumps called saccades. The component features a built-in noise generator that simulates these micro-movements, adding an instant layer of realism.
• Flexible Input Systems: It supports bone-based eye setups, blendshape-based setups (common in stylized or anime characters), and UV-coordinate shifting for low-poly or retro models.
• Dynamic Clamping & Limits: You can define custom horizontal and vertical rotation thresholds. This prevents the eyes from clipping into the character's eyelids or rotating completely backward into the skull.
• Procedural Blinking: Features an integrated, highly customizable automatic blinking system. It handles blink frequency, duration, and random double-blinks using either bones or blendshapes.
• Render Pipeline Agnostic: Because the system works directly with Transform manipulation and material property blocks, it is 100% compatible with the Built-In Render Pipeline, Universal Render Pipeline (URP), and High Definition Render Pipeline (HDRP).

Ideal Use Cases & Game Genres

While any game with 3D characters can benefit from this tool, there are several genres where its impact is particularly significant:

Indie RPGs & Dialogue-Heavy Adventure Games

When your game features close-up camera angles during conversations, static eyes make characters look like mannequins. This tool allows NPCs to look directly at the player or dynamically shift their gaze to points of interest in the environment during conversation lines, heavily boosting narrative engagement.

Third-Person Action & Open World Games

In third-person setups, having the protagonist's eyes track interactive objects, enemies, or look toward the direction of travel makes the character feel connected to the world. It adds a subtle but noticeable polish layer that players subconsciously appreciate.

Virtual Reality (VR) & First-Person Titles

In VR, social presence is crucial. If you are developing multiplayer VR spaces or cooperative games, routing players' head-tracking data to drive eye gaze towards other avatars creates a massive leap in social realism. The performance footprint is low enough to run on standalone mobile VR hardware without dropping frames.

Quick-Start Unity Setup & Integration Guide

Setting up the component on a humanoid character is straightforward. Here is how to configure it manually and control it dynamically via C# script:

Step 1: Component Attachment

Select your character's root GameObject, click Add Component, and search for `EyesAnimator`. In the inspector, assign the left eye transform to the Left Eye field and the right eye transform to the Right Eye field. If your model uses blendshapes for blinking, configure those in the blinking dropdown section.

Step 2: Define Gaze Clamping

Adjust the horizontal and vertical limit sliders in the Inspector. Green visual gizmos will appear in the Scene View, allowing you to visually calibrate the safe rotation zones for your character's specific mesh structure.

Step 3: Controlling Gaze Programmatically

To dynamically update targets (for example, when an NPC notices an object of interest), you can interface with the animator using a simple controller script. Here is a clean, practical implementation:

using UnityEngine;
using FIMSpace.FEyes; // Ensure you import the correct namespace for the asset

public class CharacterGazeController : MonoBehaviour
{
    [Header("Dependencies")]
    [SerializeField] private EyesAnimator _eyesAnimator;
    [SerializeField] private Transform _defaultTarget;

    private void Start()
    {
        if (_eyesAnimator == null)
        {
            _eyesAnimator = GetComponent<EyesAnimator>();
        }

        // Set up default gaze direction if a target is available
        if (_eyesAnimator != null && _defaultTarget != null)
        {
            _eyesAnimator.Target = _defaultTarget;
            _eyesAnimator.Amount = 1.0f; // Enable full tracking influence
        }
    }

    /// <summary>
    /// Call this method to dynamically shift the character's gaze to an enemy or point of interest.
    /// </summary>
    public void LookAtTarget(Transform newTarget, float blendSpeed = 2f)
    {
        if (_eyesAnimator == null) return;

        // Smoothly blend eye tracking influence back up or down if needed
        _eyesAnimator.Target = newTarget;
        _eyesAnimator.BlendGoBack = blendSpeed;
    }

    /// <summary>
    /// Resets the character's gaze back to looking straight ahead.
    /// </summary>
    public void ClearGazeTarget()
    {
        if (_eyesAnimator == null) return;
        _eyesAnimator.Target = null;
    }

    /// <summary>
    /// Triggers an immediate procedural blink override.
    /// </summary>
    public void ForceBlink()
    {
        if (_eyesAnimator != null)
        {
            _eyesAnimator.User_TriggerBlink();
        }
    }
}

Pros & Cons Assessment

Here is an honest evaluation of the asset's performance and design after practical implementation:

• PRO: Extremely Lightweight. The mathematics behind the spring-dampened rotations and noise calculations are highly optimized. Running 50 active characters with eye tracking simultaneously has negligible CPU impact.
• PRO: Modular Design. It does not force you into a specific animation pipeline. It works beautifully alongside standard FBX animations, blendshapes, or procedurally modified bone structures.
• PRO: Outstanding Visual Customization. The saccade frequency, micro-movement intensity, and individual eye offset values allow you to quickly define distinct personality profiles for your characters (e.g., confident, shifty, or hyperactive).
• CON: Initial Configuration Curve. If your model has non-standard bone orientations (e.g., local Z-axis pointing up instead of forward), you will need to spend a few minutes configuring the axis alignment settings within the component inspector to prevent the eyes from rolling back.
• CON: Multi-eyed / Creature Limits. Out of the box, it is optimized for dual-eye configurations (humanoids). If you are building creatures with three, four, or eight eyes, you will need to stack multiple instances of the script or write custom wrappers to synchronize them.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets