LC Vision Storyboard Builder (BETA) 🎞️

Here's the failure that motivated this node. You've planned a short film with the LC Vision Showrunner - cast, places, shot list - and you hit Run. Halfway through, the video model has to invent what one of your characters looks like, because nobody ever gave it a picture of him. Every segment after that invents him slightly differently.

LC Vision Storyboard Builder fixes that before it can happen. It reads the project, works out which reference pictures the movie doesn't have yet - a face per cast member, an empty shot of each place, an anchor frame for rooms with several people in them - and emits one prompt, one empty latent and one seed per picture. Wire your image model behind it and you get a storyboard folder instead of a gamble.

Note the odd bit: this node doesn't use the vision model at all. No GGUF, no Loader. The thinking already happened in the Showrunner; this is bookkeeping on the project JSON plus prompt templates written in Python.

The mechanism

The project lives at output/LC_H3/<project>/project.json, written by the Showrunner when you run or save it. The Builder reads the cast (name, who, look), the places (every distinct where across the shot list) and who appears in each shot.

From that it builds a wishlist: one face per cast member, one place picture per location described as empty, and one anchor per location that has a shot with more than one person in it - the opening wide frame that pins who stands where, and the reference that stops your video model reshuffling the room every segment. Anything you already have tagged as a face or full-body for that character, or a setting/layout for that place, counts as have and gets skipped.

The prompts come from the Shot List's own words, not from an LLM - a head-and-shoulders portrait on plain grey for a face, a 35mm eye-level establishing shot for a place. Anchors rewrite each character name into their look, because your image model has never heard of Earl; it just needs "the man (mid-fifties, heavy build)". Cast names in a prompt are a reliable way to get a stranger.

Sizes are rounded down to a multiple of 16, and latents are built from your VAE's own channel count and compression factor, so they're honest empty latents rather than a guess at what the model wants.

Inputs and outputs worth knowing

project_name must come off the Showrunner's project_name output - it's a socket, not a text field. vae is your image model's VAE, which is what makes the latent the right shape. family picks the prompt dialect and preferred sizes; today it's Krea 2 or Z-Image, and the difference is a closing line of photographic boilerplate. make is the everyday switch: missing only fills gaps, everything redoes all of them - your own pictures survive either way.

The three toggles - faces, places, anchors - let you build the set in stages, which is what I'd do on a first project: faces only, look at them, then places and anchors. portrait_size is the square face size (1024 by default); wide_width/wide_height default to 1344×768, matching the movie's own 960×544 shape, so don't wander far.

seed deserves a sentence: each picture's real seed is your seed plus a hash of its own name, so nudging the node's seed doesn't reshuffle picture six, and a redo of one picture leaves the other eleven alone. Then the optional pair - only takes names, comma separated (Earl, the bank lobby), and style is free text appended to every prompt.

Outputs are lists except summary: latent, prompt, seed (one per picture) and job, the little JSON tag telling the Save node which picture is which. Wire latent into your sampler, prompt into the positive text encode, seed into the sampler's seed, and job into LC Vision Storyboard Save. Being lists, one Run makes the whole set - you're not queuing twelve times. summary says exactly what it's about to make, take numbers included.

Install

ComfyUI Manager, search ComfyUI LC Vision Nodes, install. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/lonecatone23/ComfyUI_LC_Vision_nodes.git

Run install.py and restart. Its job is pulling a matching llama-cpp-python vision wheel - which, strictly for this node, you don't need: the storyboard modules load independently of the vision stack. The Showrunner that produces your project does need it, though. Expect Python 3.10+ and an NVIDIA CUDA runtime for that half.

When it doesn't work

"no project 'X' in output/LC_H3" is the error you'll actually see, and it means exactly what it says: the Builder has nothing to read. Run the Showrunner once, or hit its 💾 Save, so project.json exists. The Builder never invents a project.

"Nothing to make." Everything on the wishlist already has a picture. Either set make to everything, or use only to force one name. In that state it deliberately blocks the sampler rather than rendering nothing twelve times.

It's re-planning constantly. When project_name is wired, the node reports itself changed every run (the float("nan") trick), so the summary and prompts are always current. That's cheap - it's JSON reading - but it means downstream nodes don't get to sit in the cache.

Names don't match. only matches names and place strings exactly as spelled in the Shot List, and a place called "the bank lobby" in one shot and "bank lobby" in another is two places to this node. You'll get two pictures. Keep the wording consistent.

Last thing: this node is BETA and new, and the pack's README still describes the pack as it was before the storyboard nodes existed. There's no tutorial for it - the docs are the node's tooltips. Read them, they're better written than most.