SolarRenderer: Few-Step Generative Reference Rendering
Python
SolarRenderer on ComfyUI: nodes, workflows, long clips and the SolarRenderer page (#3)
Guian Fang00b89093234a
diff --git a/README.md b/README.mdindex 69f89b8..2c932b9 100644--- a/README.md+++ b/README.md@@ -80,23 +80,15 @@ Add `--causal` with the two causal LoRAs to stream the clip block by block- 🏋️ **Training** on one 8-GPU node ([guide](docs/training.md)).- 📊 **Benchmark scoring** ([guide](eval/README.md)).-## Inference with Reactor Runtime+## Ways to run-The [Reactor integration](reactor/README.md) provides a streaming inference service-and a browser demo for a structure video, optional appearance reference, and prompt.-The guide includes four-B200 validation results and deployment limitations.-After preparing the licensed weights as described in that guide:+| | For | Start here |+|---|---|---|+| **Reference script** | The reference implementation: one GPU, a clip at a time | `scripts/render.py` above |+| **ComfyUI** | A browser page and node workflows with no code; the low-memory workflow fits a 16 GB GPU (e.g. RTX 4090) | [`comfyui/`](comfyui/README.md) |+| **Streaming on [Reactor](https://reactor.inc)** | The fastest path: a four-GPU streaming service with a browser demo, validated by the Reactor team on four B200 GPUs | [`reactor/`](reactor/README.md) |-```bash-cd reactor-reactor build-reactor run --gpus device=0,1,2,3 --shm-size 8g --port 8080 --weights ./weights-```--Check `http://localhost:8080/health`, then run `cd reactor/demo && npm ci && npm run dev`-from another terminal at the repository root. Open http://localhost:5173, click-**Connect**, select your inputs, and click **Start new video**. See the integration-guide for SSH/WebRTC networking and the fixed-prompt, finite-video behavior.+The Reactor integration is a community contribution; thanks to [Rising0321](https://github.com/Rising0321) and the Reactor team.## Citationdiff --git a/__init__.py b/__init__.pynew file mode 100644index 0000000..6a3adf9--- /dev/null+++ b/__init__.py@@ -0,0 +1,5 @@+"""ComfyUI loads this repository as a custom node pack when it is cloned into ComfyUI/custom_nodes (see comfyui/)."""++from .comfyui import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS++__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]diff --git a/comfyui/README.md b/comfyui/README.mdnew file mode 100644index 0000000..a386d42--- /dev/null+++ b/comfyui/README.md@@ -0,0 +1,80 @@+# SolarRenderer in ComfyUI++SolarRenderer runs on ComfyUI's own MiniMax-H3 with a few extra nodes. Load a structure video (a grey box, a+segmentation, skeletons, depth, a game's frames, a sketch), add a first frame and a prompt, and render it in four steps.++## Install++1. Update ComfyUI to a version with MiniMax-H3 (v0.30.0 or later).+2. Clone this repository into `ComfyUI/custom_nodes`:++ ```bash+ cd ComfyUI/custom_nodes && git clone https://github.com/Enderfga/SolarRenderer+ ```++3. Download the models into `ComfyUI/models` (pick one row per folder; the workflows below say which):++ | Folder | Full quality | Low memory | From |+ |---|---|---|---|+ | `diffusion_models` | `minimax_h3_ref2va_bf16.safetensors` | `minimax_h3_ref2va_pruned_int8_convrot.safetensors` | [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3) |+ | `text_encoders` | `qwen3vl_32b_minimax_h3_bf16.safetensors` | `qwen3vl_32b_minimax_h3_int8_convrot.safetensors` | Comfy-Org/MiniMax-H3 |+ | `vae` | `minimax_h3_video_vae_fp16.safetensors` | same | Comfy-Org/MiniMax-H3 |+ | `loras` | `solarrenderer_control_lora.safetensors`, `solarrenderer_4step_lora.safetensors` | same | [Enderfga/SolarRenderer](https://huggingface.co/Enderfga/SolarRenderer) |+ | `loras` (long clips) | `solarrenderer_causal_control_lora.safetensors`, `solarrenderer_causal_4step_lora.safetensors` | same | Enderfga/SolarRenderer |+ | `vae_approx` (optional, previews) | `taeh3.safetensors` | same | [madebyollin/taehv](https://github.com/madebyollin/taehv/tree/main/safetensors) |++ The SolarRenderer LoRAs are used as released; the LoRA loader below maps them onto ComfyUI's weights.++## The SolarRenderer page++Start ComfyUI and open `http://127.0.0.1:8188/solarrenderer`: pick an example or drop in your own structure video and+first frame, write the prompt, choose the models and render: **6.6 s** renders the first 158 frames in one pass,+**Whole video** the whole structure video chunk by chunk (see [Long clips](#long-clips)). The page shows the sampler's+previews as they arrive and plays the render beside its structure when it is done. It runs on the same ComfyUI, so+everything below (models, memory, the queue) applies to it too.++## Workflows++For the node graph itself, drag a file from [`workflows/`](workflows) into ComfyUI. Both render the+[synthwave example](../examples/sem-highway_synthwave) (copy its `structure.mp4` and `first.png` into+`ComfyUI/input`).++| Workflow | Models | GPU memory |+|---|---|---|+| `solarrenderer_full.json` | full quality | a large GPU; less memory works, more slowly |+| `solarrenderer_low_memory.json` | low memory (8-bit) | **16 GB**, e.g. RTX 4080 or RTX 4090 |++The low-memory models render close to the full ones. ComfyUI keeps on the GPU only what fits and moves the rest in+from system memory as it is needed: the low-memory workflow completed with ComfyUI held to 14 GB of GPU memory, peaking+at 14.5 GB including the CUDA context. Give it 64 GB of system memory. On a GPU that holds every model, the low-memory+workflow takes about twice as long as the full one; on a smaller card, moving the weights in adds to that.++## Long clips++`solarrenderer_long.json` renders a structure video of any length (up to 150 s) with the causal LoRA pair: the+**SolarRenderer Causal Sampler** generates five latent frames (about 17 video frames) at a time, each chunk seeing the+prompt, the first frame and the structure and render of the five chunks before it, so the memory stays that of a+six-chunk window however long the clip. Its `length` is set to the maximum, so the whole structure video is rendered.++The sampler keeps the window's keys and values in a cache of up to about 80 GB at 1344×768. `cache: auto` keeps it on+the GPU when it fits and in system memory otherwise (or choose `system memory`), which lets a smaller GPU render long+clips with the low-memory models, more slowly.++**Live previews**: put `taeh3.safetensors` in `ComfyUI/models/vae_approx` and start ComfyUI with+`--preview-method taesd` to watch each step (the page asks for previews by itself). The same file, chosen in a+`Load VAE` node, decodes in a fraction of the time at a visible cost in detail.++## Nodes++| Node | What it does |+|---|---|+| **SolarRenderer LoRA Loader** | Loads a released SolarRenderer LoRA. Chain two: the four-step LoRA, then the control LoRA. |+| **SolarRenderer Structure to Video** | The structure video, the first frame and the prompt in; the conditioning and an empty latent out. `length` is in frames at 24 fps (trained at 158). Connect `taeh3` to `structure_vae` to encode the structure faster. |+| **SolarRenderer Model (silent soundtrack)** | Holds the soundtrack at silence while sampling, as the renderer was trained. |+| **SolarRenderer Four-Step Sigmas** | The four-step schedule. Sample with `SamplerCustomAdvanced`, the `lcm` sampler and a `BasicGuider`. |+| **SolarRenderer Causal Sampler (long clips)** | Renders the conditioning chunk by chunk with the causal LoRA pair, at any length; split the result with `Separate AV Latent` and decode it with `VAE Decode`. |+| **SolarRenderer Fast Attention** | Runs attention on another kernel, which on many GPUs samples faster than ComfyUI's default; same output. Bypass it if it is slower on yours. |+| **SolarRenderer Prompt** | Builds the six-part prompt from its free parts ([prompt guide](../docs/prompts.md)). |+| **SolarRenderer Web Capture** | Records a web page's 3D canvas (three.js or any WebGL) as a structure video, with its sound: a URL in, frames and audio out. An optional key script plays it. Needs `pip install playwright && python -m playwright install chromium`. |++Split the sampled latent with `Separate AV Latent` and decode the video with `VAE Decode`.diff --git a/comfyui/__init__.py b/comfyui/__init__.pynew file mode 100644index 0000000..e1e4a42--- /dev/null+++ b/comfyui/__init__.py@@ -0,0 +1,14 @@+"""SolarRenderer for ComfyUI (see comfyui/README.md)."""++from .causal import SolarRendererCausalSampler+from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS++NODE_CLASS_MAPPINGS["SolarRendererCausalSampler"] = SolarRendererCausalSampler+NODE_DISPLAY_NAME_MAPPINGS["SolarRendererCausalSampler"] = "SolarRenderer Causal Sampler (long clips)"++try: # the page needs the running server; the nodes load without it (tests, tooling)+ from . import app # noqa: F401+except ImportError:+ pass++__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]diff --git a/comfyui/app.py b/comfyui/app.pynew file mode 100644index 0000000..354c30c--- /dev/null+++ b/comfyui/app.py@@ -0,0 +1,185 @@+"""The SolarRenderer page: a browser front end served by this ComfyUI, at http://<comfyui>/solarrenderer.++Pick an example or upload a structure video (and a first frame), write the prompt, choose full quality or low memory,+and render. The page builds the same graph as the workflows in workflows/, queues it on this server, shows the+sampler's previews as they arrive and plays the render beside its structure when it is done. Nothing runs outside+ComfyUI: the models, the memory management and the queue are ComfyUI's own.+"""++import logging+import os+import re+import shutil++import folder_paths+from aiohttp import web+from server import PromptServer++HERE = os.path.dirname(os.path.abspath(__file__))+WEB = os.path.join(HERE, "web")+EXAMPLES = os.path.join(os.path.dirname(HERE), "examples")+INPUT_SUBFOLDER = "solarrenderer"++QUALITIES = {+ "full": {+ "label": "Full quality",+ "note": "bf16 weights, for a large GPU",+ "unet": "minimax_h3_ref2va_bf16.safetensors",+ "clip": "qwen3vl_32b_minimax_h3_bf16.safetensors",+ },+ "low_memory": {+ "label": "Low memory",+ "note": "8-bit weights; runs on a 16 GB GPU",+ "unet": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",+ "clip": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",+ },+}+VAE = "minimax_h3_video_vae_fp16.safetensors"+FEWSTEP_LORA = "solarrenderer_4step_lora.safetensors"+CONTROL_LORA = "solarrenderer_control_lora.safetensors"+CAUSAL_FEWSTEP_LORA = "solarrenderer_causal_4step_lora.safetensors"+CAUSAL_CONTROL_LORA = "solarrenderer_causal_control_lora.safetensors"+++def _missing(quality: dict, causal: bool = False) -> list:+ """The model files this quality (and the causal pair, for long clips) needs that ComfyUI cannot find."""+ loras = (CAUSAL_FEWSTEP_LORA, CAUSAL_CONTROL_LORA) if causal else (FEWSTEP_LORA, CONTROL_LORA)+ need = [("diffusion_models", quality["unet"]), ("text_encoders", quality["clip"]), ("vae", VAE),+ *(("loras", name) for name in loras)]+ return [f"{folder}/{name}" for folder, name in need if name not in folder_paths.get_filename_list(folder)]+++def graph(quality: str, structure: str, first: str | None, prompt: str, seed: int, width: int, height: int,+ length: int, causal: bool = False) -> dict:+ """The render as an API-format prompt: the nodes and settings of workflows/solarrenderer_*.json; ``causal`` renders+ a long clip chunk by chunk with the causal LoRA pair."""+ q = QUALITIES[quality]+ fewstep, control = (CAUSAL_FEWSTEP_LORA, CAUSAL_CONTROL_LORA) if causal else (FEWSTEP_LORA, CONTROL_LORA)+ nodes = {+ "1": {"class_type": "UNETLoader", "inputs": {"unet_name": q["unet"], "weight_dtype": "default"}},+ "2": {"class_type": "SolarRendererLoraLoader", "inputs": {"model": ["1", 0], "lora_name": fewstep, "strength": 1.0}},+ "3": {"class_type": "SolarRendererLoraLoader", "inputs": {"model": ["2", 0], "lora_name": control, "strength": 1.0}},+ "4": {"class_type": "SolarRendererFastAttention", "inputs": {"model": ["3", 0], "backend": "auto"}},+ "5": {"class_type": "SolarRendererModel", "inputs": {"model": ["4", 0], "seed": seed}},+ "6": {"class_type": "CLIPLoader", "inputs": {"clip_name": q["clip"], "type": "minimax", "device": "default"}},+ "7": {"class_type": "VAELoader", "inputs": {"vae_name": VAE}},+ "8": {"class_type": "LoadVideo", "inputs": {"file": structure}},+ "9": {"class_type": "GetVideoComponents", "inputs": {"video": ["8", 0]}},+ "11": {"class_type": "SolarRendererConditioning", "inputs": {+ "clip": ["6", 0], "vae": ["7", 0], "structure": ["9", 0], "prompt": prompt,+ "width": width, "height": height, "length": length}},+ "12": {"class_type": "KSamplerSelect", "inputs": {"sampler_name": "lcm"}},+ "13": {"class_type": "SolarRendererSigmas", "inputs": {"steps": 4}},+ "14": {"class_type": "RandomNoise", "inputs": {"noise_seed": seed}},+ "15": {"class_type": "BasicGuider", "inputs": {"model": ["5", 0], "conditioning": ["11", 0]}},+ "16": {"class_type": "SamplerCustomAdvanced", "inputs": {+ "noise": ["14", 0], "guider": ["15", 0], "sampler": ["12", 0], "sigmas": ["13", 0], "latent_image": ["11", 1]}},+ "17": {"class_type": "LTXVSeparateAVLatent", "inputs": {"av_latent": ["16", 0]}},+ "18": {"class_type": "VAEDecode", "inputs": {"samples": ["17", 0], "vae": ["7", 0]}},+ "19": {"class_type": "CreateVideo", "inputs": {"images": ["18", 0], "fps": 24.0}},+ "20": {"class_type": "SaveVideo", "inputs": {+ "video": ["19", 0], "filename_prefix": "SolarRenderer/render", "format": "mp4", "codec": "h264"}},+ }+ if causal: # one node samples the whole clip, chunk by chunk+ for key in ("4", "5", "12", "13", "14", "15"):+ nodes.pop(key)+ nodes["16"] = {"class_type": "SolarRendererCausalSampler", "inputs": {+ "model": ["3", 0], "positive": ["11", 0], "latent": ["11", 1], "seed": seed, "cache": "auto"}}+ if first:+ nodes["10"] = {"class_type": "LoadImage", "inputs": {"image": first}}+ nodes["11"]["inputs"]["first_frame"] = ["10", 0]+ return nodes+++def _examples() -> list:+ found = []+ for name in sorted(os.listdir(EXAMPLES)) if os.path.isdir(EXAMPLES) else []:+ root = os.path.join(EXAMPLES, name)+ if not os.path.isfile(os.path.join(root, "structure.mp4")):+ continue+ title = name+ readme = os.path.join(root, "README.md")+ if os.path.isfile(readme):+ heading = open(readme, encoding="utf-8").readline().lstrip("# ").strip()+ title = re.sub(r"^Example:\s*", "", heading) or name+ found.append({"id": name, "title": title[:1].upper() + title[1:],+ "first": os.path.isfile(os.path.join(root, "first.png"))})+ return found+++def _example_dir(request) -> str:+ name = request.match_info["name"]+ if name not in {e["id"] for e in _examples()}:+ raise web.HTTPNotFound()+ return os.path.join(EXAMPLES, name)+++routes = PromptServer.instance.routes++[email protected]("/solarrenderer")+async def page(request):+ return web.FileResponse(os.path.join(WEB, "index.html"))++[email protected]("/solarrenderer/static/{file}")+async def static(request):+ path = os.path.join(WEB, os.path.basename(request.match_info["file"]))+ if not os.path.isfile(path):+ raise web.HTTPNotFound()+ return web.FileResponse(path)++[email protected]("/solarrenderer/api/info")+async def info(request):+ qualities = [{"id": k, "label": q["label"], "note": q["note"], "missing": _missing(q),+ "missing_causal": _missing(q, causal=True)} for k, q in QUALITIES.items()]+ return web.json_response({"qualities": qualities, "examples": _examples()})++[email protected]("/solarrenderer/api/example/{name}/{file}")+async def example_file(request):+ file = request.match_info["file"]+ if file not in ("structure.mp4", "first.png", "preview.gif", "prompt.txt"):+ raise web.HTTPNotFound()+ path = os.path.join(_example_dir(request), file)+ if not os.path.isfile(path):+ raise web.HTTPNotFound()+ return web.FileResponse(path)++[email protected]("/solarrenderer/api/example/{name}")+async def use_example(request):+ """Copy an example's files into ComfyUI's input folder, where the loaders read them."""+ root, name = _example_dir(request), request.match_info["name"]+ target = os.path.join(folder_paths.get_input_directory(), INPUT_SUBFOLDER)+ os.makedirs(target, exist_ok=True)+ chosen = {}+ for file, key in (("structure.mp4", "structure"), ("first.png", "first")):+ if os.path.isfile(os.path.join(root, file)):+ shutil.copyfile(os.path.join(root, file), os.path.join(target, f"{name}_{file}"))+ chosen[key] = f"{INPUT_SUBFOLDER}/{name}_{file}"+ prompt = os.path.join(root, "prompt.txt")+ chosen["prompt"] = open(prompt, encoding="utf-8").read() if os.path.isfile(prompt) else ""+ return web.json_response(chosen)++[email protected]("/solarrenderer/api/graph")+async def make_graph(request):+ body = await request.json()+ quality = body.get("quality", "low_memory")+ if quality not in QUALITIES:+ return web.json_response({"error": f"unknown quality {quality}"}, status=400)+ causal = bool(body.get("causal"))+ missing = _missing(QUALITIES[quality], causal)+ if missing:+ return web.json_response({"error": "missing models: " + ", ".join(missing)}, status=400)+ if not body.get("structure") or not str(body.get("prompt", "")).strip():+ return web.json_response({"error": "a structure video and a prompt are needed"}, status=400)+ landscape = body.get("orientation", "landscape") != "portrait"+ return web.json_response({"prompt": graph(+ quality, body["structure"], body.get("first") or None, body["prompt"], int(body.get("seed", 0)),+ 1344 if landscape else 768, 768 if landscape else 1344, int(body.get("length", 158)), causal)})+++logging.info("SolarRenderer: the page is at /solarrenderer")diff --git a/comfyui/causal.py b/comfyui/causal.pynew file mode 100644index 0000000..5f5f2eb--- /dev/null+++ b/comfyui/causal.py@@ -0,0 +1,295 @@+"""Long clips, chunk by chunk: SolarRenderer's causal LoRA pair on ComfyUI's own MiniMax-H3.++The causal renderer generates a clip five latent frames (about 17 video frames) at a time, each chunk seeing the prompt,+the first frame, the soundtrack, the structure of its own and the five chunks before it, and the rendered frames of+those five chunks - nothing later. So a clip can run far past the 158 frames of a single render, with the memory of a+six-chunk window. This is the sampler of the released ``--causal`` path (scripts/render.py, omni_causal.stream):++* the prompt and the first frame (time 1 and 0.999) and the held silence (0.999) are written to a key/value cache once;+* each chunk's structure (0.999) is written once, seeing the prompt, the first frame and itself;+* each chunk is denoised in four evaluations against the cache, re-noised between them to the next level, and written+ back at 0.999 with its own clean frames.++Every forward runs only the rows it adds - one chunk - against the cached keys and values of the rest.+"""++import logging++import torch++import comfy.model_management as mm+import comfy.nested_tensor+import comfy.quant_ops+import comfy.utils+import latent_preview+from comfy.ldm.minimax.model import PackedLayout, pack_audio, patchify_video, rope_rotation_table, unpatchify_video++from .nodes import CATEGORY, SHIFT_AUDIO, SHIFT_VIDEO, SILENCE, _fa4, shifted_sigmas++STATIC_TIME = 1.0 # the prompt rows+CLEAN_LEVEL = 0.999 # the first frame, the structure, the soundtrack and every rendered chunk as the next ones see it+CHUNK, WINDOW, STEPS = 5, 6, 4+TAG_VIDEO, TAG_AUDIO = 0, 2 # ComfyUI's modality tags (text rows carry their own, from the text encoder)+++def _silence(length: int, edge: int = 20):+ """H3's encoded silence over ``length`` audio latents, ``[1, 32, 2, length]``: away from its first and last+ ``edge`` columns the encoded silence is constant, so a longer one keeps both ends and repeats a middle column."""+ silence = comfy.utils.load_torch_file(SILENCE)["silence_170f"].float().permute(1, 0, 2).unsqueeze(0)+ columns = silence.shape[-1]+ if length <= columns:+ return silence[..., :length]+ middle = silence[..., columns // 2: columns // 2 + 1].expand(*silence.shape[:-1], length - 2 * edge)+ return torch.cat((silence[..., :edge], middle, silence[..., columns - edge:]), dim=-1).contiguous()+++def _attention_kernel():+ fa4 = _fa4()++ def attend(q, k, v): # [1, tokens, heads, head_dim]+ if fa4 is not None and q.is_cuda:+ out = fa4(q, k, v)+ return out[0] if isinstance(out, tuple) else out+ from torch.nn.attention import SDPBackend, sdpa_kernel++ order = [SDPBackend.CUDNN_ATTENTION, SDPBackend.FLASH_ATTENTION, SDPBackend.EFFICIENT_ATTENTION, SDPBackend.MATH]+ with sdpa_kernel(order, set_priority=True):+ out = torch.nn.functional.scaled_dot_product_attention(q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2))+ return out.transpose(1, 2)++ return attend+++class _Cache:+ """Per layer, the keys and values (after the rotary) of written rows under ``(kind, chunk)``; chunks of a kind+ older than the window are dropped as new ones arrive. Kept on ``device`` (the GPU, or system memory for a small+ GPU: about 1 MB per row over all layers)."""++ def __init__(self, window: int, device):+ self.layers, self.window, self.device = {}, window, device++ def put(self, layer, name, key, value):+ entries = self.layers.setdefault(layer, {})+ entries[name] = (key.to(self.device, copy=True), value.to(self.device, copy=True))+ kind, chunk = name+ for old in [n for n in entries if n[0] == kind and n[1] <= chunk - self.window]:+ entries.pop(old)++ def get(self, layer, name, device):+ key, value = self.layers[layer][name]+ return key.to(device, non_blocking=True), value.to(device, non_blocking=True)+++class CausalRun:+ """One clip on a loaded MiniMax-H3 (``dm``): its document's rows, the cache, and the chunk loop."""++ def __init__(self, dm, device, dtype, context, extra, latent_shapes, seed, cache_device):+ self.dm, self.device, self.dtype = dm, device, dtype+ self.attend = _attention_kernel()+ self.generator = torch.Generator(device=device).manual_seed(int(seed))+ (_, _, frames, height, width), audio_t = latent_shapes[0], latent_shapes[1][-1]+ if height % 2 or width % 2:+ raise ValueError("the latent's height and width must be even (width and height multiples of 32)")+ self.frames, self.height, self.width = frames, height, width+ self.per_frame = (height // 2) * (width // 2)++ keyframes = extra.get("minimax_keyframes") or []+ if not keyframes or keyframes[0]["latent"].shape[2] != frames:+ raise ValueError("SolarRenderer Causal Sampler takes the conditioning of SolarRenderer Structure to Video")+ context = context.to(device, dtype)+ layout = PackedLayout(context.shape[1], frames, height, width, audio_t, keyframes=keyframes)+ self.positions = layout.position_ids+ segments = layout.segments+ self.text = segments[0][:2]+ conds = [s[:2] for s in segments if s[2] == "cond"]+ self.structure_start = conds[0][0]+ self.first = conds[1] if len(conds) > 1 else None+ self.audio = next(s[:2] for s in segments if s[2] == "audio")+ self.video_start = next(s[0] for s in segments if s[2] == "video")++ # the condition rows (structure, then the first frame), as ComfyUI noises them to 0.999 for every render+ self.cond_rows = dm._cond_video_rows({"cond_video_latents": [k["latent"] for k in keyframes],+ "seed": int(seed)}, device)+ self.text_embed = dm.preprocess_text_embeds(context)[0]+ tags = extra.get("minimax_token_tags")+ self.text_tags = tags.view(-1).tolist() if tags is not None else [1] * context.shape[1]+ clean = _silence(audio_t).to(device)+ noise = torch.randn(clean.shape, generator=self.generator, device=device, dtype=torch.float32)+ self.audio_embed = dm.audio_patch_proj(pack_audio(CLEAN_LEVEL * clean + (1.0 - CLEAN_LEVEL) * noise)).to(dtype)+ self.cache = _Cache(WINDOW, cache_device)++ # ------------------------------------------------------------------------------------------------ one forward++ def _video_embed(self, rows):+ return self.dm.video_patch_proj(rows.to(self.device, torch.float32)).to(self.dtype)++ def _forward(self, pieces, cached, commit, sigma=None):+ """Run the rows ``pieces`` [(embed, (start, stop) in the document, time, tag)] against the cached ``cached``;+ write their keys and values as ``commit``; with ``sigma``, return the last piece's velocity rows."""+ dm = self.dm+ h = torch.cat([p[0] for p in pieces]).contiguous()+ positions = torch.cat([self.positions[a:b] for _, (a, b), _, _ in pieces])+ times = sorted({p[2] for p in pieces})+ index = {t: i for i, t in enumerate(times)}+ mod, row = [], 0+ for embed, _, t, tag in pieces:+ n = embed.shape[0]+ if isinstance(tag, list): # the prompt: runs of its rows' own tags+ start = 0+ for i in range(1, n + 1):+ if i == n or tag[i] != tag[start]:+ mod.append((row + start, row + i, index[t] * 3 + int(tag[start])))+ start = i+ else:+ mod.append((row, row + n, index[t] * 3 + tag))+ row += n++ t_vals = torch.tensor(times, dtype=torch.float32, device=self.device)+ if dm.use_adaln_curves:+ table = mm.cast_to(dm.adaln_t_table, device=self.device)+ pos = t_vals.clamp(0.0, 1.0) * (table.shape[0] - 1)+ i0 = pos.floor().long().clamp(max=table.shape[0] - 2)+ t_emb = torch.lerp(table[i0], table[i0 + 1], (pos - i0).unsqueeze(1))+ else:+ t_emb = dm.time_embedder(t_vals).to(self.dtype)+ rope = rope_rotation_table(dm.rope_freqs(positions, self.device), self.dtype)++ for layer, block in enumerate(dm.blocks):+ h = block(h, t_emb, mod, rope, transformer_options={},+ attention=self._attention(block.attn, layer, cached, commit))+ if sigma is None:+ return None+ n = pieces[-1][0].shape[0]+ a, b = row - n, row+ video, _ = dm.final_layer(h, t_emb, (a, b, index[pieces[-1][2]]), (b, b, index[pieces[-1][2]]),+ torch.tensor(sigma), None, (SHIFT_VIDEO, SHIFT_AUDIO))+ return video++ def _attention(self, attn, layer, cached, commit):+ """The block's attention over its own rows and the cached ones: H3's q/k norm and rotary as ComfyUI computes+ them, the new keys and values written to the cache when the forward commits."""++ def run(x, rope_freqs=None, transformer_options={}):+ s, heads, dim = x.shape[0], attn.heads, attn.head_dim+ q, k, v = attn.qkv_proj(x).split(heads * dim, dim=-1)+ v = v.view(s, heads, dim)+ q, k = q.view(1, s, heads, dim), k.view(1, s, heads, dim)+ qw = mm.cast_to(attn.q_norm.weight, device=x.device)+ kw = mm.cast_to(attn.k_norm.weight, device=x.device)+ comfy.quant_ops.ck.rms_rope_split_half_(q, k, rope_freqs, qw, kw, epsilon=attn.q_norm.eps,+ rot_dim=rope_freqs.shape[-3] * 2)+ k = k[0]+ if commit is not None:+ self.cache.put(layer, commit, k, v)+ keys, values = [], []+ for name in cached:+ ck, cv = self.cache.get(layer, name, x.device)+ keys.append(ck)+ values.append(cv)+ keys.append(k)+ values.append(v)+ out = self.attend(q.contiguous(), torch.cat(keys).unsqueeze(0).contiguous(),+ torch.cat(values).unsqueeze(0).contiguous())+ return attn.out_proj(out.reshape(s, heads * dim))++ return run++ # ------------------------------------------------------------------------------------------------ the clip++ def prefill(self):+ """The prompt and the first frame, then the soundtrack, into the cache."""+ static = [(self.text_embed, self.text, STATIC_TIME, self.text_tags)]+ if self.first is not None:+ n = self.frames * self.per_frame+ static.append((self._video_embed(self.cond_rows[n:n + self.per_frame]), self.first, CLEAN_LEVEL, TAG_VIDEO))+ self._forward(static, (), ("static", 0))+ self._forward([(self.audio_embed, self.audio, CLEAN_LEVEL, TAG_AUDIO)], [("static", 0)], ("audio", 0))++ def chunk(self, c, f0, f1):+ """Render latent frames ``f0:f1`` (chunk ``c``); returns them ``[1, 24, f1 - f0, h, w]``."""+ rows = (f0 * self.per_frame, f1 * self.per_frame)+ structure = (self.structure_start + rows[0], self.structure_start + rows[1])+ target = (self.video_start + rows[0], self.video_start + rows[1])+ self._forward([(self._video_embed(self.cond_rows[rows[0]:rows[1]]), structure, CLEAN_LEVEL, TAG_VIDEO)],+ [("static", 0)], ("structure", c))+ window = range(max(0, c - WINDOW + 1), c + 1)+ history = [("static", 0), ("audio", 0), *(("structure", j) for j in window),+ *(("clean", j) for j in window if j < c)]++ shape = (1, 24, f1 - f0, self.height, self.width)+ draw = lambda: torch.randn(shape, generator=self.generator, device=self.device, dtype=torch.float32) # noqa: E731+ sigmas = shifted_sigmas(STEPS)+ current = draw()+ for i in range(STEPS):+ sigma, sigma_next = float(sigmas[i]), float(sigmas[i + 1])+ embed = self._video_embed(patchify_video(current, self.dm.patch_size))+ velocity = self._forward([(embed, target, 1.0 - sigma, TAG_VIDEO)], history, None, sigma=sigma)+ velocity = unpatchify_video(velocity, f1 - f0, self.height // 2, self.width // 2, 24,+ self.dm.patch_size).float()+ estimate = current + sigma * velocity+ current = estimate if i == STEPS - 1 else (1.0 - sigma_next) * estimate + sigma_next * draw()+ written = CLEAN_LEVEL * current + (1.0 - CLEAN_LEVEL) * draw()+ self._forward([(self._video_embed(patchify_video(written, self.dm.patch_size)), target, CLEAN_LEVEL,+ TAG_VIDEO)], history, ("clean", c))+ return current+++class SolarRendererCausalSampler:+ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "model": ("MODEL", {"tooltip": "MiniMax-H3 with the two causal SolarRenderer LoRAs loaded "+ "(solarrenderer_causal_4step_lora, then solarrenderer_causal_control_lora)."}),+ "positive": ("CONDITIONING", {"tooltip": "From SolarRenderer Structure to Video, at any length."}),+ "latent": ("LATENT",),+ "seed": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFFFFFFFFFFFF}),+ "cache": (["auto", "gpu", "system memory"],+ {"tooltip": "Where the six-chunk key/value cache lives (about 60 GB at 1344x768). 'system "+ "memory' lets a smaller GPU render long clips, more slowly; 'auto' picks "+ "the GPU when it has room."}),+ }+ }++ RETURN_TYPES = ("LATENT",)+ FUNCTION = "sample"+ CATEGORY = CATEGORY+ DESCRIPTION = ("Renders the clip chunk by chunk with the causal LoRA pair: any length, the memory of a six-chunk "+ "window. Split the result with Separate AV Latent and decode the video with VAE Decode.")++ @torch.no_grad()+ def sample(self, model, positive, latent, seed, cache):+ streams = latent["samples"]+ shapes = [t.shape for t in streams.tensors] if getattr(streams, "is_nested", False) else None+ if shapes is None or len(shapes) < 2:+ raise ValueError("SolarRenderer Causal Sampler takes the latent of SolarRenderer Structure to Video")+ mm.load_models_gpu([model])+ device, dtype = model.load_device, model.model.get_dtype_inference()+ dm = model.model.diffusion_model+ context, extra = positive[0][0], positive[0][1]++ _, _, frames, height, width = shapes[0]+ rows = (height // 2) * (width // 2)+ need = rows * CHUNK * (2 * WINDOW) * 2 * dm.blocks[0].attn.heads * dm.blocks[0].attn.head_dim * 2 * len(dm.blocks)+ on_gpu = cache == "gpu" or (cache == "auto" and mm.get_free_memory(device) > need * 1.3)+ run = CausalRun(dm, device, dtype, context, extra, shapes, seed, device if on_gpu else torch.device("cpu"))+ chunks = [(f, min(f + CHUNK, frames)) for f in range(0, frames, CHUNK)]+ logging.info(f"SolarRenderer: {len(chunks)} chunks, cache on {'the GPU' if on_gpu else 'system memory'} "+ f"(up to {need / 2**30:.0f} GB)")++ callback = latent_preview.prepare_callback(model, len(chunks))+ run.prefill()+ clip = torch.zeros(shapes[0], dtype=torch.float32)+ for c, (f0, f1) in enumerate(chunks):+ mm.throw_exception_if_processing_interrupted()+ rendered = run.chunk(c, f0, f1)+ clip[:, :, f0:f1] = rendered.cpu()+ try:+ callback(c, rendered, None, len(chunks))+ except Exception as exc: # noqa: BLE001 - a preview never stops the render+ logging.debug(f"SolarRenderer: no preview for chunk {c}: {exc}")+ del run+ audio = _silence(shapes[1][-1]).to(clip.dtype)+ out = latent.copy()+ out["samples"] = comfy.nested_tensor.NestedTensor((clip.to(mm.intermediate_device()), audio))+ return (out,)diff --git a/comfyui/nodes.py b/comfyui/nodes.pynew file mode 100644index 0000000..703c794--- /dev/null+++ b/comfyui/nodes.py@@ -0,0 +1,474 @@+"""SolarRenderer nodes for ComfyUI.++They run the released renderer (scripts/render.py) on ComfyUI's own MiniMax-H3 (Comfy-Org/MiniMax-H3, the Ref2VA+transformer):++* SolarRendererLoraLoader - a released SolarRenderer LoRA as it is on the Hub, each module patched onto its part of+ ComfyUI's fused weights (q, k and v onto their thirds of attn.qkv_proj, the two halves of the feed-forward input+ onto theirs of mlp.fc1);+* SolarRendererConditioning - the clip's inputs as training encoded them: the structure video laid over every target+ frame and the first frame over frame 0, both as frame-aligned keyframes, and the prompt read by H3's Qwen3-VL with+ the two videos shown to it as <Video 1> and <Video 2> at 2 fps;+* SolarRendererModel - the soundtrack held at H3's encoded silence through sampling, as the renderer holds it (it+ never generates sound, and a generated one would sit in every attention);+* SolarRendererSigmas - the four-step grid (shift 12) the four-step LoRA was trained on; sample it with the "lcm"+ sampler, which takes the clean estimate at every step and noises it afresh, as the renderer does;+* SolarRendererPrompt - the six-part prompt assembled from its free parts with the fixed sentences training used+ (skills/solarrenderer-caption);+* SolarRendererWebCapture - a web page's 3D canvas (three.js, any WebGL) recorded as a structure video, with its+ sound, optionally played by a key script and drawn as a rough early build (web_capture.py).+"""++import importlib.util+import json+import logging+import os+import re++import torch++import comfy.lora+import comfy.patcher_extension+import comfy.utils+import folder_paths+from comfy.ldm.minimax.model import time_shift_sigma+from comfy_extras.nodes_minimax_h3 import _empty_av_latent++ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+SILENCE = os.path.join(ROOT, "assets", "h3_silence_153_158_170.safetensors")+FPS = 24+LONG, SHOWN_LONG = 362, 158 # past LONG frames, the text encoder sees the first SHOWN_LONG+STILL_FRAMES = 13 # H3 takes no reference video shorter than this; a first frame is shown to it held that long+SHIFT_VIDEO, SHIFT_AUDIO = 12.0, 3.0+CATEGORY = "SolarRenderer"+++# ------------------------------------------------------------------------------------------------- LoRA++_BLOCK = re.compile(r"^(transformer_blocks|token_refiner\.refiner_blocks)\.(\d+)\.(.+)$")+++def lora_patches(lora: dict, inner: int, ffn: int) -> tuple[dict, dict]:+ """A SolarRenderer LoRA (diffusers PEFT names) as ComfyUI LoRA entries and the weights they patch.++ Returns (state dict, key map) for comfy.lora.load_lora. A key map entry may name a slice of a fused weight,+ (key, (dim, offset, size)), so nothing is stacked or padded: q, k, v land on rows [0, inner), [inner, 2 inner),+ [2 inner, 3 inner) of qkv_proj, and the feed-forward input, [value; gate] in diffusers, on rows [ffn, 2 ffn) and+ [0, ffn) of fc1, which ComfyUI holds as [gate; value]."""+ entries, key_map = {}, {}+ for key in lora:+ if not key.endswith(".lora_A.weight"):+ continue+ base = key[: -len(".lora_A.weight")]+ match = _BLOCK.match(base)+ if match is None:+ raise ValueError(f"{key}: not a MiniMax-H3 transformer block or token refiner module")+ prefix, index, module = match.groups()+ root = "diffusion_model." + ("blocks" if prefix == "transformer_blocks" else "token_refiner.blocks") + f".{index}"+ a, b = lora[key], lora[base + ".lora_B.weight"]+ if module in ("attn.to_q", "attn.to_k", "attn.to_v"):+ third = "qkv".index(module[-1])+ entries[base + ".lora_A.weight"], entries[base + ".lora_B.weight"] = a, b+ key_map[base] = (f"{root}.attn.qkv_proj.weight", (0, third * inner, inner))+ elif module == "ff.net.0.proj":+ half = b.shape[0] // 2+ for part, rows, start in (("value", b[:half], ffn), ("gate", b[half:], 0)):+ entries[f"{base}.{part}.lora_A.weight"], entries[f"{base}.{part}.lora_B.weight"] = a, rows+ key_map[f"{base}.{part}"] = (f"{root}.mlp.fc1.weight", (0, start, ffn))+ elif module in ("attn.to_out.0", "ff.net.2"):+ entries[base + ".lora_A.weight"], entries[base + ".lora_B.weight"] = a, b+ key_map[base] = f"{root}." + ("attn.out_proj.weight" if module == "attn.to_out.0" else "mlp.fc2.weight")+ else:+ raise ValueError(f"{key}: no ComfyUI counterpart for {module}")+ return entries, key_map+++class SolarRendererLoraLoader:+ @classmethod+ def INPUT_TYPES(cls):+ return {"required": {+ "model": ("MODEL",),+ "lora_name": (folder_paths.get_filename_list("loras"),+ {"tooltip": "A released SolarRenderer LoRA, as downloaded from the Hub "+ "(solarrenderer_4step_lora / solarrenderer_control_lora)."}),+ "strength": ("FLOAT", {"default": 1.0, "min": -4.0, "max": 4.0, "step": 0.05}),+ }}++ RETURN_TYPES = ("MODEL",)+ FUNCTION = "load"+ CATEGORY = CATEGORY++ def load(self, model, lora_name, strength):+ lora = comfy.utils.load_torch_file(folder_paths.get_full_path_or_raise("loras", lora_name), safe_load=True)+ if not any(k.startswith("transformer_blocks.") for k in lora): # already in ComfyUI's own names+ key_map = comfy.lora.model_lora_keys_unet(model.model, {})+ patches = comfy.lora.load_lora(lora, key_map)+ else:+ dm = model.model.diffusion_model+ inner = dm.blocks[0].attn.out_proj.weight.shape[1]+ ffn = dm.blocks[0].mlp.fc2.weight.shape[1]+ entries, key_map = lora_patches(lora, inner, ffn)+ patches = comfy.lora.load_lora(entries, key_map)+ model = model.clone()+ missed = set(patches) - set(model.add_patches(patches, strength))+ if missed:+ raise ValueError(f"{lora_name}: {len(missed)} modules found no weight in this model")+ logging.info(f"SolarRenderer: {lora_name} patched {len(patches)} weights")+ return (model,)+++# ------------------------------------------------------------------------------------------------- conditioning++def _fit(frames, width, height):+ """[T, H, W, C] -> [T, height, width, 3]: cut to the canvas's aspect at the centre and LANCZOS-resized, as the+ renderer lays a structure video or a first frame over the target's canvas."""+ samples = frames[..., :3].movedim(-1, 1)+ if tuple(samples.shape[-2:]) != (height, width):+ samples = comfy.utils.common_upscale(samples, width, height, "lanczos", "center")+ return samples.movedim(1, -1).clamp(0.0, 1.0)+++def _shown(frames):+ """A reference as H3's Qwen3-VL reads it: every 12th of the 24 fps frames, timestamped at 2 fps."""+ index = list(range(0, frames.shape[0], FPS // 2))+ return {"type": "video", "data": frames[index], "timestamps": [i / 2.0 for i in range(len(index))]}+++class SolarRendererConditioning:+ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "clip": ("CLIP",),+ "vae": ("VAE",),+ "structure": ("IMAGE", {"tooltip": "The structure video at 24 fps: a grey box, a segmentation, "+ "skeletons, depth, a game's frames, a sketch. The render follows "+ "it frame for frame."}),+ "prompt": ("STRING", {"multiline": True, "dynamic_prompts": True,+ "tooltip": "The six-part prompt (SolarRenderer Prompt builds it): <Video 1> is "+ "the structure video, <Video 2> the first frame."}),+ "width": ("INT", {"default": 1344, "min": 256, "max": 2048, "step": 32}),+ "height": ("INT", {"default": 768, "min": 256, "max": 2048, "step": 32}),+ "length": ("INT", {"default": 158, "min": 22, "max": 3609, "step": 1,+ "tooltip": "Frames to render at 24 fps, at most the structure video's; snapped down "+ "to the 17n + 5 frames the video VAE takes. Trained at 158 (6.6 s); "+ "past 362, render with SolarRenderer Causal Sampler."}),+ },+ "optional": {+ "first_frame": ("IMAGE", {"tooltip": "The look of the shot: its first frame, already in that look."}),+ "structure_vae": ("VAE", {"tooltip": "Encode the structure video with this one instead (taeh3: ten "+ "times faster, a little less exact); the first frame keeps vae."}),+ },+ }++ RETURN_TYPES = ("CONDITIONING", "LATENT")+ RETURN_NAMES = ("positive", "latent")+ FUNCTION = "encode"+ CATEGORY = CATEGORY++ def encode(self, clip, vae, structure, prompt, width, height, length, first_frame=None, structure_vae=None):+ frames = min(int(length), int(structure.shape[0]))+ if frames < 22:+ raise ValueError(f"SolarRenderer needs at least 22 frames of structure video, got {frames}")+ while frames % 17 != 5:+ frames -= 1+ video = _fit(structure[:frames], width, height)+ # a long clip (the causal sampler's) is described to the text encoder by its opening, as the renderer streams it+ items = [_shown(video if frames <= LONG else video[:SHOWN_LONG])]+ still = None+ if first_frame is not None:+ still = _fit(first_frame[:1], width, height)+ items.append(_shown(still.repeat(STILL_FRAMES, 1, 1, 1)))+ positive = clip.encode_from_tokens_scheduled(clip.tokenize(prompt, minimax_ref_items=items))+ # both laid over the target from its frame 0: the structure over every frame, the first frame over the first+ keyframes = [{"resolved_frame_index": 0, "latent": (structure_vae or vae).encode(video)}]+ if still is not None:+ keyframes.append({"resolved_frame_index": 0, "latent": vae.encode(still)})+ positive = [[c[0], {**c[1], "minimax_keyframes": keyframes}] for c in positive]+ latent, _ = _empty_av_latent(width, height, frames)+ return (positive, latent)+++# ------------------------------------------------------------------------------------------------- sampling++class _SilentSoundtrack:+ """Holds the audio stream at H3's encoded silence, noised to the step's audio time with one fixed draw, before+ every evaluation: the renderer's soundtrack, which it never samples."""++ def __init__(self, silence, seed):+ self.silence, self.seed, self.noise = silence, seed, None++ def __call__(self, executor, x, timestep, context, transformer_options={}, **kwargs):+ video, audio = x[0], x[1]+ t = audio.shape[-1]+ if self.silence.shape[-1] < t:+ raise ValueError(f"the held silence covers 170 frames ({self.silence.shape[-1]} audio latents); "+ f"this clip needs {t}")+ clean = self.silence[..., :t].to(audio.device, torch.float32)+ if self.noise is None or self.noise.shape != clean.shape:+ generator = torch.Generator("cpu").manual_seed(self.seed)+ self.noise = torch.randn(clean.shape, generator=generator, dtype=torch.float32)+ sigma_v = (timestep.flatten()[0] / 1000.0).float().clamp(min=1e-6)+ shift_v = float(transformer_options.get("minimax_h3_sigma_shift_video", SHIFT_VIDEO))+ shift_a = float(transformer_options.get("minimax_h3_sigma_shift_audio", SHIFT_AUDIO))+ sigma_a = float(time_shift_sigma(sigma_v, shift_v, shift_a))+ held = ((1.0 - sigma_a) * clean + sigma_a * self.noise.to(clean.device)).to(audio.dtype)+ return executor([video, held], timestep, context, transformer_options, **kwargs)+++class SolarRendererModel:+ @classmethod+ def INPUT_TYPES(cls):+ return {"required": {"model": ("MODEL",),+ "seed": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFFFFFFFFFFFF,+ "tooltip": "The draw that noises the held silence."})}}++ RETURN_TYPES = ("MODEL",)+ FUNCTION = "patch"+ CATEGORY = CATEGORY++ def patch(self, model, seed):+ silence = comfy.utils.load_torch_file(SILENCE)["silence_170f"].float() # [channels 2, 32, T]+ silence = silence.permute(1, 0, 2).unsqueeze(0) # ComfyUI's audio latent is [1, 32, channels, T]+ model = model.clone()+ model.add_wrapper(comfy.patcher_extension.WrappersMP.DIFFUSION_MODEL, _SilentSoundtrack(silence, seed))+ return (model,)+++def shifted_sigmas(steps: int, shift: float = SHIFT_VIDEO):+ base = torch.linspace(1.0, 0.0, steps + 1, dtype=torch.float32)+ return shift * base / (1.0 + (shift - 1.0) * base)+++class SolarRendererSigmas:+ @classmethod+ def INPUT_TYPES(cls):+ return {"required": {"steps": ("INT", {"default": 4, "min": 1, "max": 50,+ "tooltip": "Model evaluations; the four-step LoRA was trained for 4."})}}++ RETURN_TYPES = ("SIGMAS",)+ FUNCTION = "sigmas"+ CATEGORY = CATEGORY++ def sigmas(self, steps):+ return (shifted_sigmas(steps),)+++# ------------------------------------------------------------------------------------------------- speed++def _fa4():+ try:+ from flash_attn.cute import flash_attn_func # FlashAttention-4 (pip install flash-attn-4)+ return flash_attn_func+ except Exception: # noqa: BLE001 - not installed, or built for another torch+ return None+++class _FastAttention:+ """The DiT's attention on another kernel: FlashAttention-4 when it is installed, otherwise PyTorch's cuDNN+ attention. Which is fastest depends on the GPU and the software on it; the output is the same."""++ def __init__(self, backend):+ self.backend, self.fa4 = backend, _fa4() if backend in ("auto", "flash_attn_4") else None++ def __call__(self, func, q, k, v, heads, mask=None, skip_reshape=False, **kwargs):+ if mask is not None or not skip_reshape or q.dtype not in (torch.bfloat16, torch.float16) or not q.is_cuda:+ return func(q, k, v, heads, mask=mask, skip_reshape=skip_reshape, **kwargs)+ b, h, s, d = q.shape # [B, heads, tokens, head_dim]+ if self.fa4 is not None:+ out = self.fa4(*(x.transpose(1, 2) for x in (q, k, v))) # FA4 takes [B, tokens, heads, head_dim]+ out = out[0] if isinstance(out, tuple) else out+ return out.reshape(b, s, h * d)+ from torch.nn.attention import SDPBackend, sdpa_kernel++ q, k, v = (x.contiguous() for x in (q, k, v)) # cuDNN takes no strided views of the fused qkv+ order = [SDPBackend.CUDNN_ATTENTION, SDPBackend.FLASH_ATTENTION, SDPBackend.EFFICIENT_ATTENTION, SDPBackend.MATH]+ with sdpa_kernel(order, set_priority=True): # ComfyUI puts flash first; cuDNN first is the point here+ out = torch.nn.functional.scaled_dot_product_attention(q, k, v)+ return out.transpose(1, 2).reshape(b, s, h * d)+++class SolarRendererFastAttention:+ @classmethod+ def INPUT_TYPES(cls):+ return {"required": {"model": ("MODEL",),+ "backend": (["auto", "flash_attn_4", "cudnn"],+ {"tooltip": "auto: FlashAttention-4 if installed (pip install flash-attn-4), "+ "else PyTorch's cuDNN attention."})}}++ RETURN_TYPES = ("MODEL",)+ FUNCTION = "patch"+ CATEGORY = CATEGORY++ def patch(self, model, backend):+ attention = _FastAttention(backend)+ if backend == "flash_attn_4" and attention.fa4 is None:+ raise RuntimeError("FlashAttention-4 is not installed: pip install flash-attn-4")+ logging.info(f"SolarRenderer: attention on {'FlashAttention-4' if attention.fa4 else 'cuDNN'}")+ model = model.clone()+ model.model_options.setdefault("transformer_options", {})["optimized_attention_override"] = attention+ return (model,)+++# ------------------------------------------------------------------------------------------------- prompt++def _caption_helpers():+ spec = importlib.util.spec_from_file_location(+ "solarrenderer_conditions", os.path.join(ROOT, "skills", "solarrenderer-caption", "conditions.py"))+ module = importlib.util.module_from_spec(spec)+ spec.loader.exec_module(module)+ return module+++class SolarRendererPrompt:+ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "structure_type": (["scene_graybox", "semantic", "scene_whitebox", "mask_skeleton", "smpl_mesh",+ "near_depth", "custom"],+ {"tooltip": "What the structure video is. The six trained types use the sentences "+ "training used; anything else is 'custom'."}),+ "with_first_frame": ("BOOLEAN", {"default": True}),+ "summary": ("STRING", {"multiline": True,+ "tooltip": "One paragraph: who does what, and how the camera moves."}),+ "detailed_description": ("STRING", {"multiline": True,+ "tooltip": "350-500 words: the look first (style, light, weather), "+ "then [Shot 1] and what is seen, in order."}),+ "soundscape": ("STRING", {"multiline": True, "default": "N/A"}),+ },+ "optional": {+ "custom_looks_like": ("STRING", {"default": "", "tooltip": "For 'custom': what the structure video "+ "looks like, e.g. 'a black pencil line sketch of the scene on white paper'."}),+ "custom_not_shown": ("STRING", {"default": "", "tooltip": "For 'custom': what of its look must not "+ "appear, e.g. 'the pencil lines and white paper'."}),+ },+ }++ RETURN_TYPES = ("STRING",)+ RETURN_NAMES = ("prompt",)+ FUNCTION = "build"+ CATEGORY = CATEGORY++ def build(self, structure_type, with_first_frame, summary, detailed_description, soundscape,+ custom_looks_like="", custom_not_shown=""):+ helpers = _caption_helpers()+ if structure_type == "custom":+ if not custom_looks_like.strip() or not custom_not_shown.strip():+ raise ValueError("a custom structure needs custom_looks_like and custom_not_shown")+ condition = helpers.custom_condition(custom_looks_like.strip(), custom_not_shown.strip())+ else:+ condition = structure_type+ free = {"summary": summary, "detailed_description": detailed_description, "overall_soundscape": soundscape}+ words = len(detailed_description.split())+ if not 350 <= words <= 500:+ logging.warning(f"SolarRenderer Prompt: detailed_description has {words} words; it renders best with "+ f"350-500")+ return (helpers.assemble(free, "full" if with_first_frame else "structure", condition),)+++# ------------------------------------------------------------------------------------------------- web input++def _decode_sound(path):+ """A WebAudio recording (.webm) as ComfyUI audio: {"waveform": [1, channels, samples], "sample_rate": rate}."""+ import av+ import numpy as np++ chunks, rate = [], 48000+ with av.open(path) as box:+ stream = box.streams.audio[0]+ rate = stream.rate or rate+ for frame in box.decode(stream):+ array = frame.to_ndarray()+ if array.dtype.kind in "iu":+ array = array.astype(np.float32) / float(np.iinfo(array.dtype).max)+ if frame.format.is_packed:+ array = array.reshape(-1, len(frame.layout.channels)).T+ chunks.append(array.astype(np.float32))+ waveform = torch.from_numpy(np.concatenate(chunks, axis=1)) if chunks else torch.zeros(2, 1)+ return {"waveform": waveform.unsqueeze(0), "sample_rate": int(rate)}+++class SolarRendererWebCapture:+ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "url": ("STRING", {"default": "", "tooltip": "A page drawing a 3D canvas: three.js, Babylon, any WebGL "+ "(http(s):// or file://)."}),+ "frames": ("INT", {"default": 158, "min": 22, "max": 2400, "tooltip": "Frames to record at 24 fps."}),+ "width": ("INT", {"default": 1344, "min": 256, "max": 2048, "step": 32}),+ "height": ("INT", {"default": 768, "min": 256, "max": 2048, "step": 32}),+ },+ "optional": {+ "keys": ("STRING", {"multiline": True, "default": "",+ "tooltip": "What to press, one action per line: '1.5:KeyW:2' (W held 2 s), "+ "'3:down:ShiftLeft' / '4:up:ShiftLeft', '5:mouse:200:0' (look right), "+ "'6:click'."}),+ "click": ("STRING", {"default": "", "tooltip": "The selector of a start button to press first."}),+ "setup": ("STRING", {"default": "", "tooltip": "JavaScript run once the page has started."}),+ "warm": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 30.0, "step": 0.5,+ "tooltip": "Seconds the page runs before the first frame."}),+ "frame_exact": ("BOOLEAN", {"default": True, "tooltip": "Run the page on a virtual clock, 1/24 s per "+ "frame, so a slow machine still records exactly "+ "24 fps. Off records in real time, with the "+ "page's sound."}),+ },+ }++ RETURN_TYPES = ("IMAGE", "AUDIO")+ RETURN_NAMES = ("frames", "sound")+ FUNCTION = "capture"+ CATEGORY = CATEGORY++ def capture(self, url, frames, width, height, keys="", click="", setup="", warm=1.0, frame_exact=True):+ import subprocess+ import sys+ import tempfile++ import numpy as np++ if not url.strip():+ raise ValueError("SolarRenderer Web Capture needs a url")+ try:+ import playwright # noqa: F401+ except ImportError as error:+ raise RuntimeError("SolarRenderer Web Capture records the page in headless Chromium: "+ "pip install playwright && python -m playwright install chromium") from error+ with tempfile.TemporaryDirectory() as work:+ out = os.path.join(work, "capture")+ command = [sys.executable, os.path.join(os.path.dirname(os.path.abspath(__file__)), "web_capture.py"),+ "--url", url.strip(), "--out", out, "--frames", str(frames), "--width", str(width),+ "--height", str(height), "--keys", keys, "--click", click, "--setup", setup,+ "--warm", str(warm)] + (["--exact"] if frame_exact else [])+ done = subprocess.run(command, capture_output=True, text=True)+ if done.returncode != 0:+ raise RuntimeError(f"web capture failed: {done.stderr.strip()[-2000:]}")+ report = json.loads(done.stdout.strip().splitlines()[-1])+ if not frame_exact and report["real_time"] < 0.9:+ logging.warning(f"SolarRenderer Web Capture grabbed at {report['real_time']}x real time: the page ran "+ f"ahead of its frames, so the clip plays fast. Turn frame_exact on, or record smaller.")+ images = torch.from_numpy(np.load(f"{out}.npy")).float() / 255.0+ sound = _decode_sound(f"{out}.webm") if os.path.exists(f"{out}.webm") else \+ {"waveform": torch.zeros(1, 2, 1), "sample_rate": 48000}+ return (images, sound)+++NODE_CLASS_MAPPINGS = {+ "SolarRendererLoraLoader": SolarRendererLoraLoader,+ "SolarRendererConditioning": SolarRendererConditioning,+ "SolarRendererModel": SolarRendererModel,+ "SolarRendererSigmas": SolarRendererSigmas,+ "SolarRendererFastAttention": SolarRendererFastAttention,+ "SolarRendererPrompt": SolarRendererPrompt,+ "SolarRendererWebCapture": SolarRendererWebCapture,+}+NODE_DISPLAY_NAME_MAPPINGS = {+ "SolarRendererLoraLoader": "SolarRenderer LoRA Loader",+ "SolarRendererConditioning": "SolarRenderer Structure to Video",+ "SolarRendererModel": "SolarRenderer Model (silent soundtrack)",+ "SolarRendererSigmas": "SolarRenderer Four-Step Sigmas",+ "SolarRendererFastAttention": "SolarRenderer Fast Attention",+ "SolarRendererPrompt": "SolarRenderer Prompt",+ "SolarRendererWebCapture": "SolarRenderer Web Capture (three.js / WebGL page)",+}diff --git a/comfyui/web/index.html b/comfyui/web/index.htmlnew file mode 100644index 0000000..c400b5e--- /dev/null+++ b/comfyui/web/index.html@@ -0,0 +1,365 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="utf-8">+<meta name="viewport" content="width=device-width, initial-scale=1">+<title>SolarRenderer</title>+<link rel="icon" href="data:,">+<style>+ :root { --ivory: #ece7da; --dim: rgba(236,231,218,.62); --faint: rgba(236,231,218,.18); --gold: #ffd678;+ --W: min(58vw, calc((100vh - 420px) * 1.75)); }+ * { box-sizing: border-box; }+ html, body { margin: 0; min-height: 100%; color: var(--ivory);+ font-family: "Avenir Next", "Avenir", "Helvetica Neue", "PingFang SC", Arial, sans-serif;+ background: radial-gradient(ellipse at 50% 45%, #1d2a44 0%, #161b26 55%, #0e1016 100%) fixed; }+ header { display: flex; align-items: center; gap: 28px; padding: 18px 36px 6px; }+ header img { height: 58px; }+ .tag { font-size: 22px; letter-spacing: .02em; opacity: .92; }+ .clock { margin-left: auto; text-align: right; line-height: 1; min-width: 220px; }+ .clock .num { font-size: 54px; font-weight: 600; font-variant-numeric: tabular-nums; }+ .clock .unit { font-size: 20px; margin-left: 6px; color: var(--dim); }+ .clock .lab { font-size: 12px; letter-spacing: .22em; color: var(--gold); margin-top: 6px; text-transform: uppercase; }+ main { display: flex; justify-content: center; align-items: flex-start; gap: 28px; padding: 14px 36px 30px; }+ .label { font-size: 13px; letter-spacing: .22em; color: var(--dim); margin: 0 0 8px 2px; display: flex; gap: 14px; }+ .label b { color: var(--ivory); font-weight: 600; }+ .frame { position: relative; width: 100%; aspect-ratio: 1344 / 768; border-radius: 12px; overflow: hidden; background: #000;+ box-shadow: 0 18px 50px rgba(0,0,0,.45), 0 0 0 1px rgba(236,231,218,.12); }+ .frame video, .frame img.fill { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; }+ #left { width: calc(var(--W) * .42); }+ #right { width: var(--W); }+ .drop { cursor: pointer; }+ .drop.over { box-shadow: 0 0 0 2px var(--gold), 0 18px 50px rgba(0,0,0,.45); }+ .hint { position: absolute; inset: 0; display: flex; flex-direction: column; gap: 10px; align-items: center;+ justify-content: center; text-align: center; padding: 18px; font-size: 15px; letter-spacing: .04em; color: var(--dim);+ background: rgba(8,10,16,.3); }+ .hint span.pill { padding: 10px 22px; border: 1px solid rgba(236,231,218,.5); border-radius: 40px;+ background: rgba(0,0,0,.35); color: var(--ivory); font-size: 18px; }+ .inset { position: absolute; right: 10px; bottom: 10px; width: 34%; border-radius: 6px; overflow: hidden; display: none;+ box-shadow: 0 0 0 1px rgba(236,231,218,.45), 0 6px 18px rgba(0,0,0,.5); cursor: pointer; background: #000; }+ .inset img { display: block; width: 100%; aspect-ratio: 1344 / 768; object-fit: cover; }+ .inset div { position: absolute; left: 6px; top: 5px; font-size: 9px; letter-spacing: .18em; color: var(--ivory);+ text-shadow: 0 1px 3px #000; }+ .badge { position: absolute; top: 12px; right: 14px; font-size: 12px; letter-spacing: .2em; color: var(--gold);+ background: rgba(0,0,0,.45); padding: 5px 10px; border-radius: 20px; display: none; }+ .badge.on::before { content: ""; display: inline-block; width: 7px; height: 7px; border-radius: 50%; background: #ff5a4f;+ margin-right: 7px; vertical-align: 1px; animation: blink 1s infinite; }+ @keyframes blink { 50% { opacity: .2; } }+ .progress { height: 3px; margin-top: 10px; border-radius: 3px; background: var(--faint); overflow: hidden; }+ .progress i { display: block; height: 100%; width: 0; background: var(--gold); transition: width .4s;+ box-shadow: 0 0 10px rgba(255,214,120,.7); }+ .row { display: flex; gap: 10px; margin-top: 12px; flex-wrap: wrap; align-items: center; }+ button, .btn { background: transparent; color: var(--ivory); border: 1px solid rgba(236,231,218,.3); border-radius: 18px;+ padding: 6px 14px; font: inherit; font-size: 13px; cursor: pointer; }+ button:hover, .btn:hover { border-color: var(--ivory); }+ button.on { color: #111; background: var(--gold); border-color: var(--gold); }+ button:disabled { opacity: .35; cursor: not-allowed; }+ #render { margin-left: auto; padding: 10px 34px; font-size: 16px; font-weight: 600; letter-spacing: .08em; color: #111;+ background: var(--gold); border-color: var(--gold); box-shadow: 0 0 22px rgba(255,214,120,.35); }+ #render:disabled { box-shadow: none; }+ .small { font-size: 12px; color: var(--dim); }+ .small b { color: var(--ivory); font-weight: 600; }+ textarea { width: 100%; height: 148px; margin-top: 8px; resize: vertical; padding: 12px 14px; border-radius: 10px;+ background: rgba(0,0,0,.28); color: var(--ivory); border: 1px solid var(--faint); font: inherit; font-size: 13px;+ line-height: 1.55; }+ textarea:focus { outline: none; border-color: rgba(255,214,120,.55); }+ input[type=number] { width: 120px; background: rgba(0,0,0,.28); color: var(--ivory); border: 1px solid var(--faint);+ border-radius: 18px; padding: 6px 12px; font: inherit; font-size: 13px; }+ .cards { display: flex; gap: 12px; flex-wrap: wrap; }+ .card { width: 132px; cursor: pointer; opacity: .6; transition: opacity .2s; }+ .card:hover { opacity: .9; }+ .card.on { opacity: 1; }+ .card img { width: 100%; aspect-ratio: 1344 / 768; object-fit: cover; border-radius: 6px; display: block;+ box-shadow: 0 0 0 1px rgba(236,231,218,.2); }+ .card.on img { box-shadow: 0 0 0 2px var(--gold); }+ .card div { font-size: 11px; color: var(--dim); margin-top: 5px; line-height: 1.35; }+ .msg { min-height: 18px; margin-top: 10px; font-size: 13px; color: var(--dim); }+ .msg.err { color: #ff8a80; }+ a { color: var(--gold); }+</style>+</head>+<body>+<header>+ <img src="/solarrenderer/static/wordmark.png" alt="SolarRenderer">+ <div class="tag">Any structure in. Any world out.</div>+ <div class="clock"><div><span class="num" id="clock">--</span><span class="unit">s</span></div>+ <div class="lab" id="stage">ready</div></div>+</header>++<main>+ <div id="left">+ <div class="label"><b>INPUT</b><span id="inlab">structure video</span></div>+ <div class="frame drop" id="drop">+ <video id="structure" muted playsinline loop preload="auto"></video>+ <div class="hint" id="inhint"><span class="pill">Drop a structure video</span>+ <span>a grey box, a segmentation, skeletons, depth, a game's frames, a sketch</span></div>+ <div class="inset" id="inset"><img id="first" alt=""><div>FIRST FRAME</div></div>+ </div>+ <div class="row">+ <label class="btn">Structure video<input type="file" id="pickVideo" accept="video/*" hidden></label>+ <label class="btn">First frame<input type="file" id="pickFirst" accept="image/*" hidden></label>+ <button id="clearFirst" disabled>No first frame</button>+ </div>+ <div class="examples" style="margin-top:26px">+ <div class="label"><b>EXAMPLES</b></div>+ <div class="cards" id="cards"></div>+ </div>+ </div>+ <div id="right">+ <div class="label"><b>OUTPUT</b><span id="outlab">rendered on this machine, four steps</span></div>+ <div class="frame">+ <img class="fill" id="preview" alt="" style="display:none">+ <video id="out" muted playsinline loop preload="auto"></video>+ <div class="hint" id="outhint"><span>Pick an example, or drop your own structure video on the left.</span></div>+ <div class="badge" id="badge"></div>+ </div>+ <div class="progress"><i id="bar"></i></div>+ <div class="controls" style="margin-top:18px">+ <div class="label"><b>PROMPT</b><span id="words"></span>+ <span style="margin-left:auto"><a href="https://github.com/Enderfga/SolarRenderer/blob/main/docs/prompts.md"+ target="_blank">how to write one</a></span></div>+ <textarea id="prompt" spellcheck="false" placeholder="The six-part prompt: what the structure video is, then the look of the render."></textarea>+ <div class="row">+ <span class="small"><b>LENGTH</b></span>+ <span id="lengths"><button data-mode="clip" class="on" title="158 frames, in one pass">6.6 s</button>+ <button data-mode="causal" title="The whole structure video, chunk by chunk with the causal LoRA pair">Whole video</button></span>+ <span class="small" style="margin-left:14px"><b>MODELS</b></span>+ <span id="qualities"></span>+ <span class="small" style="margin-left:14px"><b>SEED</b></span>+ <input type="number" id="seed" min="0" value="0">+ <button id="dice" title="random seed">↻</button>+ <button id="render" disabled>Render</button>+ </div>+ <div class="msg" id="msg"></div>+ </div>+ </div>+</main>++<script>+const $ = id => document.getElementById(id);+const clientId = crypto.randomUUID ? crypto.randomUUID() : String(Math.random()).slice(2);+const FRAMES = 158, FPS = 24;+const MIN_FRAMES = 22, MAX_FRAMES = 3609;+const state = { structure: null, first: null, quality: null, frames: 0, orientation: "landscape", causal: false, info: null,+ running: null, began: 0, timer: null };+const STAGES = { "1": "loading the renderer", "2": "loading the renderer", "3": "loading the renderer",+ "4": "loading the renderer", "5": "loading the renderer", "6": "reading the prompt", "7": "loading the VAE",+ "8": "reading the structure", "9": "reading the structure", "10": "reading the first frame",+ "11": "encoding the inputs", "16": "rendering", "17": "decoding", "18": "decoding", "19": "saving", "20": "saving" };++function say(text, error) { $("msg").textContent = text || ""; $("msg").className = error ? "msg err" : "msg"; }+function words() {+ const n = $("prompt").value.trim().split(/\s+/).filter(Boolean).length;+ $("words").textContent = n ? `${n} words` : "";+}+function ready() {+ $("render").disabled = !!state.running || !state.structure || !state.quality || !$("prompt").value.trim()+ || state.frames < (state.causal ? MIN_FRAMES : FRAMES);+}+function frames() { return state.causal ? Math.min(state.frames, MAX_FRAMES) : FRAMES; }+function lengthNote() {+ if (!state.frames) return;+ if (state.causal) say(state.frames < MIN_FRAMES ? `The structure video needs at least ${MIN_FRAMES} frames.`+ : `${(frames() / FPS).toFixed(1)} s, rendered chunk by chunk with the causal LoRA pair.`, state.frames < MIN_FRAMES);+ else if (state.frames < FRAMES) say(`The structure video needs at least ${FRAMES} frames (${(FRAMES / FPS).toFixed(1)} s at 24 fps); this one has ${state.frames}. Choose "Whole video" for shorter or longer clips.`, true);+ else say(state.frames > FRAMES ? `The first ${FRAMES} frames are rendered; "Whole video" renders all ${(state.frames / FPS).toFixed(1)} s.` : "");+}+function markQualities() { // a model set is usable when its files, and the causal pair for whole videos, are there+ if (!state.info) return;+ for (const b of $("qualities").children) {+ if (!b.dataset || !b.dataset.id) continue;+ const q = state.info.qualities.find(x => x.id === b.dataset.id);+ const missing = state.causal ? q.missing_causal : q.missing;+ b.disabled = missing.length > 0;+ b.title = missing.length ? `Missing: ${missing.join(", ")}` : q.note;+ if (b.disabled && state.quality === q.id) { state.quality = null; b.classList.remove("on"); }+ }+ if (!state.quality) { const ok = [...$("qualities").children].find(b => b.dataset && b.dataset.id && !b.disabled); if (ok) ok.click(); }+}+for (const b of document.querySelectorAll("#lengths button")) b.onclick = () => {+ state.causal = b.dataset.mode === "causal";+ for (const x of document.querySelectorAll("#lengths button")) x.classList.toggle("on", x === b);+ markQualities(); lengthNote(); ready();+};++// ---- inputs --------------------------------------------------------------------------------------------------------+function showStructure(url) {+ const v = $("structure");+ v.src = url; v.play().catch(() => {});+ $("inhint").style.display = "none";+}+$("structure").addEventListener("loadedmetadata", () => {+ const v = $("structure");+ state.frames = Math.floor(v.duration * FPS + 0.5);+ state.orientation = v.videoHeight > v.videoWidth ? "portrait" : "landscape";+ const ratio = state.orientation === "portrait" ? "768 / 1344" : "1344 / 768";+ for (const f of document.querySelectorAll(".frame")) f.style.aspectRatio = ratio;+ $("inlab").textContent = `structure video · ${state.frames} frames`;+ lengthNote(); ready();+});+function showFirst(url) {+ $("first").src = url || ""; $("inset").style.display = url ? "block" : "none";+ $("clearFirst").disabled = !url;+}+async function upload(file) {+ const form = new FormData();+ form.append("image", file, file.name.replace(/[^\w.\-]/g, "_"));+ form.append("type", "input"); form.append("subfolder", "solarrenderer"); form.append("overwrite", "true");+ const r = await fetch("/upload/image", { method: "POST", body: form });+ if (!r.ok) throw new Error(`upload failed (${r.status})`);+ const j = await r.json();+ return j.subfolder ? `${j.subfolder}/${j.name}` : j.name;+}+async function takeVideo(file) {+ try { say("Uploading the structure video…"); state.structure = await upload(file); showStructure(URL.createObjectURL(file)); select(null); }+ catch (e) { say(e.message, true); }+ ready();+}+async function takeFirst(file) {+ try { state.first = await upload(file); showFirst(URL.createObjectURL(file)); say(""); }+ catch (e) { say(e.message, true); }+}+$("pickVideo").onchange = e => e.target.files[0] && takeVideo(e.target.files[0]);+$("pickFirst").onchange = e => e.target.files[0] && takeFirst(e.target.files[0]);+$("inset").onclick = e => { e.stopPropagation(); $("pickFirst").click(); };+$("clearFirst").onclick = () => { state.first = null; showFirst(null); };+const drop = $("drop");+drop.onclick = () => $("pickVideo").click();+drop.ondragover = e => { e.preventDefault(); drop.classList.add("over"); };+drop.ondragleave = () => drop.classList.remove("over");+drop.ondrop = e => {+ e.preventDefault(); drop.classList.remove("over");+ for (const f of e.dataTransfer.files) (f.type.startsWith("image/") ? takeFirst : takeVideo)(f);+};+$("prompt").oninput = () => { words(); ready(); };+$("dice").onclick = () => { $("seed").value = Math.floor(Math.random() * 2 ** 31); };++function select(id) { for (const c of document.querySelectorAll(".card")) c.classList.toggle("on", c.dataset.id === id); }+async function useExample(ex) {+ select(ex.id); say("Loading the example…");+ const r = await fetch(`/solarrenderer/api/example/${ex.id}`, { method: "POST" });+ const j = await r.json();+ state.structure = j.structure; state.first = j.first || null;+ showStructure(`/solarrenderer/api/example/${ex.id}/structure.mp4`);+ showFirst(j.first ? `/solarrenderer/api/example/${ex.id}/first.png` : null);+ $("prompt").value = j.prompt; words(); say(""); ready();+}++// ---- models and examples -------------------------------------------------------------------------------------------+async function load() {+ const info = state.info = await (await fetch("/solarrenderer/api/info")).json();+ const box = $("qualities");+ for (const q of info.qualities) {+ const b = document.createElement("button");+ b.textContent = q.label; b.dataset.id = q.id;+ b.title = q.missing.length ? `Missing: ${q.missing.join(", ")}` : q.note;+ b.disabled = q.missing.length > 0;+ b.onclick = () => { state.quality = q.id; for (const x of box.children) x.classList.toggle("on", x === b); ready(); };+ box.appendChild(b); box.appendChild(document.createTextNode(" "));+ }+ const usable = info.qualities.filter(q => !q.missing.length);+ const pick = usable.find(q => q.id === "full") || usable[0];+ if (pick) [...box.children].find(x => x.dataset && x.dataset.id === pick.id).click();+ else say("No complete model set found; see the README for the files to download. Hover a button to see what is missing.", true);+ for (const ex of info.examples) {+ const c = document.createElement("div");+ c.className = "card"; c.dataset.id = ex.id;+ c.innerHTML = `<img src="/solarrenderer/api/example/${ex.id}/${ex.first ? "first.png" : "preview.gif"}" alt=""><div></div>`;+ c.querySelector("div").textContent = ex.title;+ c.onclick = () => useExample(ex);+ $("cards").appendChild(c);+ }+}++// ---- rendering -----------------------------------------------------------------------------------------------------+function tick() { $("clock").textContent = Math.round((performance.now() - state.began) / 1000); }+function stage(text, fraction) {+ $("stage").textContent = text;+ if (fraction !== undefined) $("bar").style.width = `${Math.round(fraction * 100)}%`;+}+function finish(text, error) {+ clearInterval(state.timer); state.running = null;+ $("badge").style.display = "none"; stage(text);+ if (error) say(error, true);+ ready();+}+$("render").onclick = async () => {+ say(""); $("render").disabled = true;+ const body = { quality: state.quality, structure: state.structure, first: state.first, prompt: $("prompt").value,+ seed: Number($("seed").value) || 0, length: frames(), orientation: state.orientation, causal: state.causal };+ try {+ const g = await fetch("/solarrenderer/api/graph", { method: "POST", body: JSON.stringify(body) });+ const graph = await g.json();+ if (!g.ok) throw new Error(graph.error);+ const r = await fetch("/prompt", { method: "POST", headers: { "Content-Type": "application/json" },+ body: JSON.stringify({ prompt: graph.prompt, client_id: clientId, extra_data: { preview_method: "auto" } }) });+ const queued = await r.json();+ if (!r.ok) throw new Error(queued.error ? `${queued.error.message} ${JSON.stringify(queued.node_errors || {})}` : `queue failed (${r.status})`);+ state.running = queued.prompt_id; state.began = performance.now();+ clearInterval(state.timer); state.timer = setInterval(tick, 250); tick();+ $("out").pause(); $("out").removeAttribute("src"); $("out").load();+ $("preview").style.display = "none"; $("outhint").style.display = "none";+ $("badge").textContent = "RENDERING"; $("badge").className = "badge on"; $("badge").style.display = "block";+ stage("queued", 0);+ } catch (e) { say(e.message, true); ready(); }+};++function played(file) {+ const out = $("out"), inp = $("structure");+ out.src = `/view?filename=${encodeURIComponent(file.filename)}&subfolder=${encodeURIComponent(file.subfolder || "")}&type=${file.type || "output"}`;+ out.onloadeddata = () => {+ $("preview").style.display = "none";+ inp.currentTime = 0; out.currentTime = 0; inp.play(); out.play();+ };+ out.onseeked = null;+ out.ontimeupdate = () => { if (Math.abs(inp.currentTime - out.currentTime) > 0.15) inp.currentTime = out.currentTime; };+}++function connect() {+ const ws = new WebSocket(`${location.protocol === "https:" ? "wss" : "ws"}://${location.host}/ws?clientId=${clientId}`);+ ws.binaryType = "arraybuffer";+ ws.onclose = () => setTimeout(connect, 1500);+ ws.onmessage = e => {+ if (typeof e.data !== "string") { // a sampler preview: event 1 = [type][image], event 4 = [length][metadata][image]+ if (!state.running) return;+ const view = new DataView(e.data), event = view.getUint32(0);+ let start = 8, mime = view.getUint32(4) === 2 ? "image/png" : "image/jpeg";+ if (event === 4) {+ const n = view.getUint32(4);+ const meta = JSON.parse(new TextDecoder().decode(new Uint8Array(e.data, 8, n)));+ if (meta.prompt_id && meta.prompt_id !== state.running) return;+ start = 8 + n; mime = meta.image_type || "image/jpeg";+ } else if (event !== 1) return;+ const img = $("preview"), old = img.src;+ img.src = URL.createObjectURL(new Blob([new Uint8Array(e.data, start)], { type: mime }));+ img.style.display = "block";+ if (old.startsWith("blob:")) URL.revokeObjectURL(old);+ return;+ }+ const { type, data } = JSON.parse(e.data);+ if (type === "status") {+ const left = data.status?.exec_info?.queue_remaining;+ if (state.running && $("stage").textContent === "queued" && left > 1) stage(`queued · ${left - 1} ahead`);+ return;+ }+ if (!state.running || (data && data.prompt_id && data.prompt_id !== state.running)) return;+ if (type === "executing" && data.node) stage(STAGES[data.node] || "working");+ else if (type === "progress") {+ if (data.node === "16") stage(`rendering · ${state.causal ? "chunk" : "step"} ${data.value} of ${data.max}`, data.value / data.max);+ else if (STAGES[data.node] === "decoding") stage(`decoding · ${Math.round(100 * data.value / data.max)}%`);+ } else if (type === "executed" && data.node === "20") {+ const out = data.output || {};+ const file = (out.images || out.videos || out.gifs || [])[0];+ if (file) played(file);+ } else if (type === "execution_success") {+ const s = Math.round((performance.now() - state.began) / 1000);+ $("clock").textContent = s; $("bar").style.width = "100%";+ finish(`rendered in ${s >= 60 ? `${Math.floor(s / 60)} min ${s % 60} s` : `${s} s`}`);+ } else if (type === "execution_error") finish("failed", `${data.exception_type}: ${data.exception_message}`);+ else if (type === "execution_interrupted") finish("stopped");+ };+}++connect(); load().catch(e => say(`Could not reach the SolarRenderer nodes: ${e.message}`, true)); words();+</script>+</body>+</html>diff --git a/comfyui/web/wordmark.png b/comfyui/web/wordmark.pngnew file mode 100644index 0000000..29054c5Binary files /dev/null and b/comfyui/web/wordmark.png differdiff --git a/comfyui/web_capture.py b/comfyui/web_capture.pynew file mode 100644index 0000000..d784b34--- /dev/null+++ b/comfyui/web_capture.py@@ -0,0 +1,242 @@+"""Record a web page's 3D canvas (three.js or any WebGL content) as a structure video, with its sound.++ python comfyui/web_capture.py --url https://example.com/game.html --out capture --frames 158++Runs in its own process (the node starts it), so a browser that hangs or crashes never takes ComfyUI with it. The page+is loaded in headless Chromium, its start button pressed (--click), an optional script run (--setup), and then every+1/24 s the largest canvas on the page is grabbed (it must be drawn with preserveDrawingBuffer, as most engines can be+asked to; the capture asks for it on every WebGL context). An optional key and mouse script plays it:++ seconds:Key[:hold] a key pressed for hold seconds (KeyW, ArrowUp, Space, ShiftLeft, ...)+ seconds:down:Key a key held from here ...+ seconds:up:Key ... to here+ seconds:mouse:dx:dy[:over] the mouse moved by (dx, dy) pixels over `over` seconds+ seconds:click[:hold] the left mouse button pressed++--exact runs the page on a virtual clock that moves 1/24 s per recorded frame, so a machine that cannot grab 24 frames+a second still records the page at exactly 24 fps (the sound, which runs on the real clock, is then left out).++The sound the page makes through WebAudio is recorded from the first frame.++Writes <out>.npy (frames, uint8 [T, H, W, 3]) and, when the page made sound, <out>.webm.+"""++import argparse+import base64+import io+import json+import sys+import time++import numpy as np++FPS = 24++AUDIO_TAP = """(() => {+ // every node connected to a context's destination also feeds a recorder, started at frame 0+ const taps = new WeakMap();+ window.__tapStreams = [];+ const connect = AudioNode.prototype.connect;+ AudioNode.prototype.connect = function (target, ...rest) {+ if (target instanceof AudioDestinationNode) {+ const ctx = target.context;+ if (!taps.has(ctx)) { const t = ctx.createMediaStreamDestination(); taps.set(ctx, t); window.__tapStreams.push(t.stream); }+ connect.call(this, taps.get(ctx), ...rest);+ }+ return connect.call(this, target, ...rest);+ };+ window.__startAudio = () => {+ const s = window.__tapStreams[0];+ if (!s) return false;+ window.__chunks = [];+ window.__rec = new MediaRecorder(s, { mimeType: 'audio/webm;codecs=opus', audioBitsPerSecond: 160000 });+ window.__rec.ondataavailable = e => window.__chunks.push(e.data);+ window.__rec.start(1000);+ return true;+ };+ window.__stopAudio = () => new Promise(resolve => {+ if (!window.__rec) return resolve('');+ window.__rec.onstop = async () => {+ const buf = await new Blob(window.__chunks, { type: 'audio/webm' }).arrayBuffer();+ let bin = ''; const u = new Uint8Array(buf);+ for (let i = 0; i < u.length; i += 0x8000) bin += String.fromCharCode.apply(null, u.subarray(i, i + 0x8000));+ resolve(btoa(bin));+ };+ window.__rec.stop();+ });+})()"""++# frame-exact capture: the page's clocks (performance.now, Date.now, requestAnimationFrame) run on a virtual time that+# advances 1/24 s per recorded frame, however long a frame takes to grab+VIRTUAL_TIME = """(() => {+ let now = performance.now();+ const base = Date.now() - now;+ const realRaf = window.requestAnimationFrame.bind(window);+ let queued = [], id = 0;+ performance.now = () => now;+ Date.now = () => Math.round(base + now);+ window.requestAnimationFrame = cb => { queued.push([++id, cb]); return id; };+ window.cancelAnimationFrame = handle => { queued = queued.filter(([i]) => i !== handle); };+ window.__advance = ms => {+ now += ms;+ const run = queued; queued = [];+ for (const [, cb] of run) { try { cb(now); } catch (e) { console.error(e); } }+ return new Promise(resolve => realRaf(() => resolve(true))); // let the frame reach the canvas+ };+})()"""++# every WebGL context keeps its last frame, so the canvas can be read back after the page drew it (most pages do not ask+# for this, and their canvas reads back black)+PRESERVE = """(() => {+ const getContext = HTMLCanvasElement.prototype.getContext;+ HTMLCanvasElement.prototype.getContext = function (type, attributes) {+ if (/^(webgl2?|experimental-webgl)$/.test(type)) attributes = { ...(attributes || {}), preserveDrawingBuffer: true };+ return getContext.call(this, type, attributes);+ };+})()"""++GRAB = """() => { const cs = [...document.querySelectorAll('canvas')];+ if (!cs.length) return null;+ const c = cs.sort((a, b) => b.width * b.height - a.width * a.height)[0];+ return c.toDataURL('image/jpeg', 0.92).split(',')[1]; }"""+++def plan_of(script: str) -> list:+ """The key and mouse script as (seconds, action, argument), in time order."""+ plan = []+ for item in [x.strip() for x in script.replace("\n", ",").split(",") if x.strip()]:+ parts = item.split(":")+ t, kind = float(parts[0]), parts[1]+ if kind in ("down", "up"):+ plan.append((t, kind, parts[2]))+ elif kind == "mouse":+ dx, dy = float(parts[2]), float(parts[3])+ over = float(parts[4]) if len(parts) > 4 else 0.4+ steps = max(1, int(over * 30))+ plan += [(t + over * i / steps, "move", (dx / steps, dy / steps)) for i in range(steps)]+ elif kind == "click":+ hold = float(parts[2]) if len(parts) > 2 else 0.15+ plan += [(t, "mdown", None), (t + hold, "mup", None)]+ else:+ hold = float(parts[2]) if len(parts) > 2 else 0.12+ plan += [(t, "down", kind), (t + hold, "up", kind)]+ return sorted(plan, key=lambda e: e[0])+++def default_browser_args() -> list:+ # headless Chromium draws WebGL on the GPU through ANGLE; on Linux servers EGL is the path that has a GPU+ args = ["--ignore-gpu-blocklist", "--autoplay-policy=no-user-gesture-required"]+ if sys.platform.startswith("linux"):+ args += ["--use-gl=angle", "--use-angle=gl-egl"]+ return args+++def capture(url, out, frames, width, height, keys="", click="", setup="", warm=1.0, browser_args=None,+ exact=False):+ import queue+ import threading++ from PIL import Image+ from playwright.sync_api import sync_playwright++ plan = plan_of(keys)+ shots = np.zeros((frames, height, width, 3), dtype=np.uint8)+ work: queue.Queue = queue.Queue()++ def writer() -> None: # decoding off the grab loop, which has to keep the page's 24 fps clock+ while (item := work.get()) is not None:+ n, data = item+ image = Image.open(io.BytesIO(base64.b64decode(data))).convert("RGB")+ if image.size != (width, height):+ image = image.resize((width, height), Image.Resampling.LANCZOS)+ shots[n] = np.asarray(image)++ pen = threading.Thread(target=writer, daemon=True)+ pen.start()+ with sync_playwright() as pw:+ browser = pw.chromium.launch(args=browser_args or default_browser_args())+ page = browser.new_page(viewport={"width": width, "height": height})+ page.add_init_script(PRESERVE)+ page.add_init_script(AUDIO_TAP)+ if exact:+ page.add_init_script(VIRTUAL_TIME)+ page.goto(url, wait_until="load")+ page.wait_for_timeout(1500)+ if click:+ page.click(click)+ if setup:+ page.evaluate(f"() => {{ {setup} }}")+ if exact: # the warm-up on the virtual clock too+ for _ in range(int(warm * FPS)):+ page.evaluate(f"() => window.__advance({1000 / FPS})")+ else:+ page.wait_for_timeout(int(warm * 1000))+ mouse = [width / 2, height / 2]+ page.mouse.move(*mouse)+ audio = False+ t0 = time.time()+ for n in range(frames):+ if exact:+ clock = n / FPS+ if n:+ page.evaluate(f"() => window.__advance({1000 / FPS})")+ else:+ due = t0 + n / FPS+ while time.time() < due - 0.003:+ page.wait_for_timeout(2)+ clock = time.time() - t0+ while plan and clock >= plan[0][0]:+ _t, kind, arg = plan.pop(0)+ if kind == "down":+ page.keyboard.down(arg)+ elif kind == "up":+ page.keyboard.up(arg)+ elif kind == "move":+ mouse = [mouse[0] + arg[0], mouse[1] + arg[1]]+ page.mouse.move(*mouse)+ elif kind == "mdown":+ page.mouse.down()+ elif kind == "mup":+ page.mouse.up()+ data = page.evaluate(GRAB)+ if data is None:+ raise RuntimeError(f"{url} has no canvas to record")+ work.put((n, data))+ if n == 0 and not exact: # the sound runs on the real clock: only a real-time capture keeps it+ audio = bool(page.evaluate("() => window.__startAudio && window.__startAudio()"))+ took = time.time() - t0+ sound = page.evaluate("() => window.__stopAudio ? window.__stopAudio() : ''") if audio else ""+ browser.close()+ work.put(None)+ pen.join()+ np.save(f"{out}.npy", shots)+ if sound:+ with open(f"{out}.webm", "wb") as f:+ f.write(base64.b64decode(sound))+ # a grab slower than the clock leaves the page's time running ahead of the frames: the clip plays fast+ return {"frames": frames, "seconds": round(took, 2), "real_time": round(frames / FPS / took, 2),+ "sound": bool(sound)}+++def main() -> None:+ p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)+ p.add_argument("--url", required=True)+ p.add_argument("--out", required=True, help="path prefix of the .npy frames and the .webm sound")+ p.add_argument("--frames", type=int, default=158)+ p.add_argument("--width", type=int, default=1344)+ p.add_argument("--height", type=int, default=768)+ p.add_argument("--keys", default="")+ p.add_argument("--click", default="", help="the selector of a start button to press first")+ p.add_argument("--setup", default="", help="JavaScript run once the page has started")+ p.add_argument("--warm", type=float, default=1.0, help="seconds the page runs before the first frame")+ p.add_argument("--exact", action="store_true", help="frame-exact: the page runs on a virtual clock, 1/24 s per "+ "frame however slow the grab; no sound")+ p.add_argument("--browser-args", default="", help="Chromium flags, space-separated (default: GPU through ANGLE)")+ a = p.parse_args()+ report = capture(a.url, a.out, a.frames, a.width, a.height, a.keys, a.click, a.setup, a.warm,+ a.browser_args.split() or None, a.exact)+ print(json.dumps(report), flush=True)+++if __name__ == "__main__":+ main()diff --git a/comfyui/workflows/solarrenderer_full.json b/comfyui/workflows/solarrenderer_full.jsonnew file mode 100644index 0000000..5a1227b--- /dev/null+++ b/comfyui/workflows/solarrenderer_full.json@@ -0,0 +1,2220 @@+{+ "id": "7c91c7ad-2c1e-4991-8236-31d806ddc47e",+ "revision": 0,+ "last_node_id": 21,+ "last_link_id": 21,+ "nodes": [+ {+ "id": 1,+ "type": "UNETLoader",+ "pos": [+ 80,+ 110+ ],+ "size": [+ 270,+ 82+ ],+ "flags": {},+ "order": 0,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "unet_name",+ "locked": null,+ "name": "unet_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "unet_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "weight_dtype",+ "locked": null,+ "name": "weight_dtype",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "weight_dtype"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 1+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "UNETLoader"+ },+ "widgets_values": [+ "minimax_h3_ref2va_bf16.safetensors",+ "default"+ ],+ "widgets_values_named": {+ "unet_name": "minimax_h3_ref2va_bf16.safetensors",+ "weight_dtype": "default"+ }+ },+ {+ "id": 2,+ "type": "SolarRendererLoraLoader",+ "pos": [+ 472.9,+ 110+ ],+ "size": [+ 281.9,+ 82+ ],+ "flags": {},+ "order": 9,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 1+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "lora_name",+ "locked": null,+ "name": "lora_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "lora_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "strength",+ "locked": null,+ "name": "strength",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "strength"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 2+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererLoraLoader"+ },+ "widgets_values": [+ "solarrenderer_4step_lora.safetensors",+ 1+ ],+ "widgets_values_named": {+ "lora_name": "solarrenderer_4step_lora.safetensors",+ "strength": 1+ }+ },+ {+ "id": 3,+ "type": "SolarRendererLoraLoader",+ "pos": [+ 834.8,+ 110+ ],+ "size": [+ 281.9,+ 82+ ],+ "flags": {},+ "order": 11,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 2+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "lora_name",+ "locked": null,+ "name": "lora_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "lora_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "strength",+ "locked": null,+ "name": "strength",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "strength"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 21+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererLoraLoader"+ },+ "widgets_values": [+ "solarrenderer_control_lora.safetensors",+ 1+ ],+ "widgets_values_named": {+ "lora_name": "solarrenderer_control_lora.safetensors",+ "strength": 1+ }+ },+ {+ "id": 4,+ "type": "SolarRendererModel",+ "pos": [+ 1683.6999999999998,+ 110+ ],+ "size": [+ 363.9,+ 82+ ],+ "flags": {},+ "order": 14,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 3+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "seed",+ "locked": null,+ "name": "seed",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "seed"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 9+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererModel"+ },+ "widgets_values": [+ 0,+ "randomize"+ ],+ "widgets_values_named": {+ "seed": 0,+ "control_after_generate": "randomize"+ }+ },+ {+ "id": 5,+ "type": "CLIPLoader",+ "pos": [+ 80,+ 302+ ],+ "size": [+ 270,+ 106+ ],+ "flags": {},+ "order": 1,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "clip_name",+ "locked": null,+ "name": "clip_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "clip_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "type",+ "locked": null,+ "name": "type",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "type"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "device",+ "locked": null,+ "name": "device",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "device"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "CLIP",+ "locked": null,+ "name": "CLIP",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CLIP",+ "pos": null,+ "slot_index": null,+ "links": [+ 5+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "CLIPLoader"+ },+ "widgets_values": [+ "qwen3vl_32b_minimax_h3_bf16.safetensors",+ "minimax",+ "default"+ ],+ "widgets_values_named": {+ "clip_name": "qwen3vl_32b_minimax_h3_bf16.safetensors",+ "type": "minimax",+ "device": "default"+ }+ },+ {+ "id": 6,+ "type": "VAELoader",+ "pos": [+ 80,+ 518+ ],+ "size": [+ 270,+ 58+ ],+ "flags": {},+ "order": 2,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae_name",+ "locked": null,+ "name": "vae_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "vae_name"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VAE",+ "locked": null,+ "name": "VAE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "slot_index": null,+ "links": [+ 6+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAELoader"+ },+ "widgets_values": [+ "minimax_h3_video_vae_fp16.safetensors"+ ],+ "widgets_values_named": {+ "vae_name": "minimax_h3_video_vae_fp16.safetensors"+ }+ },+ {+ "id": 7,+ "type": "LoadVideo",+ "pos": [+ 80,+ 686+ ],+ "size": [+ 280,+ 234+ ],+ "flags": {},+ "order": 3,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "file",+ "locked": null,+ "name": "file",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "file"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "choose file to upload",+ "locked": null,+ "name": "upload",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGEUPLOAD",+ "widget": {+ "name": "upload"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VIDEO",+ "locked": null,+ "name": "VIDEO",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": [+ 4+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "LoadVideo"+ },+ "widgets_values": [+ "structure.mp4",+ "image"+ ],+ "widgets_values_named": {+ "file": "structure.mp4",+ "upload": "image"+ }+ },+ {+ "id": 8,+ "type": "GetVideoComponents",+ "pos": [+ 472.9,+ 302+ ],+ "size": [+ 191.9,+ 106+ ],+ "flags": {},+ "order": 10,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "link": 4+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "images",+ "locked": null,+ "name": "images",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 7+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio",+ "locked": null,+ "name": "audio",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "AUDIO",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "fps",+ "locked": null,+ "name": "fps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "bit_depth",+ "locked": null,+ "name": "bit_depth",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "color_space",+ "locked": null,+ "name": "color_space",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "GetVideoComponents"+ }+ },+ {+ "id": 9,+ "type": "LoadImage",+ "pos": [+ 80,+ 1030+ ],+ "size": [+ 280,+ 314+ ],+ "flags": {},+ "order": 4,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "image",+ "locked": null,+ "name": "image",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "image"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "choose file to upload",+ "locked": null,+ "name": "upload",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGEUPLOAD",+ "widget": {+ "name": "upload"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "IMAGE",+ "locked": null,+ "name": "IMAGE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 8+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MASK",+ "locked": null,+ "name": "MASK",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MASK",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "LoadImage"+ },+ "widgets_values": [+ "first.png",+ "image"+ ],+ "widgets_values_named": {+ "image": "first.png",+ "upload": "image"+ }+ },+ {+ "id": 10,+ "type": "SolarRendererConditioning",+ "pos": [+ 834.8,+ 302+ ],+ "size": [+ 400,+ 240+ ],+ "flags": {},+ "order": 12,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "clip",+ "locked": null,+ "name": "clip",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CLIP",+ "pos": null,+ "link": 5+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae",+ "locked": null,+ "name": "vae",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "link": 6+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "structure",+ "locked": null,+ "name": "structure",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "link": 7+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "first_frame",+ "locked": null,+ "name": "first_frame",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "IMAGE",+ "pos": null,+ "link": 8+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "structure_vae",+ "locked": null,+ "name": "structure_vae",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "VAE",+ "pos": null,+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "prompt",+ "locked": null,+ "name": "prompt",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "STRING",+ "widget": {+ "name": "prompt"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "width",+ "locked": null,+ "name": "width",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "width"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "height",+ "locked": null,+ "name": "height",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "height"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "length",+ "locked": null,+ "name": "length",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "length"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "positive",+ "locked": null,+ "name": "positive",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CONDITIONING",+ "pos": null,+ "slot_index": null,+ "links": [+ 10+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "latent",+ "locked": null,+ "name": "latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 15+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererConditioning"+ },+ "widgets_values": [+ "subject_definitions:\n<Video 1> is a semantic segmentation of the scene, one flat colour per class (road, sidewalk, building, vegetation, vehicle, pedestrian, sky and so on), frame by frame, from the same camera as the target video.\n<Video 2> is the first frame of [Shot 1], held still.\n\nsummary:\n[keyframe completion + reference generation] The target video begins from <Video 2> and follows the frame-by-frame structure and motion of <Video 1>. A retro synthwave highway run: a neon-trimmed coupe overtakes a glowing semi-truck, flies under a neon gantry and overpass at dusk, and slides back into its lane.\n\nretention_analysis:\n<Video 1> (frame-by-frame layout of every class and camera): attribute_transfer - every region keeps its class, outline and place; materials, colours and lighting are not given by <Video 1>; the flat class colours are not shown.\n<Video 2> ([Shot 1] first frame): fully_preserved - the composition, subjects, materials, colours and lighting of <Video 2> are the target video's first frame.\n\ndetailed_description:\nThe target video is a stylised synthwave animation in the look of an eighties retro-futuristic music video, with a magenta-to-violet sunset gradient sky, a huge striped setting sun on the horizon, neon pink and cyan edge lighting, glossy reflective surfaces and a light film grain. [Shot 1] The shot begins from <Video 2>. The camera trails a few metres behind and above a black wedge-shaped sports coupe with a glowing cyan light strip across its tail, in the right lane of a six-lane divided highway whose lane lines glow hot pink. Ahead sits the back of a chrome semi-trailer outlined in purple neon, pulled by a tractor with a glowing grille. After half a second the coupe glides left into the middle lane, the camera tilting with it, and begins to close on the truck. The trailer's mirror-like side slides by on the right, reflecting the sunset, then its glowing wheels and the cab with chrome stacks, passing within a couple of metres. Midway, a gantry with two glowing signs in retro lettering sweeps overhead. Further up the road, tail lights of an SUV and a sedan streak away in the fast lane, with a hatchback, a box truck and a van glowing ahead. Across a dark median lined with tall lamp posts topped by pink light bars, oncoming cars and a coach race past as streaks of white light. Near the end the coupe flashes under a concrete overpass trimmed with neon tubes, while a glowing SUV and a delivery truck cross above, their light trails painting streaks along the bridge railing. Clear of the truck, the coupe slides back into the right lane toward the setting sun. The coupe stays planted through every move, rocking slightly over expansion joints, and the camera follows with a slight lag so each lane change feels smooth, heavy and rhythmic, like a slow camera move in a music video. Guard rails gleam with reflected pink light, palm-like trees and stylised pines stand as black silhouettes, utility poles and their wires cut thin lines across the gradient sky, and low warehouses with glowing windows and purple hills fade toward a wireframe-like horizon.\n\noverall_soundscape:\nSmooth tyre roar and wind with a punchy engine note as the coupe overtakes, a deep whoosh past the truck and a hollow echo under the overpass.\n\nnon_diegetic_music:\nN/A",+ 1344,+ 768,+ 158+ ],+ "widgets_values_named": {+ "prompt": "subject_definitions:\n<Video 1> is a semantic segmentation of the scene, one flat colour per class (road, sidewalk, building, vegetation, vehicle, pedestrian, sky and so on), frame by frame, from the same camera as the target video.\n<Video 2> is the first frame of [Shot 1], held still.\n\nsummary:\n[keyframe completion + reference generation] The target video begins from <Video 2> and follows the frame-by-frame structure and motion of <Video 1>. A retro synthwave highway run: a neon-trimmed coupe overtakes a glowing semi-truck, flies under a neon gantry and overpass at dusk, and slides back into its lane.\n\nretention_analysis:\n<Video 1> (frame-by-frame layout of every class and camera): attribute_transfer - every region keeps its class, outline and place; materials, colours and lighting are not given by <Video 1>; the flat class colours are not shown.\n<Video 2> ([Shot 1] first frame): fully_preserved - the composition, subjects, materials, colours and lighting of <Video 2> are the target video's first frame.\n\ndetailed_description:\nThe target video is a stylised synthwave animation in the look of an eighties retro-futuristic music video, with a magenta-to-violet sunset gradient sky, a huge striped setting sun on the horizon, neon pink and cyan edge lighting, glossy reflective surfaces and a light film grain. [Shot 1] The shot begins from <Video 2>. The camera trails a few metres behind and above a black wedge-shaped sports coupe with a glowing cyan light strip across its tail, in the right lane of a six-lane divided highway whose lane lines glow hot pink. Ahead sits the back of a chrome semi-trailer outlined in purple neon, pulled by a tractor with a glowing grille. After half a second the coupe glides left into the middle lane, the camera tilting with it, and begins to close on the truck. The trailer's mirror-like side slides by on the right, reflecting the sunset, then its glowing wheels and the cab with chrome stacks, passing within a couple of metres. Midway, a gantry with two glowing signs in retro lettering sweeps overhead. Further up the road, tail lights of an SUV and a sedan streak away in the fast lane, with a hatchback, a box truck and a van glowing ahead. Across a dark median lined with tall lamp posts topped by pink light bars, oncoming cars and a coach race past as streaks of white light. Near the end the coupe flashes under a concrete overpass trimmed with neon tubes, while a glowing SUV and a delivery truck cross above, their light trails painting streaks along the bridge railing. Clear of the truck, the coupe slides back into the right lane toward the setting sun. The coupe stays planted through every move, rocking slightly over expansion joints, and the camera follows with a slight lag so each lane change feels smooth, heavy and rhythmic, like a slow camera move in a music video. Guard rails gleam with reflected pink light, palm-like trees and stylised pines stand as black silhouettes, utility poles and their wires cut thin lines across the gradient sky, and low warehouses with glowing windows and purple hills fade toward a wireframe-like horizon.\n\noverall_soundscape:\nSmooth tyre roar and wind with a punchy engine note as the coupe overtakes, a deep whoosh past the truck and a hollow echo under the overpass.\n\nnon_diegetic_music:\nN/A",+ "width": 1344,+ "height": 768,+ "length": 158+ }+ },+ {+ "id": 11,+ "type": "KSamplerSelect",+ "pos": [+ 80,+ 1454+ ],+ "size": [+ 270,+ 58+ ],+ "flags": {},+ "order": 5,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "sampler_name",+ "locked": null,+ "name": "sampler_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "sampler_name"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "SAMPLER",+ "locked": null,+ "name": "SAMPLER",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SAMPLER",+ "pos": null,+ "slot_index": null,+ "links": [+ 13+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "KSamplerSelect"+ },+ "widgets_values": [+ "lcm"+ ],+ "widgets_values_named": {+ "sampler_name": "lcm"+ }+ },+ {+ "id": 12,+ "type": "SolarRendererSigmas",+ "pos": [+ 80,+ 1622+ ],+ "size": [+ 312.9,+ 58+ ],+ "flags": {},+ "order": 6,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "steps",+ "locked": null,+ "name": "steps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "steps"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "SIGMAS",+ "locked": null,+ "name": "SIGMAS",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SIGMAS",+ "pos": null,+ "slot_index": null,+ "links": [+ 14+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererSigmas"+ },+ "widgets_values": [+ 4+ ],+ "widgets_values_named": {+ "steps": 4+ }+ },+ {+ "id": 13,+ "type": "RandomNoise",+ "pos": [+ 80,+ 1790+ ],+ "size": [+ 270,+ 82+ ],+ "flags": {},+ "order": 7,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "noise_seed",+ "locked": null,+ "name": "noise_seed",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "noise_seed"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "NOISE",+ "locked": null,+ "name": "NOISE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "NOISE",+ "pos": null,+ "slot_index": null,+ "links": [+ 11+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "RandomNoise"+ },+ "widgets_values": [+ 0,+ "randomize"+ ],+ "widgets_values_named": {+ "noise_seed": 0,+ "control_after_generate": "randomize"+ }+ },+ {+ "id": 14,+ "type": "BasicGuider",+ "pos": [+ 2127.6,+ 110+ ],+ "size": [+ 159,+ 46+ ],+ "flags": {},+ "order": 15,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 9+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "conditioning",+ "locked": null,+ "name": "conditioning",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CONDITIONING",+ "pos": null,+ "link": 10+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "GUIDER",+ "locked": null,+ "name": "GUIDER",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "GUIDER",+ "pos": null,+ "slot_index": null,+ "links": [+ 12+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "BasicGuider"+ }+ },+ {+ "id": 15,+ "type": "SamplerCustomAdvanced",+ "pos": [+ 2366.6,+ 110+ ],+ "size": [+ 211.9,+ 106+ ],+ "flags": {},+ "order": 16,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "noise",+ "locked": null,+ "name": "noise",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "NOISE",+ "pos": null,+ "link": 11+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "guider",+ "locked": null,+ "name": "guider",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "GUIDER",+ "pos": null,+ "link": 12+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "sampler",+ "locked": null,+ "name": "sampler",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SAMPLER",+ "pos": null,+ "link": 13+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "sigmas",+ "locked": null,+ "name": "sigmas",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SIGMAS",+ "pos": null,+ "link": 14+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "latent_image",+ "locked": null,+ "name": "latent_image",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 15+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "output",+ "locked": null,+ "name": "output",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 16+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "denoised_output",+ "locked": null,+ "name": "denoised_output",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "SamplerCustomAdvanced"+ }+ },+ {+ "id": 16,+ "type": "LTXVSeparateAVLatent",+ "pos": [+ 2658.5,+ 110+ ],+ "size": [+ 168.9,+ 46+ ],+ "flags": {},+ "order": 17,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "av_latent",+ "locked": null,+ "name": "av_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 16+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video_latent",+ "locked": null,+ "name": "video_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 17+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio_latent",+ "locked": null,+ "name": "audio_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "LTXVSeparateAVLatent"+ }+ },+ {+ "id": 17,+ "type": "VAELoader",+ "pos": [+ 80,+ 1982+ ],+ "size": [+ 270,+ 58+ ],+ "flags": {},+ "order": 8,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae_name",+ "locked": null,+ "name": "vae_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "vae_name"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VAE",+ "locked": null,+ "name": "VAE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "slot_index": null,+ "links": [+ 18+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAELoader"+ },+ "widgets_values": [+ "minimax_h3_video_vae_fp16.safetensors"+ ],+ "widgets_values_named": {+ "vae_name": "minimax_h3_video_vae_fp16.safetensors"+ }+ },+ {+ "id": 18,+ "type": "VAEDecode",+ "pos": [+ 2907.4,+ 110+ ],+ "size": [+ 140,+ 46+ ],+ "flags": {},+ "order": 18,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "samples",+ "locked": null,+ "name": "samples",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 17+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae",+ "locked": null,+ "name": "vae",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "link": 18+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "IMAGE",+ "locked": null,+ "name": "IMAGE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 19+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAEDecode"+ }+ },+ {+ "id": 19,+ "type": "CreateVideo",+ "pos": [+ 3127.4,+ 110+ ],+ "size": [+ 270,+ 150+ ],+ "flags": {},+ "order": 19,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "images",+ "locked": null,+ "name": "images",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "link": 19+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio",+ "locked": null,+ "name": "audio",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "AUDIO",+ "pos": null,+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "fps",+ "locked": null,+ "name": "fps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "fps"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "bit_depth",+ "locked": null,+ "name": "bit_depth",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "bit_depth"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "color_space",+ "locked": null,+ "name": "color_space",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "color_space"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "codec",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "codec"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VIDEO",+ "locked": null,+ "name": "VIDEO",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": [+ 20+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "CreateVideo"+ },+ "widgets_values": [+ 24,+ "auto",+ "sRGB",+ "none"+ ],+ "widgets_values_named": {+ "fps": 24,+ "bit_depth": "auto",+ "color_space": "sRGB",+ "codec": "none"+ }+ },+ {+ "id": 20,+ "type": "SaveVideo",+ "pos": [+ 3477.4,+ 110+ ],+ "size": [+ 270,+ 130+ ],+ "flags": {},+ "order": 20,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "link": 20+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "filename_prefix",+ "locked": null,+ "name": "filename_prefix",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "STRING",+ "widget": {+ "name": "filename_prefix"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "format",+ "locked": null,+ "name": "format",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "format"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "format.codec",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "format.codec"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "codec",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "codec"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "encoding",+ "locked": null,+ "name": "codec.encoding",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "codec.encoding"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {},+ "widgets_values": [+ "solarrenderer_full",+ "mp4",+ "auto",+ "h264",+ "auto"+ ],+ "widgets_values_named": {+ "filename_prefix": "solarrenderer_full",+ "format": "mp4",+ "format.codec": "auto",+ "codec": "h264",+ "codec.encoding": "auto"+ }+ },+ {+ "id": 21,+ "type": "SolarRendererFastAttention",+ "pos": [+ 1314.8,+ 110+ ],+ "size": [+ 288.9,+ 58+ ],+ "flags": {},+ "order": 13,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 21+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "backend",+ "locked": null,+ "name": "backend",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "backend"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 3+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererFastAttention"+ },+ "widgets_values": [+ "auto"+ ],+ "widgets_values_named": {+ "backend": "auto"+ }+ }+ ],+ "links": [+ [+ 1,+ 1,+ 0,+ 2,+ 0,+ "MODEL"+ ],+ [+ 2,+ 2,+ 0,+ 3,+ 0,+ "MODEL"+ ],+ [+ 3,+ 21,+ 0,+ 4,+ 0,+ "MODEL"+ ],+ [+ 4,+ 7,+ 0,+ 8,+ 0,+ "VIDEO"+ ],+ [+ 5,+ 5,+ 0,+ 10,+ 0,+ "CLIP"+ ],+ [+ 6,+ 6,+ 0,+ 10,+ 1,+ "VAE"+ ],+ [+ 7,+ 8,+ 0,+ 10,+ 2,+ "IMAGE"+ ],+ [+ 8,+ 9,+ 0,+ 10,+ 3,+ "IMAGE"+ ],+ [+ 9,+ 4,+ 0,+ 14,+ 0,+ "MODEL"+ ],+ [+ 10,+ 10,+ 0,+ 14,+ 1,+ "CONDITIONING"+ ],+ [+ 11,+ 13,+ 0,+ 15,+ 0,+ "NOISE"+ ],+ [+ 12,+ 14,+ 0,+ 15,+ 1,+ "GUIDER"+ ],+ [+ 13,+ 11,+ 0,+ 15,+ 2,+ "SAMPLER"+ ],+ [+ 14,+ 12,+ 0,+ 15,+ 3,+ "SIGMAS"+ ],+ [+ 15,+ 10,+ 1,+ 15,+ 4,+ "LATENT"+ ],+ [+ 16,+ 15,+ 0,+ 16,+ 0,+ "LATENT"+ ],+ [+ 17,+ 16,+ 0,+ 18,+ 0,+ "LATENT"+ ],+ [+ 18,+ 17,+ 0,+ 18,+ 1,+ "VAE"+ ],+ [+ 19,+ 18,+ 0,+ 19,+ 0,+ "IMAGE"+ ],+ [+ 20,+ 19,+ 0,+ 20,+ 0,+ "VIDEO"+ ],+ [+ 21,+ 3,+ 0,+ 21,+ 0,+ "MODEL"+ ]+ ],+ "floatingLinks": null,+ "groups": [],+ "definitions": null,+ "config": {},+ "extra": {+ "ds": {+ "scale": 1,+ "offset": [+ 0,+ 0+ ]+ },+ "reroutes": null+ },+ "version": 0.4+}\ No newline at end of filediff --git a/comfyui/workflows/solarrenderer_long.json b/comfyui/workflows/solarrenderer_long.jsonnew file mode 100644index 0000000..7a1ae6c--- /dev/null+++ b/comfyui/workflows/solarrenderer_long.json@@ -0,0 +1,1682 @@+{+ "id": "3a873ec8-b1b2-4b3c-8e11-101c14203a7c",+ "revision": 0,+ "last_node_id": 20,+ "last_link_id": 15,+ "nodes": [+ {+ "id": 1,+ "type": "UNETLoader",+ "pos": [+ 80,+ 110+ ],+ "size": [+ 270,+ 82+ ],+ "flags": {},+ "order": 0,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "unet_name",+ "locked": null,+ "name": "unet_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "unet_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "weight_dtype",+ "locked": null,+ "name": "weight_dtype",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "weight_dtype"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 1+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "UNETLoader"+ },+ "widgets_values": [+ "minimax_h3_ref2va_bf16.safetensors",+ "default"+ ],+ "widgets_values_named": {+ "unet_name": "minimax_h3_ref2va_bf16.safetensors",+ "weight_dtype": "default"+ }+ },+ {+ "id": 2,+ "type": "SolarRendererLoraLoader",+ "pos": [+ 440,+ 110+ ],+ "size": [+ 281.9,+ 82+ ],+ "flags": {},+ "order": 5,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 1+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "lora_name",+ "locked": null,+ "name": "lora_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "lora_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "strength",+ "locked": null,+ "name": "strength",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "strength"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 2+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererLoraLoader"+ },+ "widgets_values": [+ "solarrenderer_causal_4step_lora.safetensors",+ 1+ ],+ "widgets_values_named": {+ "lora_name": "solarrenderer_causal_4step_lora.safetensors",+ "strength": 1+ }+ },+ {+ "id": 3,+ "type": "SolarRendererLoraLoader",+ "pos": [+ 801.9,+ 110+ ],+ "size": [+ 281.9,+ 82+ ],+ "flags": {},+ "order": 7,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 2+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "lora_name",+ "locked": null,+ "name": "lora_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "lora_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "strength",+ "locked": null,+ "name": "strength",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "strength"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 8+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererLoraLoader"+ },+ "widgets_values": [+ "solarrenderer_causal_control_lora.safetensors",+ 1+ ],+ "widgets_values_named": {+ "lora_name": "solarrenderer_causal_control_lora.safetensors",+ "strength": 1+ }+ },+ {+ "id": 6,+ "type": "CLIPLoader",+ "pos": [+ 80,+ 302+ ],+ "size": [+ 270,+ 106+ ],+ "flags": {},+ "order": 1,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "clip_name",+ "locked": null,+ "name": "clip_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "clip_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "type",+ "locked": null,+ "name": "type",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "type"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "device",+ "locked": null,+ "name": "device",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "device"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "CLIP",+ "locked": null,+ "name": "CLIP",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CLIP",+ "pos": null,+ "slot_index": null,+ "links": [+ 4+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "CLIPLoader"+ },+ "widgets_values": [+ "qwen3vl_32b_minimax_h3_bf16.safetensors",+ "minimax",+ "default"+ ],+ "widgets_values_named": {+ "clip_name": "qwen3vl_32b_minimax_h3_bf16.safetensors",+ "type": "minimax",+ "device": "default"+ }+ },+ {+ "id": 7,+ "type": "VAELoader",+ "pos": [+ 80,+ 518+ ],+ "size": [+ 270,+ 58+ ],+ "flags": {},+ "order": 2,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae_name",+ "locked": null,+ "name": "vae_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "vae_name"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VAE",+ "locked": null,+ "name": "VAE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "slot_index": null,+ "links": [+ 5,+ 13+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAELoader"+ },+ "widgets_values": [+ "minimax_h3_video_vae_fp16.safetensors"+ ],+ "widgets_values_named": {+ "vae_name": "minimax_h3_video_vae_fp16.safetensors"+ }+ },+ {+ "id": 8,+ "type": "LoadVideo",+ "pos": [+ 80,+ 686+ ],+ "size": [+ 280,+ 234+ ],+ "flags": {},+ "order": 3,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "file",+ "locked": null,+ "name": "file",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "file"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "choose file to upload",+ "locked": null,+ "name": "upload",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGEUPLOAD",+ "widget": {+ "name": "upload"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VIDEO",+ "locked": null,+ "name": "VIDEO",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": [+ 3+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "LoadVideo"+ },+ "widgets_values": [+ "structure.mp4",+ "image"+ ],+ "widgets_values_named": {+ "file": "structure.mp4",+ "upload": "image"+ }+ },+ {+ "id": 9,+ "type": "GetVideoComponents",+ "pos": [+ 440,+ 302+ ],+ "size": [+ 191.9,+ 106+ ],+ "flags": {},+ "order": 6,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "link": 3+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "images",+ "locked": null,+ "name": "images",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 6+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio",+ "locked": null,+ "name": "audio",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "AUDIO",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "fps",+ "locked": null,+ "name": "fps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "bit_depth",+ "locked": null,+ "name": "bit_depth",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "color_space",+ "locked": null,+ "name": "color_space",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "GetVideoComponents"+ }+ },+ {+ "id": 10,+ "type": "LoadImage",+ "pos": [+ 80,+ 1030+ ],+ "size": [+ 280,+ 314+ ],+ "flags": {},+ "order": 4,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "image",+ "locked": null,+ "name": "image",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "image"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "choose file to upload",+ "locked": null,+ "name": "upload",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGEUPLOAD",+ "widget": {+ "name": "upload"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "IMAGE",+ "locked": null,+ "name": "IMAGE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 7+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MASK",+ "locked": null,+ "name": "MASK",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MASK",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "LoadImage"+ },+ "widgets_values": [+ "first.png",+ "image"+ ],+ "widgets_values_named": {+ "image": "first.png",+ "upload": "image"+ }+ },+ {+ "id": 11,+ "type": "SolarRendererConditioning",+ "pos": [+ 801.9,+ 302+ ],+ "size": [+ 400,+ 240+ ],+ "flags": {},+ "order": 8,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "clip",+ "locked": null,+ "name": "clip",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CLIP",+ "pos": null,+ "link": 4+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae",+ "locked": null,+ "name": "vae",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "link": 5+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "structure",+ "locked": null,+ "name": "structure",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "link": 6+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "first_frame",+ "locked": null,+ "name": "first_frame",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "IMAGE",+ "pos": null,+ "link": 7+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "structure_vae",+ "locked": null,+ "name": "structure_vae",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "VAE",+ "pos": null,+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "prompt",+ "locked": null,+ "name": "prompt",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "STRING",+ "widget": {+ "name": "prompt"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "width",+ "locked": null,+ "name": "width",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "width"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "height",+ "locked": null,+ "name": "height",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "height"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "length",+ "locked": null,+ "name": "length",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "length"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "positive",+ "locked": null,+ "name": "positive",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CONDITIONING",+ "pos": null,+ "slot_index": null,+ "links": [+ 9+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "latent",+ "locked": null,+ "name": "latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 10+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererConditioning"+ },+ "widgets_values": [+ "subject_definitions:\n<Video 1> is a semantic segmentation of the scene, one flat colour per class (road, sidewalk, building, vegetation, vehicle, pedestrian, sky and so on), frame by frame, from the same camera as the target video.\n<Video 2> is the first frame of [Shot 1], held still.\n\nsummary:\n[keyframe completion + reference generation] The target video begins from <Video 2> and follows the frame-by-frame structure and motion of <Video 1>. A retro synthwave highway run: a neon-trimmed coupe overtakes a glowing semi-truck, flies under a neon gantry and overpass at dusk, and slides back into its lane.\n\nretention_analysis:\n<Video 1> (frame-by-frame layout of every class and camera): attribute_transfer - every region keeps its class, outline and place; materials, colours and lighting are not given by <Video 1>; the flat class colours are not shown.\n<Video 2> ([Shot 1] first frame): fully_preserved - the composition, subjects, materials, colours and lighting of <Video 2> are the target video's first frame.\n\ndetailed_description:\nThe target video is a stylised synthwave animation in the look of an eighties retro-futuristic music video, with a magenta-to-violet sunset gradient sky, a huge striped setting sun on the horizon, neon pink and cyan edge lighting, glossy reflective surfaces and a light film grain. [Shot 1] The shot begins from <Video 2>. The camera trails a few metres behind and above a black wedge-shaped sports coupe with a glowing cyan light strip across its tail, in the right lane of a six-lane divided highway whose lane lines glow hot pink. Ahead sits the back of a chrome semi-trailer outlined in purple neon, pulled by a tractor with a glowing grille. After half a second the coupe glides left into the middle lane, the camera tilting with it, and begins to close on the truck. The trailer's mirror-like side slides by on the right, reflecting the sunset, then its glowing wheels and the cab with chrome stacks, passing within a couple of metres. Midway, a gantry with two glowing signs in retro lettering sweeps overhead. Further up the road, tail lights of an SUV and a sedan streak away in the fast lane, with a hatchback, a box truck and a van glowing ahead. Across a dark median lined with tall lamp posts topped by pink light bars, oncoming cars and a coach race past as streaks of white light. Near the end the coupe flashes under a concrete overpass trimmed with neon tubes, while a glowing SUV and a delivery truck cross above, their light trails painting streaks along the bridge railing. Clear of the truck, the coupe slides back into the right lane toward the setting sun. The coupe stays planted through every move, rocking slightly over expansion joints, and the camera follows with a slight lag so each lane change feels smooth, heavy and rhythmic, like a slow camera move in a music video. Guard rails gleam with reflected pink light, palm-like trees and stylised pines stand as black silhouettes, utility poles and their wires cut thin lines across the gradient sky, and low warehouses with glowing windows and purple hills fade toward a wireframe-like horizon.\n\noverall_soundscape:\nSmooth tyre roar and wind with a punchy engine note as the coupe overtakes, a deep whoosh past the truck and a hollow echo under the overpass.\n\nnon_diegetic_music:\nN/A",+ 1344,+ 768,+ 3609+ ],+ "widgets_values_named": {+ "prompt": "subject_definitions:\n<Video 1> is a semantic segmentation of the scene, one flat colour per class (road, sidewalk, building, vegetation, vehicle, pedestrian, sky and so on), frame by frame, from the same camera as the target video.\n<Video 2> is the first frame of [Shot 1], held still.\n\nsummary:\n[keyframe completion + reference generation] The target video begins from <Video 2> and follows the frame-by-frame structure and motion of <Video 1>. A retro synthwave highway run: a neon-trimmed coupe overtakes a glowing semi-truck, flies under a neon gantry and overpass at dusk, and slides back into its lane.\n\nretention_analysis:\n<Video 1> (frame-by-frame layout of every class and camera): attribute_transfer - every region keeps its class, outline and place; materials, colours and lighting are not given by <Video 1>; the flat class colours are not shown.\n<Video 2> ([Shot 1] first frame): fully_preserved - the composition, subjects, materials, colours and lighting of <Video 2> are the target video's first frame.\n\ndetailed_description:\nThe target video is a stylised synthwave animation in the look of an eighties retro-futuristic music video, with a magenta-to-violet sunset gradient sky, a huge striped setting sun on the horizon, neon pink and cyan edge lighting, glossy reflective surfaces and a light film grain. [Shot 1] The shot begins from <Video 2>. The camera trails a few metres behind and above a black wedge-shaped sports coupe with a glowing cyan light strip across its tail, in the right lane of a six-lane divided highway whose lane lines glow hot pink. Ahead sits the back of a chrome semi-trailer outlined in purple neon, pulled by a tractor with a glowing grille. After half a second the coupe glides left into the middle lane, the camera tilting with it, and begins to close on the truck. The trailer's mirror-like side slides by on the right, reflecting the sunset, then its glowing wheels and the cab with chrome stacks, passing within a couple of metres. Midway, a gantry with two glowing signs in retro lettering sweeps overhead. Further up the road, tail lights of an SUV and a sedan streak away in the fast lane, with a hatchback, a box truck and a van glowing ahead. Across a dark median lined with tall lamp posts topped by pink light bars, oncoming cars and a coach race past as streaks of white light. Near the end the coupe flashes under a concrete overpass trimmed with neon tubes, while a glowing SUV and a delivery truck cross above, their light trails painting streaks along the bridge railing. Clear of the truck, the coupe slides back into the right lane toward the setting sun. The coupe stays planted through every move, rocking slightly over expansion joints, and the camera follows with a slight lag so each lane change feels smooth, heavy and rhythmic, like a slow camera move in a music video. Guard rails gleam with reflected pink light, palm-like trees and stylised pines stand as black silhouettes, utility poles and their wires cut thin lines across the gradient sky, and low warehouses with glowing windows and purple hills fade toward a wireframe-like horizon.\n\noverall_soundscape:\nSmooth tyre roar and wind with a punchy engine note as the coupe overtakes, a deep whoosh past the truck and a hollow echo under the overpass.\n\nnon_diegetic_music:\nN/A",+ "width": 1344,+ "height": 768,+ "length": 3609+ }+ },+ {+ "id": 16,+ "type": "SolarRendererCausalSampler",+ "pos": [+ 1281.9,+ 110+ ],+ "size": [+ 374.9,+ 146+ ],+ "flags": {},+ "order": 9,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 8+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "positive",+ "locked": null,+ "name": "positive",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CONDITIONING",+ "pos": null,+ "link": 9+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "latent",+ "locked": null,+ "name": "latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 10+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "seed",+ "locked": null,+ "name": "seed",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "seed"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "cache",+ "locked": null,+ "name": "cache",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "cache"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "LATENT",+ "locked": null,+ "name": "LATENT",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 11+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererCausalSampler"+ },+ "widgets_values": [+ 0,+ "randomize",+ "auto"+ ],+ "widgets_values_named": {+ "seed": 0,+ "control_after_generate": "randomize",+ "cache": "auto"+ }+ },+ {+ "id": 17,+ "type": "LTXVSeparateAVLatent",+ "pos": [+ 1736.8000000000002,+ 110+ ],+ "size": [+ 168.9,+ 46+ ],+ "flags": {},+ "order": 10,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "av_latent",+ "locked": null,+ "name": "av_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 11+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video_latent",+ "locked": null,+ "name": "video_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 12+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio_latent",+ "locked": null,+ "name": "audio_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "LTXVSeparateAVLatent"+ }+ },+ {+ "id": 18,+ "type": "VAEDecode",+ "pos": [+ 1985.7000000000003,+ 110+ ],+ "size": [+ 140,+ 46+ ],+ "flags": {},+ "order": 11,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "samples",+ "locked": null,+ "name": "samples",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 12+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae",+ "locked": null,+ "name": "vae",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "link": 13+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "IMAGE",+ "locked": null,+ "name": "IMAGE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 14+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAEDecode"+ }+ },+ {+ "id": 19,+ "type": "CreateVideo",+ "pos": [+ 2205.7000000000003,+ 110+ ],+ "size": [+ 270,+ 150+ ],+ "flags": {},+ "order": 12,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "images",+ "locked": null,+ "name": "images",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "link": 14+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio",+ "locked": null,+ "name": "audio",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "AUDIO",+ "pos": null,+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "fps",+ "locked": null,+ "name": "fps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "fps"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "bit_depth",+ "locked": null,+ "name": "bit_depth",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "bit_depth"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "color_space",+ "locked": null,+ "name": "color_space",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "color_space"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "codec",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "codec"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VIDEO",+ "locked": null,+ "name": "VIDEO",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": [+ 15+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "CreateVideo"+ },+ "widgets_values": [+ 24,+ "auto",+ "sRGB",+ "none"+ ],+ "widgets_values_named": {+ "fps": 24,+ "bit_depth": "auto",+ "color_space": "sRGB",+ "codec": "none"+ }+ },+ {+ "id": 20,+ "type": "SaveVideo",+ "pos": [+ 2555.7000000000003,+ 110+ ],+ "size": [+ 270,+ 130+ ],+ "flags": {},+ "order": 13,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "link": 15+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "filename_prefix",+ "locked": null,+ "name": "filename_prefix",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "STRING",+ "widget": {+ "name": "filename_prefix"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "format",+ "locked": null,+ "name": "format",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "format"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "format.codec",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "format.codec"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "codec",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "codec"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "encoding",+ "locked": null,+ "name": "codec.encoding",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "codec.encoding"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {},+ "widgets_values": [+ "solarrenderer_long",+ "mp4",+ "auto",+ "h264",+ "auto"+ ],+ "widgets_values_named": {+ "filename_prefix": "solarrenderer_long",+ "format": "mp4",+ "format.codec": "auto",+ "codec": "h264",+ "codec.encoding": "auto"+ }+ }+ ],+ "links": [+ [+ 1,+ 1,+ 0,+ 2,+ 0,+ "MODEL"+ ],+ [+ 2,+ 2,+ 0,+ 3,+ 0,+ "MODEL"+ ],+ [+ 3,+ 8,+ 0,+ 9,+ 0,+ "VIDEO"+ ],+ [+ 4,+ 6,+ 0,+ 11,+ 0,+ "CLIP"+ ],+ [+ 5,+ 7,+ 0,+ 11,+ 1,+ "VAE"+ ],+ [+ 6,+ 9,+ 0,+ 11,+ 2,+ "IMAGE"+ ],+ [+ 7,+ 10,+ 0,+ 11,+ 3,+ "IMAGE"+ ],+ [+ 8,+ 3,+ 0,+ 16,+ 0,+ "MODEL"+ ],+ [+ 9,+ 11,+ 0,+ 16,+ 1,+ "CONDITIONING"+ ],+ [+ 10,+ 11,+ 1,+ 16,+ 2,+ "LATENT"+ ],+ [+ 11,+ 16,+ 0,+ 17,+ 0,+ "LATENT"+ ],+ [+ 12,+ 17,+ 0,+ 18,+ 0,+ "LATENT"+ ],+ [+ 13,+ 7,+ 0,+ 18,+ 1,+ "VAE"+ ],+ [+ 14,+ 18,+ 0,+ 19,+ 0,+ "IMAGE"+ ],+ [+ 15,+ 19,+ 0,+ 20,+ 0,+ "VIDEO"+ ]+ ],+ "floatingLinks": null,+ "groups": [],+ "definitions": null,+ "config": {},+ "extra": {+ "ds": {+ "scale": 0.9,+ "offset": [+ 416,+ 110+ ]+ },+ "reroutes": null+ },+ "version": 0.4+}\ No newline at end of filediff --git a/comfyui/workflows/solarrenderer_low_memory.json b/comfyui/workflows/solarrenderer_low_memory.jsonnew file mode 100644index 0000000..b8c4813--- /dev/null+++ b/comfyui/workflows/solarrenderer_low_memory.json@@ -0,0 +1,2220 @@+{+ "id": "60ca832f-7ac9-42c8-b751-71a9d7677d1b",+ "revision": 0,+ "last_node_id": 21,+ "last_link_id": 21,+ "nodes": [+ {+ "id": 1,+ "type": "UNETLoader",+ "pos": [+ 80,+ 110+ ],+ "size": [+ 270,+ 82+ ],+ "flags": {},+ "order": 0,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "unet_name",+ "locked": null,+ "name": "unet_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "unet_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "weight_dtype",+ "locked": null,+ "name": "weight_dtype",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "weight_dtype"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 1+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "UNETLoader"+ },+ "widgets_values": [+ "minimax_h3_ref2va_pruned_int8_convrot.safetensors",+ "default"+ ],+ "widgets_values_named": {+ "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",+ "weight_dtype": "default"+ }+ },+ {+ "id": 2,+ "type": "SolarRendererLoraLoader",+ "pos": [+ 472.9,+ 110+ ],+ "size": [+ 281.9,+ 82+ ],+ "flags": {},+ "order": 9,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 1+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "lora_name",+ "locked": null,+ "name": "lora_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "lora_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "strength",+ "locked": null,+ "name": "strength",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "strength"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 2+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererLoraLoader"+ },+ "widgets_values": [+ "solarrenderer_4step_lora.safetensors",+ 1+ ],+ "widgets_values_named": {+ "lora_name": "solarrenderer_4step_lora.safetensors",+ "strength": 1+ }+ },+ {+ "id": 3,+ "type": "SolarRendererLoraLoader",+ "pos": [+ 834.8,+ 110+ ],+ "size": [+ 281.9,+ 82+ ],+ "flags": {},+ "order": 11,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 2+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "lora_name",+ "locked": null,+ "name": "lora_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "lora_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "strength",+ "locked": null,+ "name": "strength",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "strength"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 21+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererLoraLoader"+ },+ "widgets_values": [+ "solarrenderer_control_lora.safetensors",+ 1+ ],+ "widgets_values_named": {+ "lora_name": "solarrenderer_control_lora.safetensors",+ "strength": 1+ }+ },+ {+ "id": 4,+ "type": "SolarRendererModel",+ "pos": [+ 1683.6999999999998,+ 110+ ],+ "size": [+ 363.9,+ 82+ ],+ "flags": {},+ "order": 14,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 3+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "seed",+ "locked": null,+ "name": "seed",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "seed"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 9+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererModel"+ },+ "widgets_values": [+ 0,+ "randomize"+ ],+ "widgets_values_named": {+ "seed": 0,+ "control_after_generate": "randomize"+ }+ },+ {+ "id": 5,+ "type": "CLIPLoader",+ "pos": [+ 80,+ 302+ ],+ "size": [+ 270,+ 106+ ],+ "flags": {},+ "order": 1,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "clip_name",+ "locked": null,+ "name": "clip_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "clip_name"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "type",+ "locked": null,+ "name": "type",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "type"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "device",+ "locked": null,+ "name": "device",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "device"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "CLIP",+ "locked": null,+ "name": "CLIP",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CLIP",+ "pos": null,+ "slot_index": null,+ "links": [+ 5+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "CLIPLoader"+ },+ "widgets_values": [+ "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",+ "minimax",+ "default"+ ],+ "widgets_values_named": {+ "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",+ "type": "minimax",+ "device": "default"+ }+ },+ {+ "id": 6,+ "type": "VAELoader",+ "pos": [+ 80,+ 518+ ],+ "size": [+ 270,+ 58+ ],+ "flags": {},+ "order": 2,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae_name",+ "locked": null,+ "name": "vae_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "vae_name"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VAE",+ "locked": null,+ "name": "VAE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "slot_index": null,+ "links": [+ 6+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAELoader"+ },+ "widgets_values": [+ "minimax_h3_video_vae_fp16.safetensors"+ ],+ "widgets_values_named": {+ "vae_name": "minimax_h3_video_vae_fp16.safetensors"+ }+ },+ {+ "id": 7,+ "type": "LoadVideo",+ "pos": [+ 80,+ 686+ ],+ "size": [+ 280,+ 234+ ],+ "flags": {},+ "order": 3,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "file",+ "locked": null,+ "name": "file",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "file"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "choose file to upload",+ "locked": null,+ "name": "upload",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGEUPLOAD",+ "widget": {+ "name": "upload"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VIDEO",+ "locked": null,+ "name": "VIDEO",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": [+ 4+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "LoadVideo"+ },+ "widgets_values": [+ "structure.mp4",+ "image"+ ],+ "widgets_values_named": {+ "file": "structure.mp4",+ "upload": "image"+ }+ },+ {+ "id": 8,+ "type": "GetVideoComponents",+ "pos": [+ 472.9,+ 302+ ],+ "size": [+ 191.9,+ 106+ ],+ "flags": {},+ "order": 10,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "link": 4+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "images",+ "locked": null,+ "name": "images",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 7+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio",+ "locked": null,+ "name": "audio",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "AUDIO",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "fps",+ "locked": null,+ "name": "fps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "bit_depth",+ "locked": null,+ "name": "bit_depth",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "pos": null,+ "slot_index": null,+ "links": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "color_space",+ "locked": null,+ "name": "color_space",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "GetVideoComponents"+ }+ },+ {+ "id": 9,+ "type": "LoadImage",+ "pos": [+ 80,+ 1030+ ],+ "size": [+ 280,+ 314+ ],+ "flags": {},+ "order": 4,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "image",+ "locked": null,+ "name": "image",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "image"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "choose file to upload",+ "locked": null,+ "name": "upload",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGEUPLOAD",+ "widget": {+ "name": "upload"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "IMAGE",+ "locked": null,+ "name": "IMAGE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 8+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MASK",+ "locked": null,+ "name": "MASK",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MASK",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "LoadImage"+ },+ "widgets_values": [+ "first.png",+ "image"+ ],+ "widgets_values_named": {+ "image": "first.png",+ "upload": "image"+ }+ },+ {+ "id": 10,+ "type": "SolarRendererConditioning",+ "pos": [+ 834.8,+ 302+ ],+ "size": [+ 400,+ 240+ ],+ "flags": {},+ "order": 12,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "clip",+ "locked": null,+ "name": "clip",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CLIP",+ "pos": null,+ "link": 5+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae",+ "locked": null,+ "name": "vae",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "link": 6+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "structure",+ "locked": null,+ "name": "structure",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "link": 7+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "first_frame",+ "locked": null,+ "name": "first_frame",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "IMAGE",+ "pos": null,+ "link": 8+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "structure_vae",+ "locked": null,+ "name": "structure_vae",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "VAE",+ "pos": null,+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "prompt",+ "locked": null,+ "name": "prompt",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "STRING",+ "widget": {+ "name": "prompt"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "width",+ "locked": null,+ "name": "width",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "width"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "height",+ "locked": null,+ "name": "height",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "height"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "length",+ "locked": null,+ "name": "length",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "length"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "positive",+ "locked": null,+ "name": "positive",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CONDITIONING",+ "pos": null,+ "slot_index": null,+ "links": [+ 10+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "latent",+ "locked": null,+ "name": "latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 15+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererConditioning"+ },+ "widgets_values": [+ "subject_definitions:\n<Video 1> is a semantic segmentation of the scene, one flat colour per class (road, sidewalk, building, vegetation, vehicle, pedestrian, sky and so on), frame by frame, from the same camera as the target video.\n<Video 2> is the first frame of [Shot 1], held still.\n\nsummary:\n[keyframe completion + reference generation] The target video begins from <Video 2> and follows the frame-by-frame structure and motion of <Video 1>. A retro synthwave highway run: a neon-trimmed coupe overtakes a glowing semi-truck, flies under a neon gantry and overpass at dusk, and slides back into its lane.\n\nretention_analysis:\n<Video 1> (frame-by-frame layout of every class and camera): attribute_transfer - every region keeps its class, outline and place; materials, colours and lighting are not given by <Video 1>; the flat class colours are not shown.\n<Video 2> ([Shot 1] first frame): fully_preserved - the composition, subjects, materials, colours and lighting of <Video 2> are the target video's first frame.\n\ndetailed_description:\nThe target video is a stylised synthwave animation in the look of an eighties retro-futuristic music video, with a magenta-to-violet sunset gradient sky, a huge striped setting sun on the horizon, neon pink and cyan edge lighting, glossy reflective surfaces and a light film grain. [Shot 1] The shot begins from <Video 2>. The camera trails a few metres behind and above a black wedge-shaped sports coupe with a glowing cyan light strip across its tail, in the right lane of a six-lane divided highway whose lane lines glow hot pink. Ahead sits the back of a chrome semi-trailer outlined in purple neon, pulled by a tractor with a glowing grille. After half a second the coupe glides left into the middle lane, the camera tilting with it, and begins to close on the truck. The trailer's mirror-like side slides by on the right, reflecting the sunset, then its glowing wheels and the cab with chrome stacks, passing within a couple of metres. Midway, a gantry with two glowing signs in retro lettering sweeps overhead. Further up the road, tail lights of an SUV and a sedan streak away in the fast lane, with a hatchback, a box truck and a van glowing ahead. Across a dark median lined with tall lamp posts topped by pink light bars, oncoming cars and a coach race past as streaks of white light. Near the end the coupe flashes under a concrete overpass trimmed with neon tubes, while a glowing SUV and a delivery truck cross above, their light trails painting streaks along the bridge railing. Clear of the truck, the coupe slides back into the right lane toward the setting sun. The coupe stays planted through every move, rocking slightly over expansion joints, and the camera follows with a slight lag so each lane change feels smooth, heavy and rhythmic, like a slow camera move in a music video. Guard rails gleam with reflected pink light, palm-like trees and stylised pines stand as black silhouettes, utility poles and their wires cut thin lines across the gradient sky, and low warehouses with glowing windows and purple hills fade toward a wireframe-like horizon.\n\noverall_soundscape:\nSmooth tyre roar and wind with a punchy engine note as the coupe overtakes, a deep whoosh past the truck and a hollow echo under the overpass.\n\nnon_diegetic_music:\nN/A",+ 1344,+ 768,+ 158+ ],+ "widgets_values_named": {+ "prompt": "subject_definitions:\n<Video 1> is a semantic segmentation of the scene, one flat colour per class (road, sidewalk, building, vegetation, vehicle, pedestrian, sky and so on), frame by frame, from the same camera as the target video.\n<Video 2> is the first frame of [Shot 1], held still.\n\nsummary:\n[keyframe completion + reference generation] The target video begins from <Video 2> and follows the frame-by-frame structure and motion of <Video 1>. A retro synthwave highway run: a neon-trimmed coupe overtakes a glowing semi-truck, flies under a neon gantry and overpass at dusk, and slides back into its lane.\n\nretention_analysis:\n<Video 1> (frame-by-frame layout of every class and camera): attribute_transfer - every region keeps its class, outline and place; materials, colours and lighting are not given by <Video 1>; the flat class colours are not shown.\n<Video 2> ([Shot 1] first frame): fully_preserved - the composition, subjects, materials, colours and lighting of <Video 2> are the target video's first frame.\n\ndetailed_description:\nThe target video is a stylised synthwave animation in the look of an eighties retro-futuristic music video, with a magenta-to-violet sunset gradient sky, a huge striped setting sun on the horizon, neon pink and cyan edge lighting, glossy reflective surfaces and a light film grain. [Shot 1] The shot begins from <Video 2>. The camera trails a few metres behind and above a black wedge-shaped sports coupe with a glowing cyan light strip across its tail, in the right lane of a six-lane divided highway whose lane lines glow hot pink. Ahead sits the back of a chrome semi-trailer outlined in purple neon, pulled by a tractor with a glowing grille. After half a second the coupe glides left into the middle lane, the camera tilting with it, and begins to close on the truck. The trailer's mirror-like side slides by on the right, reflecting the sunset, then its glowing wheels and the cab with chrome stacks, passing within a couple of metres. Midway, a gantry with two glowing signs in retro lettering sweeps overhead. Further up the road, tail lights of an SUV and a sedan streak away in the fast lane, with a hatchback, a box truck and a van glowing ahead. Across a dark median lined with tall lamp posts topped by pink light bars, oncoming cars and a coach race past as streaks of white light. Near the end the coupe flashes under a concrete overpass trimmed with neon tubes, while a glowing SUV and a delivery truck cross above, their light trails painting streaks along the bridge railing. Clear of the truck, the coupe slides back into the right lane toward the setting sun. The coupe stays planted through every move, rocking slightly over expansion joints, and the camera follows with a slight lag so each lane change feels smooth, heavy and rhythmic, like a slow camera move in a music video. Guard rails gleam with reflected pink light, palm-like trees and stylised pines stand as black silhouettes, utility poles and their wires cut thin lines across the gradient sky, and low warehouses with glowing windows and purple hills fade toward a wireframe-like horizon.\n\noverall_soundscape:\nSmooth tyre roar and wind with a punchy engine note as the coupe overtakes, a deep whoosh past the truck and a hollow echo under the overpass.\n\nnon_diegetic_music:\nN/A",+ "width": 1344,+ "height": 768,+ "length": 158+ }+ },+ {+ "id": 11,+ "type": "KSamplerSelect",+ "pos": [+ 80,+ 1454+ ],+ "size": [+ 270,+ 58+ ],+ "flags": {},+ "order": 5,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "sampler_name",+ "locked": null,+ "name": "sampler_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "sampler_name"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "SAMPLER",+ "locked": null,+ "name": "SAMPLER",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SAMPLER",+ "pos": null,+ "slot_index": null,+ "links": [+ 13+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "KSamplerSelect"+ },+ "widgets_values": [+ "lcm"+ ],+ "widgets_values_named": {+ "sampler_name": "lcm"+ }+ },+ {+ "id": 12,+ "type": "SolarRendererSigmas",+ "pos": [+ 80,+ 1622+ ],+ "size": [+ 312.9,+ 58+ ],+ "flags": {},+ "order": 6,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "steps",+ "locked": null,+ "name": "steps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "steps"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "SIGMAS",+ "locked": null,+ "name": "SIGMAS",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SIGMAS",+ "pos": null,+ "slot_index": null,+ "links": [+ 14+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererSigmas"+ },+ "widgets_values": [+ 4+ ],+ "widgets_values_named": {+ "steps": 4+ }+ },+ {+ "id": 13,+ "type": "RandomNoise",+ "pos": [+ 80,+ 1790+ ],+ "size": [+ 270,+ 82+ ],+ "flags": {},+ "order": 7,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "noise_seed",+ "locked": null,+ "name": "noise_seed",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "INT",+ "widget": {+ "name": "noise_seed"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "NOISE",+ "locked": null,+ "name": "NOISE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "NOISE",+ "pos": null,+ "slot_index": null,+ "links": [+ 11+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "RandomNoise"+ },+ "widgets_values": [+ 0,+ "randomize"+ ],+ "widgets_values_named": {+ "noise_seed": 0,+ "control_after_generate": "randomize"+ }+ },+ {+ "id": 14,+ "type": "BasicGuider",+ "pos": [+ 2127.6,+ 110+ ],+ "size": [+ 159,+ 46+ ],+ "flags": {},+ "order": 15,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 9+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "conditioning",+ "locked": null,+ "name": "conditioning",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "CONDITIONING",+ "pos": null,+ "link": 10+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "GUIDER",+ "locked": null,+ "name": "GUIDER",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "GUIDER",+ "pos": null,+ "slot_index": null,+ "links": [+ 12+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "BasicGuider"+ }+ },+ {+ "id": 15,+ "type": "SamplerCustomAdvanced",+ "pos": [+ 2366.6,+ 110+ ],+ "size": [+ 211.9,+ 106+ ],+ "flags": {},+ "order": 16,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "noise",+ "locked": null,+ "name": "noise",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "NOISE",+ "pos": null,+ "link": 11+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "guider",+ "locked": null,+ "name": "guider",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "GUIDER",+ "pos": null,+ "link": 12+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "sampler",+ "locked": null,+ "name": "sampler",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SAMPLER",+ "pos": null,+ "link": 13+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "sigmas",+ "locked": null,+ "name": "sigmas",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "SIGMAS",+ "pos": null,+ "link": 14+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "latent_image",+ "locked": null,+ "name": "latent_image",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 15+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "output",+ "locked": null,+ "name": "output",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 16+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "denoised_output",+ "locked": null,+ "name": "denoised_output",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "SamplerCustomAdvanced"+ }+ },+ {+ "id": 16,+ "type": "LTXVSeparateAVLatent",+ "pos": [+ 2658.5,+ 110+ ],+ "size": [+ 168.9,+ 46+ ],+ "flags": {},+ "order": 17,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "av_latent",+ "locked": null,+ "name": "av_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 16+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video_latent",+ "locked": null,+ "name": "video_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": [+ 17+ ]+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio_latent",+ "locked": null,+ "name": "audio_latent",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {+ "Node name for S&R": "LTXVSeparateAVLatent"+ }+ },+ {+ "id": 17,+ "type": "VAELoader",+ "pos": [+ 80,+ 1982+ ],+ "size": [+ 270,+ 58+ ],+ "flags": {},+ "order": 8,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae_name",+ "locked": null,+ "name": "vae_name",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "vae_name"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VAE",+ "locked": null,+ "name": "VAE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "slot_index": null,+ "links": [+ 18+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAELoader"+ },+ "widgets_values": [+ "minimax_h3_video_vae_fp16.safetensors"+ ],+ "widgets_values_named": {+ "vae_name": "minimax_h3_video_vae_fp16.safetensors"+ }+ },+ {+ "id": 18,+ "type": "VAEDecode",+ "pos": [+ 2907.4,+ 110+ ],+ "size": [+ 140,+ 46+ ],+ "flags": {},+ "order": 18,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "samples",+ "locked": null,+ "name": "samples",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "LATENT",+ "pos": null,+ "link": 17+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "vae",+ "locked": null,+ "name": "vae",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VAE",+ "pos": null,+ "link": 18+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "IMAGE",+ "locked": null,+ "name": "IMAGE",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "slot_index": null,+ "links": [+ 19+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "VAEDecode"+ }+ },+ {+ "id": 19,+ "type": "CreateVideo",+ "pos": [+ 3127.4,+ 110+ ],+ "size": [+ 270,+ 150+ ],+ "flags": {},+ "order": 19,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "images",+ "locked": null,+ "name": "images",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "IMAGE",+ "pos": null,+ "link": 19+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "audio",+ "locked": null,+ "name": "audio",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "AUDIO",+ "pos": null,+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "fps",+ "locked": null,+ "name": "fps",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "FLOAT",+ "widget": {+ "name": "fps"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "bit_depth",+ "locked": null,+ "name": "bit_depth",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "bit_depth"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "color_space",+ "locked": null,+ "name": "color_space",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "color_space"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "codec",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMBO",+ "widget": {+ "name": "codec"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "VIDEO",+ "locked": null,+ "name": "VIDEO",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": [+ 20+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "CreateVideo"+ },+ "widgets_values": [+ 24,+ "auto",+ "sRGB",+ "none"+ ],+ "widgets_values_named": {+ "fps": 24,+ "bit_depth": "auto",+ "color_space": "sRGB",+ "codec": "none"+ }+ },+ {+ "id": 20,+ "type": "SaveVideo",+ "pos": [+ 3477.4,+ 110+ ],+ "size": [+ 270,+ 130+ ],+ "flags": {},+ "order": 20,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "link": 20+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "filename_prefix",+ "locked": null,+ "name": "filename_prefix",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "STRING",+ "widget": {+ "name": "filename_prefix"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "format",+ "locked": null,+ "name": "format",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "format"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "format.codec",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "format.codec"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "codec",+ "locked": null,+ "name": "codec",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "codec"+ },+ "link": null+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "encoding",+ "locked": null,+ "name": "codec.encoding",+ "nameLocked": null,+ "removable": null,+ "shape": 7,+ "type": "COMFY_DYNAMICCOMBO_V3",+ "widget": {+ "name": "codec.encoding"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "video",+ "locked": null,+ "name": "video",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "VIDEO",+ "pos": null,+ "slot_index": null,+ "links": null+ }+ ],+ "properties": {},+ "widgets_values": [+ "solarrenderer_lowvram",+ "mp4",+ "auto",+ "h264",+ "auto"+ ],+ "widgets_values_named": {+ "filename_prefix": "solarrenderer_lowvram",+ "format": "mp4",+ "format.codec": "auto",+ "codec": "h264",+ "codec.encoding": "auto"+ }+ },+ {+ "id": 21,+ "type": "SolarRendererFastAttention",+ "pos": [+ 1314.8,+ 110+ ],+ "size": [+ 288.9,+ 58+ ],+ "flags": {},+ "order": 13,+ "mode": 0,+ "showAdvanced": null,+ "inputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "model",+ "locked": null,+ "name": "model",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "link": 21+ },+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "backend",+ "locked": null,+ "name": "backend",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "COMBO",+ "widget": {+ "name": "backend"+ },+ "link": null+ }+ ],+ "outputs": [+ {+ "color_off": null,+ "color_on": null,+ "dir": null,+ "label": null,+ "localized_name": "MODEL",+ "locked": null,+ "name": "MODEL",+ "nameLocked": null,+ "removable": null,+ "shape": null,+ "type": "MODEL",+ "pos": null,+ "slot_index": null,+ "links": [+ 3+ ]+ }+ ],+ "properties": {+ "Node name for S&R": "SolarRendererFastAttention"+ },+ "widgets_values": [+ "auto"+ ],+ "widgets_values_named": {+ "backend": "auto"+ }+ }+ ],+ "links": [+ [+ 1,+ 1,+ 0,+ 2,+ 0,+ "MODEL"+ ],+ [+ 2,+ 2,+ 0,+ 3,+ 0,+ "MODEL"+ ],+ [+ 3,+ 21,+ 0,+ 4,+ 0,+ "MODEL"+ ],+ [+ 4,+ 7,+ 0,+ 8,+ 0,+ "VIDEO"+ ],+ [+ 5,+ 5,+ 0,+ 10,+ 0,+ "CLIP"+ ],+ [+ 6,+ 6,+ 0,+ 10,+ 1,+ "VAE"+ ],+ [+ 7,+ 8,+ 0,+ 10,+ 2,+ "IMAGE"+ ],+ [+ 8,+ 9,+ 0,+ 10,+ 3,+ "IMAGE"+ ],+ [+ 9,+ 4,+ 0,+ 14,+ 0,+ "MODEL"+ ],+ [+ 10,+ 10,+ 0,+ 14,+ 1,+ "CONDITIONING"+ ],+ [+ 11,+ 13,+ 0,+ 15,+ 0,+ "NOISE"+ ],+ [+ 12,+ 14,+ 0,+ 15,+ 1,+ "GUIDER"+ ],+ [+ 13,+ 11,+ 0,+ 15,+ 2,+ "SAMPLER"+ ],+ [+ 14,+ 12,+ 0,+ 15,+ 3,+ "SIGMAS"+ ],+ [+ 15,+ 10,+ 1,+ 15,+ 4,+ "LATENT"+ ],+ [+ 16,+ 15,+ 0,+ 16,+ 0,+ "LATENT"+ ],+ [+ 17,+ 16,+ 0,+ 18,+ 0,+ "LATENT"+ ],+ [+ 18,+ 17,+ 0,+ 18,+ 1,+ "VAE"+ ],+ [+ 19,+ 18,+ 0,+ 19,+ 0,+ "IMAGE"+ ],+ [+ 20,+ 19,+ 0,+ 20,+ 0,+ "VIDEO"+ ],+ [+ 21,+ 3,+ 0,+ 21,+ 0,+ "MODEL"+ ]+ ],+ "floatingLinks": null,+ "groups": [],+ "definitions": null,+ "config": {},+ "extra": {+ "ds": {+ "scale": 0.9,+ "offset": [+ 416,+ 110+ ]+ },+ "reroutes": null+ },+ "version": 0.4+}\ No newline at end of file