Acting

This is the node that makes ComfyUI-scene-camera-action feel like a toy you actually want to play with. Acting sits between Staging and Directing: it takes your gray-box 3D set, drops in a rigged character (or car, or dog), and lets you record a performance by driving it around with WASD in real time. Record once, and every camera cut you set up downstream in Directing has real motion to frame against. No keyframes, no spline editing, no timeline scrubbing to place a character - you just move it.

That's the whole editorial bet of this pack, and it's a good one: for reference/previz video work, the hardest thing to communicate to a video model is trajectory. Prompts fail at "the car drifts left, slows, then turns into the alley at second four." A recorded motion path doesn't. Acting turns choreography into data your camera and your final video model can both consume.

How it works

Wire in the Stage Data from a Staging node, and the node hosts another embedded three.js viewport. You pick an actor archetype, hit Record, drive with W/A/S/D for the recording window, and the widget serializes your whole path - position, rotation, speed over time - into a compact trajectory JSON. The Python backend just parses that and hands it forward as Acting Data; like Staging, the actual "acting" happens in your browser at 60fps, not on the model GPU.

Three archetypes ship in the pack: Human (rigged, with idle/walk/run locomotion), Car (vehicle physics - steering, acceleration, drift), and Quadruped (added in v0.5, a four-legged actor with sit/walk/run animations and its own default scale). Before you commit a take there's a Practice Rehearsal Mode - loop a movement freely to feel out the path, then record the real one. Recorded takes play back as a ghost so you can judge the motion before you ever touch the camera node.

The inputs that matter

• actor_type - human, car, or quadruped. The whole feel of the take changes here.
• actor_speed (1–30, default 10) and actor_scale (0.3–2.0, default 1) - how fast and how big the actor is. These aren't cosmetic: Directing auto-frames and auto-zooms the camera around the actor, so a tiny quadruped or an over-speedy car reshapes your shots.
• duration (4–15s, default 7) - the recording window in seconds. Plan the beat before you hit Record; you can't extend a take later.
• stage (optional *) - connect a Staging node, or chain the Acting Data of a previous Acting node into this same socket for multi-actor chaining (multiple characters/cars sequenced on one stage, replayed together in sync).

The output is Acting Data (*), and it's the only wire you need to pull: it feeds Directing for camera work, and it embeds the stage geometry so Directing knows where walls are.

How to install it

Identical to the rest of the pack: ComfyUI Manager → search "Scene Camera Action", or

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

then restart ComfyUI. (Windows portable: use python_embeded\python.exe -m pip install -r ....) Nothing to download - the rigged actor models are bundled .glb assets in the repo. Nodes appear in the scene-camera-action category.

Common issues

The recurring trap here is a workflow-state one: motion is only real if it's been recorded and the ghost replay is playing. If you wire up Acting, queue the graph, and your Directing node downstream complains that motion is missing, you almost always skipped the Record step - the node needs an actual trajectory in its hidden motion_data before Directing will so much as open its canvas. Rehearsal mode is great for practicing, but it does not count as a recorded take. Keep the browser tab focused while you're driving, too - WASD and the recording loop live in the frontend, so a backgrounded or minimized tab can drop frames you didn't mean to lose.

Once you've got a take you like, hand Acting Data to Directing and go shoot it.