Unity Data to After Effects

In Unity:

Create the Import Script:

In After Effects:

using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.Playables;

[System.Serializable] public class StateSnapshot
{
public int frame;
public double time;
public List<VariablePair> states = new();
}

[System.Serializable] public class VariablePair
{
public string key;
public float value;
}

[System.Serializable] public class UniversalDataLog
{
public List<StateSnapshot> events = new();
}

public class DataRecorder : MonoBehaviour
{
[RuntimeInitializeOnLoadMethod( RuntimeInitializeLoadType.SubsystemRegistration )] private static void Init() => Instance = null;

public static DataRecorder Instance { get; private set; }

[SerializeField] private PlayableDirector director;
[SerializeField] private float frameRate = 30f;

private UniversalDataLog dataLog = new();
private Dictionary<string, float> currentStates = new();

private void Awake()
{
if ( Instance == null ) Instance = this;
else Destroy( gameObject );
}

/// <summary>
/// Sets a variable to an exact, specific value.
/// </summary>
public void RecordState( string variableName, float absoluteValue )
{
currentStates[ variableName ] = absoluteValue;
TakeSnapshot();
}

/// <summary>
/// Modifies a variable by an offset amount (positive or negative).
/// </summary>
public void ModifyState( string variableName, float amount )
{
if ( !currentStates.ContainsKey( variableName ) )
{
currentStates[ variableName ] = 0f;
}

currentStates[ variableName ] += amount;
TakeSnapshot();
}

/// <summary>
/// Internal helper to handle the frame math and save the snapshot data.
/// </summary>
private void TakeSnapshot()
{
double t = director != null ? director.time : Time.time;
int frame = Mathf.FloorToInt( (float) ( t * frameRate ) );

StateSnapshot snapshot = new StateSnapshot
{
frame = frame,
time = t
};

foreach ( var kvp in currentStates )
{
snapshot.states.Add( new VariablePair { key = kvp.Key, value = kvp.Value } );
}

dataLog.events.Add( snapshot );
}

public void Save()
{
if ( dataLog.events.Count == 0 ) return;

string json = JsonUtility.ToJson( dataLog, true );
string path = Path.Combine( Application.dataPath, “UniversalHUDData.json” );

File.WriteAllText( path, json );
Debug.Log( $”Universal data successfully saved to: {path}” );
}

private void OnDisable() => Save();
}

(function() {
// 1. Find the active composition
var comp = app.project.activeItem;
if (!comp || !(comp instanceof CompItem)) {
alert(“Please select an active composition.”);
return;
}

// 2. Find the target layer
var layer = comp.layer(“HUD_Controller”);
if (!layer) {
alert(“Could not find a layer named ‘HUD_Controller’.”);
return;
}

// 3. Prompt user to select the universal JSON file
var jsonFile = File.openDialog(“Select the UniversalHUDData.json file”, “*.json”);
if (!jsonFile) return;

if (jsonFile.open(“r”)) {
var content = jsonFile.read();
jsonFile.close();

// Parse the JSON data safely using eval (standard for ExtendScript)
var data;
try {
data = eval(“(” + content + “)”);
} catch (e) {
alert(“Failed to parse JSON file.”);
return;
}

if (!data || !data.events) {
alert(“Invalid data structure.”);
return;
}

// 4. Set the keyframes across matching sliders
app.beginUndoGroup(“Import Universal Unity Data”);

var events = data.events;
var compFrameRate = comp.frameRate;

// Keep track of which sliders we have cleared so we don’t wipe them repeatedly
var clearedSliders = {};

for (var i = 0; i < events.length; i++) {
var ev = events[i];
// Convert Unity frame to AE time based on AE composition framerate
var aeTime = ev.frame / compFrameRate;

// Loop through all states recorded in this specific frame snapshot
for (var j = 0; j < ev.states.length; j++) {
var stateName = ev.states[j].key;
var stateValue = ev.states[j].value;

// Try to find a matching slider on the HUD layer
var targetSlider = null;
try {
targetSlider = layer.effect(stateName)(“Slider”);
} catch(err) {
// Slider doesn’t exist on the layer, skip it safely
continue;
}

if (targetSlider) {
// Wipe pre-existing keys for this slider just once upon first encounter
if (!clearedSliders[stateName]) {
while (targetSlider.numKeys > 0) {
targetSlider.removeKey(1);
}
// Add an initial 0 keyframe if the first event starts later in the timeline
if (aeTime > 0) {
targetSlider.setValueAtTime(0, 0);
}
clearedSliders[stateName] = true;
}

// Apply the keyframe value
targetSlider.setValueAtTime(aeTime, stateValue);

// Set keyframe interpolation to Hold so counts jump instantly
var keyIndex = targetSlider.nearestKeyIndex(aeTime);
targetSlider.setInterpolationTypeAtKey(keyIndex, KeyframeInterpolationType.HOLD);
}
}
}

app.endUndoGroup();
alert(“Successfully imported universal data across matching sliders!”);
}
})();