twotalesanimation
1163bd6455
Deploy / deploy (push) Successful in 5m57s
The preview manifest now carries the show name, taken from the project's
name rather than its code — a slate is read by a human, so "Ungovernable"
beats "UNG_S1".
Both the worker's headless build and the panel's own preview set it, so a
farm-generated preview and an artist-built one still match. The panel
writes it whenever it touches an overlay, not only when building a
preview, so existing comps pick it up on the next Add Overlay.
The slate's other properties are title case ("Date", "Scene") while the
overlay's are upper ("DATE", "SHOT NAME"), so both spellings of SHOW are
attempted; a template exposing neither reports its actual property names
as a build warning rather than failing silently, matching how the VFX
Scope and Submission Note fields already behave.
Panel 2.2.0, worker 1.2.0.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
574 lines
20 KiB
React
574 lines
20 KiB
React
/*
|
|
vfxr_build_preview.jsx — VFXReview render pipeline, preview build stage.
|
|
|
|
Runs headlessly: AfterFX.com -noui -r <wrapper>.jsx
|
|
where the wrapper sets var VFXR_CONTEXT_PATH = "...json"; then
|
|
$.evalFile()s this script.
|
|
|
|
It does NOT render. It opens the studio slate/overlay template, rebuilds
|
|
the shot around the *rendered* EXR sequence (OCIO → show LUT → overlay),
|
|
duplicates the export template into a preview comp with the slate filled
|
|
in, queues the MOV and MP4 output modules, and saves a throwaway AEP.
|
|
The worker then runs `aerender -project <that aep>` with no -comp, which
|
|
renders the whole queue in one launch.
|
|
|
|
Build logic mirrors the VFXReviewConnector panel functions
|
|
buildShotFromCode / updateOverlayForComp / buildPreviewForShot so the
|
|
farm and the artist produce identical slates and burn-ins.
|
|
|
|
Everything is reported back through the result JSON — never a dialog.
|
|
*/
|
|
|
|
(function vfxrBuildPreview() {
|
|
var ctx = null;
|
|
var result = {
|
|
ok: false,
|
|
error: null,
|
|
warnings: [],
|
|
tempAep: null,
|
|
previewComp: null,
|
|
queued: [],
|
|
frameCount: null,
|
|
width: null,
|
|
height: null
|
|
};
|
|
var resultPath = null;
|
|
|
|
// ── tiny helpers (ES3 / ExtendScript safe) ───────────────────────────────
|
|
|
|
function readTextFile(path) {
|
|
var f = new File(path);
|
|
var text;
|
|
if (!f.exists) {
|
|
return null;
|
|
}
|
|
f.encoding = "UTF-8";
|
|
if (!f.open("r")) {
|
|
return null;
|
|
}
|
|
text = f.read();
|
|
f.close();
|
|
return text;
|
|
}
|
|
|
|
function writeTextFile(path, text) {
|
|
var f = new File(path);
|
|
try {
|
|
f.encoding = "UTF-8";
|
|
if (!f.open("w")) {
|
|
return false;
|
|
}
|
|
f.write(text);
|
|
f.close();
|
|
return true;
|
|
} catch (writeError) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function jsonEscape(value) {
|
|
var text = String(value);
|
|
var out = "";
|
|
var i;
|
|
var ch;
|
|
var code;
|
|
|
|
for (i = 0; i < text.length; i += 1) {
|
|
ch = text.charAt(i);
|
|
code = text.charCodeAt(i);
|
|
if (ch === "\"") {
|
|
out += "\\\"";
|
|
} else if (ch === "\\") {
|
|
out += "\\\\";
|
|
} else if (ch === "\n") {
|
|
out += "\\n";
|
|
} else if (ch === "\r") {
|
|
out += "\\r";
|
|
} else if (ch === "\t") {
|
|
out += "\\t";
|
|
} else if (code < 32) {
|
|
out += "\\u" + ("000" + code.toString(16)).slice(-4);
|
|
} else {
|
|
out += ch;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function toJSON(value) {
|
|
var parts = [];
|
|
var i;
|
|
var key;
|
|
|
|
if (value === null || value === undefined) {
|
|
return "null";
|
|
}
|
|
if (typeof value === "number") {
|
|
return isFinite(value) ? String(value) : "null";
|
|
}
|
|
if (typeof value === "boolean") {
|
|
return String(value);
|
|
}
|
|
if (typeof value === "string") {
|
|
return "\"" + jsonEscape(value) + "\"";
|
|
}
|
|
if (value instanceof Array) {
|
|
for (i = 0; i < value.length; i += 1) {
|
|
parts.push(toJSON(value[i]));
|
|
}
|
|
return "[" + parts.join(",") + "]";
|
|
}
|
|
for (key in value) {
|
|
if (value.hasOwnProperty(key) && value[key] !== undefined) {
|
|
parts.push("\"" + jsonEscape(key) + "\":" + toJSON(value[key]));
|
|
}
|
|
}
|
|
return "{" + parts.join(",") + "}";
|
|
}
|
|
|
|
function warn(message) {
|
|
result.warnings.push(String(message));
|
|
}
|
|
|
|
function findComp(name) {
|
|
var i;
|
|
var item;
|
|
|
|
for (i = 1; i <= app.project.numItems; i += 1) {
|
|
item = app.project.item(i);
|
|
if (item instanceof CompItem && item.name === name) {
|
|
return item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function findFolder(name) {
|
|
var i;
|
|
var item;
|
|
|
|
for (i = 1; i <= app.project.numItems; i += 1) {
|
|
item = app.project.item(i);
|
|
if (item instanceof FolderItem && item.name === name) {
|
|
return item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Mirrors the panel's addOCIOToLayer: effect added but disabled, so the
|
|
// artist/farm chain matches exactly.
|
|
function addOCIOToLayer(layer) {
|
|
var ocio;
|
|
var outputProp;
|
|
|
|
try {
|
|
ocio = layer.property("Effects").addProperty("OCIO Color Space Transform");
|
|
ocio.enabled = false;
|
|
} catch (ocioError) {
|
|
warn("OCIO effect unavailable: " + ocioError.toString());
|
|
return;
|
|
}
|
|
|
|
try {
|
|
outputProp = ocio.property("Output Color Space");
|
|
} catch (byNameError) {
|
|
outputProp = null;
|
|
}
|
|
if (!outputProp) {
|
|
try {
|
|
outputProp = ocio.property(2);
|
|
} catch (byIndexError) {
|
|
outputProp = null;
|
|
}
|
|
}
|
|
if (outputProp) {
|
|
try {
|
|
outputProp.setValue(93);
|
|
} catch (setError) {
|
|
warn("Could not set OCIO output colour space: " + setError.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
function setEssentialProperty(layer, propName, value) {
|
|
if (value === null || value === undefined || value === "") {
|
|
return false;
|
|
}
|
|
try {
|
|
layer.property("Essential Properties").property(propName).setValue(value);
|
|
return true;
|
|
} catch (setError) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function setEssentialPropertyByIndex(layer, index, value) {
|
|
try {
|
|
layer.property("Essential Properties").property(index).setValue(value);
|
|
return true;
|
|
} catch (setError) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function listEssentialPropertyNames(layer) {
|
|
var names = [];
|
|
var group;
|
|
var i;
|
|
|
|
try {
|
|
group = layer.property("Essential Properties");
|
|
for (i = 1; i <= group.numProperties; i += 1) {
|
|
try {
|
|
names.push(i + ":" + group.property(i).name);
|
|
} catch (oneError) {
|
|
}
|
|
}
|
|
} catch (groupError) {
|
|
}
|
|
return names;
|
|
}
|
|
|
|
// Slate identity fields (version name, shot name). Current templates expose
|
|
// these under a stable name, older ones only positionally, and the two do
|
|
// not always line up — so write both. Setting the same property twice is
|
|
// harmless; the panel uses the same name-with-index-fallback pattern.
|
|
function setSlateIdentity(layer, propName, index, value, label) {
|
|
var byName;
|
|
var byIndex;
|
|
|
|
if (value === null || value === undefined || value === "") {
|
|
return; // leave the template's own default
|
|
}
|
|
byName = setEssentialProperty(layer, propName, value);
|
|
byIndex = setEssentialPropertyByIndex(layer, index, value);
|
|
if (!byName && !byIndex) {
|
|
warn(label + ": neither Essential Property \"" + propName + "\" nor index " +
|
|
index + " could be set. Available: " +
|
|
listEssentialPropertyNames(layer).join(", "));
|
|
}
|
|
}
|
|
|
|
// Per-submission fields (VFX Scope / Submission Note). The property names
|
|
// come from config; if one does not exist, report the template's actual
|
|
// property names so it can be corrected without another build.
|
|
function setSlateField(layer, propName, value, label) {
|
|
if (!propName) {
|
|
return;
|
|
}
|
|
if (value === null || value === undefined || value === "") {
|
|
return; // nothing to write; leave the template's own default
|
|
}
|
|
if (!setEssentialProperty(layer, propName, value)) {
|
|
warn(label + ": Essential Property \"" + propName + "\" not found or not settable. " +
|
|
"Available: " + listEssentialPropertyNames(layer).join(", "));
|
|
}
|
|
}
|
|
|
|
// The production name, burned into both the slate and the overlay. The
|
|
// slate's other fields are title case ("Date", "Scene") while the overlay's
|
|
// are upper ("DATE", "SHOT NAME"), so both spellings are attempted rather
|
|
// than assuming which template uses which — and a template that exposes
|
|
// neither reports its actual property names instead of failing silently.
|
|
function setShowField(layer, value, label) {
|
|
var candidates = ["SHOW", "Show"];
|
|
var i;
|
|
|
|
if (value === null || value === undefined || value === "") {
|
|
return;
|
|
}
|
|
for (i = 0; i < candidates.length; i += 1) {
|
|
if (setEssentialProperty(layer, candidates[i], value)) {
|
|
return;
|
|
}
|
|
}
|
|
warn(label + ": no Essential Property named " + candidates.join(" or ") +
|
|
". Available: " + listEssentialPropertyNames(layer).join(", "));
|
|
}
|
|
|
|
function setCompStartFrame(comp, frameNumber) {
|
|
try {
|
|
comp.displayStartFrame = frameNumber;
|
|
return;
|
|
} catch (frameError) {
|
|
}
|
|
try {
|
|
comp.displayStartTime = frameNumber / comp.frameRate;
|
|
} catch (timeError) {
|
|
}
|
|
}
|
|
|
|
function applyOutputModuleTemplate(outputModule, templateName) {
|
|
var templates;
|
|
var i;
|
|
|
|
try {
|
|
templates = outputModule.templates;
|
|
for (i = 0; i < templates.length; i += 1) {
|
|
if (templates[i] === templateName) {
|
|
outputModule.applyTemplate(templateName);
|
|
return true;
|
|
}
|
|
}
|
|
} catch (templateError) {
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function importExrSequence(dirPath) {
|
|
var folder = new Folder(dirPath);
|
|
var files;
|
|
var importOptions;
|
|
var footage;
|
|
|
|
if (!folder.exists) {
|
|
throw new Error("Render output folder not found: " + dirPath);
|
|
}
|
|
|
|
files = folder.getFiles("*.exr");
|
|
if (!files || files.length < 1) {
|
|
throw new Error("No EXR files found in " + dirPath);
|
|
}
|
|
files.sort();
|
|
|
|
importOptions = new ImportOptions(files[0]);
|
|
importOptions.sequence = true;
|
|
footage = app.project.importFile(importOptions);
|
|
try {
|
|
footage.mainSource.conformFrameRate = ctx.fps || 24;
|
|
} catch (conformError) {
|
|
warn("Could not conform frame rate: " + conformError.toString());
|
|
}
|
|
return footage;
|
|
}
|
|
|
|
function queueOutput(comp, templateName, outputPath, label) {
|
|
var item;
|
|
var outputModule;
|
|
|
|
if (!templateName || !outputPath) {
|
|
warn("Skipping " + label + ": no template or output path configured");
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
item = app.project.renderQueue.items.add(comp);
|
|
outputModule = item.outputModule(1);
|
|
if (!applyOutputModuleTemplate(outputModule, templateName)) {
|
|
item.remove();
|
|
throw new Error("Output module template not found: \"" + templateName + "\"");
|
|
}
|
|
outputModule.file = new File(outputPath);
|
|
result.queued.push({ label: label, template: templateName, output: outputPath });
|
|
return true;
|
|
} catch (queueError) {
|
|
try {
|
|
if (item) {
|
|
item.remove();
|
|
}
|
|
} catch (removeError) {
|
|
}
|
|
throw queueError;
|
|
}
|
|
}
|
|
|
|
// ── main ─────────────────────────────────────────────────────────────────
|
|
|
|
try {
|
|
if (typeof VFXR_CONTEXT_PATH === "undefined" || !VFXR_CONTEXT_PATH) {
|
|
throw new Error("VFXR_CONTEXT_PATH was not set by the wrapper script");
|
|
}
|
|
|
|
var contextText = readTextFile(VFXR_CONTEXT_PATH);
|
|
if (!contextText) {
|
|
throw new Error("Could not read job context: " + VFXR_CONTEXT_PATH);
|
|
}
|
|
ctx = eval("(" + contextText + ")");
|
|
resultPath = ctx.resultPath;
|
|
|
|
try {
|
|
app.beginSuppressDialogs();
|
|
} catch (suppressError) {
|
|
}
|
|
|
|
// 1. Open the studio template (slate, overlay, show LUT, export template)
|
|
var templateFile = new File(ctx.templateAep);
|
|
if (!templateFile.exists) {
|
|
throw new Error("Template project not found: " + ctx.templateAep);
|
|
}
|
|
app.open(templateFile);
|
|
|
|
var templateComp = findComp(ctx.templateComp);
|
|
if (!templateComp) {
|
|
throw new Error("Export template comp \"" + ctx.templateComp + "\" not found in template project");
|
|
}
|
|
|
|
// 2. Import the rendered EXR sequence
|
|
var footage = importExrSequence(ctx.outputDirLocal);
|
|
var footageFolder = findFolder("_FOOTAGE_4K");
|
|
if (footageFolder) {
|
|
footage.parentFolder = footageFolder;
|
|
}
|
|
footage.name = ctx.shotCode + "_" + ctx.versionString;
|
|
|
|
var width = footage.width;
|
|
var height = footage.height;
|
|
var duration = footage.duration;
|
|
var fps = ctx.fps || 24;
|
|
|
|
result.width = width;
|
|
result.height = height;
|
|
result.frameCount = Math.round(duration * fps);
|
|
|
|
// 3. Footage precomp (mirrors buildShotFromCode)
|
|
var precompFolder = findFolder("_PRECOMPS");
|
|
var footageComp = app.project.items.addComp(
|
|
ctx.shotCode + "_FOOTAGE", width, height, 1, duration, fps);
|
|
if (precompFolder) {
|
|
footageComp.parentFolder = precompFolder;
|
|
}
|
|
if (ctx.frameStart !== null && ctx.frameStart !== undefined) {
|
|
setCompStartFrame(footageComp, ctx.frameStart);
|
|
}
|
|
addOCIOToLayer(footageComp.layers.add(footage));
|
|
|
|
// 4. Shot comp: footage + show LUT + overlay
|
|
var shotComp = app.project.items.addComp(ctx.shotCode, width, height, 1, duration, fps);
|
|
if (ctx.frameStart !== null && ctx.frameStart !== undefined) {
|
|
setCompStartFrame(shotComp, ctx.frameStart);
|
|
}
|
|
shotComp.layers.add(footageComp);
|
|
|
|
if (ctx.lutComp) {
|
|
var showLut = findComp(ctx.lutComp);
|
|
if (showLut) {
|
|
var lutLayer = shotComp.layers.add(showLut);
|
|
lutLayer.collapseTransformation = true;
|
|
} else {
|
|
warn("Show LUT comp \"" + ctx.lutComp + "\" not found — rendering without it");
|
|
}
|
|
}
|
|
|
|
if (ctx.overlayComp) {
|
|
var overlayComp = findComp(ctx.overlayComp);
|
|
if (overlayComp) {
|
|
var overlayLayer = shotComp.layers.add(overlayComp);
|
|
overlayLayer.moveToBeginning();
|
|
overlayLayer.enabled = true;
|
|
setEssentialProperty(overlayLayer, "DATE", ctx.slate.date);
|
|
setEssentialProperty(overlayLayer, "SHOT NAME", ctx.slate.versionName);
|
|
setShowField(overlayLayer, ctx.slate.show, "Overlay SHOW");
|
|
} else {
|
|
warn("Overlay comp \"" + ctx.overlayComp + "\" not found — rendering without burn-ins");
|
|
}
|
|
}
|
|
|
|
// 5. Preview comp from the export template (mirrors buildPreviewForShot)
|
|
var previewsFolder = findFolder("_PREVIEWS");
|
|
var previewComp = templateComp.duplicate();
|
|
previewComp.name = ctx.shotCode + "_PREVIEW";
|
|
if (previewsFolder) {
|
|
previewComp.parentFolder = previewsFolder;
|
|
}
|
|
|
|
previewComp.layer("SHOT").replaceSource(shotComp, false);
|
|
try {
|
|
previewComp.layer("THUMBNAIL").replaceSource(shotComp, false);
|
|
} catch (thumbError) {
|
|
warn("THUMBNAIL layer not updated: " + thumbError.toString());
|
|
}
|
|
|
|
var slateLayer = previewComp.layer("NETFLIX_SLATE");
|
|
if (slateLayer) {
|
|
// Identity fields match the panel's indices (3 = version name,
|
|
// 10 = shot name) and are also written by name; the rest are
|
|
// addressed by name only.
|
|
// VersionName carries the full "{shotCode}_cmp_TT_{version}";
|
|
// ShotName is the bare shot code, with no version suffix.
|
|
setSlateIdentity(slateLayer, "VersionName", 3, ctx.slate.versionName, "Version Name");
|
|
setSlateIdentity(slateLayer, "ShotName", 10, ctx.slate.shotCode, "Shot Name");
|
|
setEssentialProperty(slateLayer, "Date", ctx.slate.date);
|
|
setEssentialProperty(slateLayer, "Desc", ctx.slate.description);
|
|
setEssentialProperty(slateLayer, "Episode", ctx.slate.episode);
|
|
setEssentialProperty(slateLayer, "Scene", ctx.slate.scene);
|
|
setEssentialProperty(slateLayer, "Frames", result.frameCount);
|
|
setShowField(slateLayer, ctx.slate.show, "Slate SHOW");
|
|
|
|
setSlateField(slateLayer, ctx.slateScopeProp, ctx.slate.vfxScope, "VFX Scope");
|
|
// The slate's Notes field carries this submission's note; when the
|
|
// artist left it blank, fall back to the shot's own notes so the
|
|
// slate looks the same as an artist-built preview.
|
|
setSlateField(slateLayer, ctx.slateSubmissionProp,
|
|
(ctx.slate.submissionNote !== null &&
|
|
ctx.slate.submissionNote !== undefined &&
|
|
ctx.slate.submissionNote !== "")
|
|
? ctx.slate.submissionNote
|
|
: ctx.slate.notes,
|
|
"Submission Note");
|
|
} else {
|
|
warn("NETFLIX_SLATE layer not found in template — slate fields not filled");
|
|
}
|
|
|
|
var shotLayer = previewComp.layer("SHOT");
|
|
var targetOutPoint = shotLayer.inPoint + shotComp.duration;
|
|
if (targetOutPoint > previewComp.duration) {
|
|
previewComp.duration = targetOutPoint;
|
|
}
|
|
shotLayer.outPoint = targetOutPoint;
|
|
previewComp.duration = targetOutPoint;
|
|
|
|
result.previewComp = previewComp.name;
|
|
|
|
// 6. Queue both outputs against the same preview comp. aerender will
|
|
// render the whole queue in one launch.
|
|
app.project.renderQueue.showWindow(false);
|
|
while (app.project.renderQueue.numItems > 0) {
|
|
app.project.renderQueue.item(1).remove();
|
|
}
|
|
queueOutput(previewComp, ctx.movTemplate, ctx.movOutput, "mov");
|
|
queueOutput(previewComp, ctx.mp4Template, ctx.mp4Output, "mp4");
|
|
|
|
if (result.queued.length < 1) {
|
|
throw new Error("Nothing was queued — check output module templates");
|
|
}
|
|
|
|
// 7. Save the throwaway project the worker will hand to aerender
|
|
var tempFile = new File(ctx.tempAep);
|
|
var tempParent = tempFile.parent;
|
|
if (tempParent && !tempParent.exists) {
|
|
tempParent.create();
|
|
}
|
|
app.project.save(tempFile);
|
|
result.tempAep = ctx.tempAep;
|
|
result.ok = true;
|
|
} catch (buildError) {
|
|
result.ok = false;
|
|
result.error = buildError && buildError.toString ? buildError.toString() : String(buildError);
|
|
try {
|
|
if (buildError && buildError.line) {
|
|
result.error += " (line " + buildError.line + ")";
|
|
}
|
|
} catch (lineError) {
|
|
}
|
|
}
|
|
|
|
try {
|
|
app.endSuppressDialogs(false);
|
|
} catch (endSuppressError) {
|
|
}
|
|
|
|
if (!resultPath && ctx && ctx.resultPath) {
|
|
resultPath = ctx.resultPath;
|
|
}
|
|
if (resultPath) {
|
|
writeTextFile(resultPath, toJSON(result));
|
|
}
|
|
|
|
// -noui leaves the app running otherwise; the worker waits on exit.
|
|
try {
|
|
app.quit();
|
|
} catch (quitError) {
|
|
}
|
|
}());
|