Staging

Staging is the "set design" step of a three-node pipeline (Staging ➔ Acting ➔ Directing) that turns ComfyUI video generation from "type a prompt, cross your fingers" into something you can actually walk through first. Where most video workflows describe camera moves in a prompt and hope the model sorts it out, this pack makes you block out a real 3D environment, drives an actor through it with WASD, and records camera cuts against real geometry - then feeds that captured video to a reference-to-video model like Seedance or MiniMax H3 as ground truth. Staging is where that set gets built.

The pitch is a lot more compelling than it sounds for a node whose entire wire surface is one optional input and one output. The name "Staging" is doing real work: these aren't pixels, they're geometry. Blocks, barriers, spawn points - blockout (previz-grade gray-box) sets you can edit live in your browser and re-use across as many generations as you like.

How it works

The clever part is where the "work" happens: in your browser, not your GPU. Staging is a Vue.js + three.js app embedded in the node (a WebGL widget in the classic ComfyUI DOM-widget style), written against ComfyUI's newer V3 backend API. The Python half of the node is nearly a pass-through - it takes whatever stage JSON it receives, and re-emits it as the Stage Data output so the graph can keep state. Everything you see - orbiting the set, dragging blocks, picking presets - is client-side three.js. That's why the README can promise no GPU load and why the whole "playable previz" idea works at all: nothing needs a model, and nothing needs your render card until the video model at the end of the chain.

It's also why the pack's example workflow brags about needing 0 AI models. The stage presets ship inside the custom node folder, and the rigged actor models are bundled .glb files, not downloads.

The inputs and outputs that matter

• stage_data (optional string) - the serialized stage JSON. You will almost never hand-type this; it's the internal format. Leave it alone unless you're pasting a stage JSON between workflows.
• Stage Data output - a *-typed wire carrying the stage state. This is what plugs into the Acting node downstream - the one wire that makes the whole pipeline go.

The real controls live inside the widget: a preset dropdown, and viewport navigation. Left-click+drag orbits, right-click+drag pans, scroll zooms. Shift+click multi-selects, and there's Group/Ungroup for hierarchies. The bundled presets give you a fast starting point: race_track, liberty_beach, industrial_ruin, courthouse_square, gas_station, test-collider, and others. Pick one, add a few cubes to taste, and you're staging.

How to install it

Via ComfyUI Manager, search "Scene Camera Action" (or comfyui-scene-camera-action) and install. Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/arturitu/ComfyUI-scene-camera-action.git
pip install -r ComfyUI-scene-camera-action/requirements.txt

On a Windows portable install, run the pip line with python_embeded\python.exe -m pip. The requirements file is basically empty (typing_extensions) - all the heavy lifting is frontend. Restart ComfyUI and the nodes land under the scene-camera-action category. There are no model files to download, no weights, no API keys.

Common issues

The node renders inside your browser, so the two failure classes are frontend and workflow. If the widget area comes up blank or glitchy, your ComfyUI frontend is probably older than the pack expects - DOM-widget nodes and the V3 backend API are recent ComfyUI territory, so update ComfyUI before blaming the node. If you load a shared workflow and the Staging node shows no scene, check that the preset actually resolved and the Stage Data wire is connected downstream. And a friendly warning: because everything lives in browser state, big hand-edited stage JSONs pasted into stage_data are the one place you can genuinely break this - let the widget own the data.

From here the set flows into Acting, where the playable part begins. The set you build here is the whole point: it's the geometry the actor will drive on and the camera will avoid.