Unity Recorder Scripting

2025-07-18 09:27 UTC o4-mini-high Open in ChatGPT ↗

Summary

Yes—Unity provides a fully scriptable API for the Recorder package (in the UnityEditor.Recorder namespace) that lets you programmatically set every option, including the output filename. You create or fetch a RecorderControllerSettings instance, add one or more RecorderSettings (e.g., MovieRecorderSettings) to it, assign your desired base filename via the OutputFile property (with support for wildcards), and then drive recording with PrepareRecording/StartRecording/StopRecording calls. You can also modify the global Recorder settings at runtime and push updates to the Recorder window UI if it’s open. citeturn9search2turn6search0

Creating and configuring a scripted recording session

1. Instantiate RecorderControllerSettings

Create a fresh settings asset in code:

var controllerSettings = ScriptableObject.CreateInstance<RecorderControllerSettings>();

citeturn9search2

If you instead want to tweak the same settings the Recorder window is using, fetch the global asset:

var globalSettings = RecorderControllerSettings.GetGlobalSettings();

citeturn8search1

2. Configure frame rate and recording mode

Set up your desired frame rate and whether recording is manual or bound to a time/frame interval:

controllerSettings.FrameRate = 30f;
controllerSettings.SetRecordModeToManual();

citeturn9search2

Defining RecorderSettings and setting the filename

1. Create a MovieRecorderSettings instance

For video output, instantiate the corresponding settings:

var movieSettings = ScriptableObject.CreateInstance<MovieRecorderSettings>();

citeturn7view0

2. Assign the OutputFile property

Give your recording a base filename (Unity appends “.mp4” or the appropriate extension automatically):

movieSettings.OutputFile = "custom_video_name";

citeturn6search0turn7view0

You can include wildcards—such as <Date>, `

what if i want to edit existing movie settinsg?

Summary

Unity’s Recorder API lets you programmatically modify any existing MovieRecorderSettings by fetching the global RecorderControllerSettings asset, locating the specific MovieRecorderSettings instance in its RecorderSettings collection, updating its public properties (like filename, format, bitrate, alpha capture, input settings), then persisting changes with RecorderControllerSettings.Save() and, if needed, refreshing the Recorder window UI with RecorderWindow.SetRecorderControllerSettings() citeturn1search0turn1search1.

1. Retrieve the existing Recorder settings

Load the global settings asset
Use RecorderControllerSettings.GetGlobalSettings() to access the current, saved Recorder settings citeturn1search0.
Inspect its RecorderSettings list
The returned instance exposes RecorderSettings, an IEnumerable<RecorderSettings> containing all configured recorders citeturn1search0turn1search1.

2. Locate the Movie recorder to edit

Filter by type
Employ LINQ’s OfType<MovieRecorderSettings>() to pick out your movie recorder from the collection citeturn1search1.

var movieSettings = settings.RecorderSettings
                          .OfType<MovieRecorderSettings>()
                          .FirstOrDefault();
``` citeturn1search1

3. Modify the desired properties

Once you have the movieSettings instance, you can tweak any of its public fields:

Change the output filename
```
movieSettings.OutputFile = "session_<Date>_<Take>";
```
Supports wildcards like <Date>, `

what if I want to store in the Project directory, inside a Recordings directory

Summary

Unity Recorder’s OutputFile property accepts both relative and absolute paths, letting you drop recordings into any folder under your project root—such as a Recordings directory—simply by embedding the subfolder in the path string. citeturn1search2turn1search5 You can also drive the more granular FileNameGenerator API to specify the root (e.g. project folder) and leaf (subfolder + filename) directly. citeturn9search0turn9search1

1. Using `OutputFile`

1.1. Basic relative path

The easiest approach is to assign a path relative to your project root directly to the recorder’s OutputFile string. citeturn1search2

movieSettings.OutputFile = "Recordings/myVideo_<Date>_<Take>";

Here, Unity resolves "Recordings/..." under your project folder and appends the proper extension. citeturn1search0

1.2. Absolute path alternative

If you need an absolute path, combine Application.dataPath (which points to <project>/Assets) with your desired folder using Path.Combine. citeturn11search0turn12search0

using System.IO;
...
string absolutePath = Path.Combine(Application.dataPath, "../Recordings/myVideo_<Date>_<Take>");
movieSettings.OutputFile = absolutePath;

1.3. Forum note

In community discussions, users report that only relative paths (and root‐anchored absolute paths like C:\…) reliably work out of the box—making a relative "Recordings/…" path the most bulletproof choice. citeturn1search3

2. Using `FileNameGenerator`

Under the hood, OutputFile drives a FileNameGenerator. You can configure this generator directly for finer control:

// 1. Create your Movie recorder settings
var movieSettings = ScriptableObject.CreateInstance<MovieRecorderSettings>();

// 2. Access its FileNameGenerator
var fg = movieSettings.FileNameGenerator;                           // citeturn9search0

// 3. Set the root to the project folder
fg.Root = OutputPath.Root.Project;                                  // citeturn1search7turn9search0

// 4. Define the leaf as a subfolder + filename (wildcards supported)
fg.Leaf = "Recordings/myVideo_<Date>_<Take>";                       // citeturn9search1

// 5. Enable and add to controller settings as usual
movieSettings.Enabled = true;
controllerSettings.AddRecorderSettings(movieSettings);

This ensures your recordings land in <ProjectRoot>/Recordings/ with dynamic naming.

3. Complete Script Example

Below is a self-contained snippet showing how to load existing global settings, adjust the movie recorder to drop outputs into a Recordings folder, and save the changes:

using UnityEditor;
using UnityEditor.Recorder;
using UnityEditor.Recorder.Input;
using System.IO;
using System.Linq;

// 1. Fetch or create controller settings
var settings = RecorderControllerSettings.GetGlobalSettings();

// 2. Locate an existing Movie recorder (or create a new one)
var movieSettings = settings.RecorderSettings
                            .OfType<MovieRecorderSettings>()
                            .FirstOrDefault()
                        ?? ScriptableObject.CreateInstance<MovieRecorderSettings>();

// 3. Configure relative output path directly
movieSettings.OutputFile = "Recordings/Session_<Date>_<Take>";

// ── OR set via FileNameGenerator ──
// var fg = movieSettings.FileNameGenerator;
// fg.Root = OutputPath.Root.Project;
// fg.Leaf = "Recordings/Session_<Date>_<Take>";

// 4. Enable and ensure it's registered
movieSettings.Enabled = true;
if (!settings.RecorderSettings.Contains(movieSettings))
    settings.AddRecorderSettings(movieSettings);

// 5. Persist settings and, if open, refresh the Recorder window
settings.Save();
var window = EditorWindow.GetWindow<RecorderWindow>();
window.SetRecorderControllerSettings(settings);

With either method, Unity will automatically create the Recordings folder under your project directory when you start your next recording session.