FL Poster Layers

FL Poster Layers is where the poster pipeline stops being a plan and starts burning GPU time. Hand it a plan from FL Image Layer Planner plus a model, CLIP, VAE and your source image, and it extracts each layer for real - one sampling run per entry, each guided by that entry's extraction prompt with the source image attached as a reference latent. Out comes a layer stack your parallax node can fly a camera through.

It expands into a subgraph, which is why the node looks the way it does. Behind the enable_expand flag it builds a small graph per layer: an empty layered latent, the source encoded through the VAE as a reference, a text encode of the layer's prompt, and a KSampler. That's the Qwen layered route - the stack is generated with an RGBA-capable VAE so transparency comes out of the model rather than being cut out afterwards. Edge quality is the payoff: hair, glass and smoke get real alpha instead of a matte's best guess.

The consequence is the thing to internalise: six planned layers means six full sampling runs. This is the expensive node in the pipeline, and maximum_layers upstream is your only brake.

The inputs

plan comes from the planner. model, clip, vae and image are the usual crew, and they need to be the right family for the layered latent path - this is a Qwen-image-layered generation, not a generic KSampler. seed, steps, cfg, sampler_name and scheduler are the shared sampling settings, applied across all layers with per-layer seed offsets so the layers differ.

overrides is the interesting one: a JSON string of per-layer prompt, depth, placement, visibility and reroll edits, applied on the next Run. So the loop is: run once, look at the layers on the node, fill in overrides for the two that came out wrong, run again. That's a much better workflow than nuking the plan and starting over - it turns "the midground came out as mush" into a one-layer re-roll.

Output and where it goes

One output: layer_stack, type FL_PARALLAX_STACK, carrying the background and the cutouts with their planned depths. From there it goes into FL Layered Parallax (which takes the stack's background in preference to a separate image input) or into FL Parallax Depth Sources if you want relief.

You should also look at the layers. The extraction path saves each layer and a thumbnail to disk and reports coverage; that review data is how you know which layers to override, and the node surfaces it rather than making you hunt through the output folder.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/filliptm/ComfyUI_Fill-Nodes

Restart. Requirements: a current ComfyUI - this node's subgraph uses newer core nodes for layered latents, plus comfy_api.latest, and if your build is old the pack won't import at all. You'll need the layered-capable model, text encoder, and RGBA VAE to match. Fill-Nodes itself brings a long pip list; none of it is specific to this node.

Where people get burned

Cost, again. Layered extraction is not a cheap operation, and it's linear in layer count. Plan with maximum_layers: 4 the first time you try a poster, not 12.

Plan and stack drift. The stack expects assets to match the plan exactly, starting with the background. If a layer's asset is missing or reordered you get a validation error rather than a mystery compositing bug - one of the nicer things about this pipeline.

Overrides that look like they did nothing. They apply on the next run. Change them and queue again; the current render is already on screen.

Expecting flat output. These layers come out RGBA over the full canvas, with the background layer being the full canvas too. That's deliberate - every layer is a complete, correctly registered plate, which is exactly what the parallax renderer needs.