oberconcejo/VS-CODE / .agents/skills/taste-application
taste-application
VerifiedGenerate new video against a distilled style pack and cut it into a finished piece - plan takes from the reference's cut rhythm, generate on fal, grade with the pack's measured LUT, cut at the measured cadence, weave in existing footage, composite overlay plates, mint 3D props, and verify the result numerically. Use when the user wants to make a video in a captured style, supplement existing footage, or assemble generated clips into a real edit.
scripts/mint3d.py
View on GitHub#!/usr/bin/env python3
"""Mint 3D props from a style pack, and render them back into footage.
Stage 2b of taste-forge, and the branch that used to dead-end.
Two ways in:
``--from-stills``
Lift a prop out of the reference itself. The pack's stills are frames of
the same world from different shots, so several of them can be passed as
multi-view input, which is the single biggest quality lever on the
endpoint - given one view the model invents the back of the object, and
invents it wrong.
``--prompt``
Generate a prop the reference implies but never shows cleanly. The pack's
distilled spec supplies the world; the prompt names the object in it.
Then the part that makes it a pipeline rather than an asset dump: the minted
mesh is rendered to a turntable locally and encoded to a clip. fal has no
endpoint that renders a mesh - the whole 3D category consumes 2D and emits
3D, or consumes 3D and emits 3D - so without a local renderer a minted GLB
can never re-enter the video graph. With one, a prop becomes footage, and
footage is something every later stage already handles: grade it with the
pack, cut it at the reference's cadence, screen it over a shot as an element,
or upload it as a conditioning reference for the video model.
python mint3d.py --genre flashethereal --from-stills 3 --render
python mint3d.py --genre flashethereal --prompt "a cracked chrome visor" --render
``--retopo`` adds a quad-remesh pass, which is what makes the prop editable
and riggable in Blender rather than merely renderable.
"""
from __future__ import annotations
import argparse
import json
import sys
from datetime import datetime, timezone
from pathlib import Path
from taste import falapi
from taste import pack as pack_mod
from taste import render3d as r3
# The endpoint's own input guidance, turned into prompt text: "simple
# background, single object, object >50% of frame". This is not stylistic - a
# busy plate produces a busy mesh. The flashethereal stills are glitch collages
# with several subjects and heavy overlay graphics, which is close to the worst
# possible input, so lifting a prop straight from them yields sculpted noise.
#
# Generating a clean plate first costs ~$0.15 and is the difference between a
# usable mesh and a discarded one.
PLATE_RULES = (
"A single isolated object centred on a plain neutral mid-grey seamless "
"background, filling most of the frame, evenly lit from three quarters, no "
"other objects, no text, no logos, no props, no shadows cast on the "
"backdrop, product-photography framing, sharp focus edge to edge, the whole "
"object visible with nothing cropped. Neutral colour, no colour grading."
)
def _asset_name(name: str | None, prompt: str) -> str:
words = prompt.split()
asset = name if name is not None else "prop_" + (words[0] if words else "lifted")
if (not asset or asset in {".", ".."} or len(asset) > 120
or any(not (c.isalnum() or c in "_-. ") for c in asset)
or asset != asset.strip()):
raise ValueError("asset name must be a simple filename stem (letters, digits, spaces, _.-)")
return asset
def _check_outputs(sp, asset: str) -> None:
"""Reject existing artifacts for this stem before any billable work."""
props = sp.dir / "props"
candidates = [props / f"{asset}{suffix}" for suffix in
(".glb", ".json", "_plate.png", "_retopo.glb")]
candidates += list(props.glob(f"{asset}_part*.glb"))
candidates += [sp.dir / "turntables" / asset,
sp.dir / "turntables" / f"{asset}.mp4"]
for path in candidates:
if path.exists() or path.is_symlink():
raise FileExistsError(f"asset output already exists; choose a new --name: {path}")
def mint3d(
genre: str,
root: str = "stylepacks",
from_stills: int = 0,
prompt: str = "",
plate: bool = False,
name: str | None = None,
pbr: bool = True,
retopo: bool = False,
split: bool = False,
render: bool = True,
frames: int = 48,
size: int = 768,
backend: str = "auto",
face_count: int | None = None,
) -> dict:
asset = _asset_name(name, prompt)
sp = pack_mod.load(genre, root=root)
_check_outputs(sp, asset)
props_dir = sp.dir / "props"
props_dir.mkdir(parents=True, exist_ok=True)
mode = "DRY RUN" if falapi.is_dry_run() else "live"
print(f"minting 3D for '{genre}' [{mode}] -> {asset}")
record: dict = {
"genre": genre,
"asset": asset,
"created": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
"dry_run": falapi.is_dry_run(),
"endpoints": {k: falapi.ENDPOINTS[k] for k in
("image_to_3d", "text_to_3d", "retopology", "part_split")},
}
if prompt and not plate:
spec = sp.read_json(sp.spec_path) or {}
# Ground the prompt in the pack so the prop belongs to the same world
# the footage does. Colour is deliberately excluded for the same
# reason apply.py excludes it: the LUT owns colour, and colour words
# here would bake a cast into the texture that then gets graded twice.
world = ", ".join(
str(v) for v in (spec.get("mood_adjectives") or [])[:3]
)
full = prompt if not world else f"{prompt}. Setting: {world}. Neutral colour, PBR materials."
print(f" text-to-3d : {full[:90]}")
mesh_url = falapi.text_to_3d(full, pbr=pbr)
record["prompt"] = full
elif plate:
# Two-step: text -> clean single-object plate -> mesh. This is the
# path to use unless the pack's stills genuinely are clean product
# shots, which reference reels almost never are.
spec = sp.read_json(sp.spec_path) or {}
world = ", ".join(str(v) for v in (spec.get("mood_adjectives") or [])[:3])
plate_prompt = f"{prompt}. {PLATE_RULES}"
if world:
plate_prompt += f" The object belongs to a world that reads as: {world}."
print(f" plate : generating clean single-object reference ...")
plate_urls = falapi.text_to_image(plate_prompt)
record["plate_prompt"] = plate_prompt
record["plate_url"] = plate_urls[0]
if not falapi.is_dry_run():
plate_path = props_dir / f"{asset}_plate.png"
falapi.download(plate_urls[0], plate_path)
record["plate"] = str(plate_path)
print(f" plate -> {plate_path}")
print(f" image-to-3d : from generated plate")
mesh_url = falapi.image_to_3d(plate_urls[0], pbr=pbr, face_count=face_count)
else:
stills = sp.stills()
if not stills:
raise SystemExit(f"pack '{genre}' has no stills - run mint.py first")
n = max(1, min(int(from_stills or 1), 8, len(stills)))
chosen = stills[:n]
print(f" image-to-3d : {n} view(s) - {', '.join(p.name for p in chosen)}")
urls = [falapi.upload(p) for p in chosen]
mesh_url = falapi.image_to_3d(urls, pbr=pbr, face_count=face_count)
record["stills"] = [p.name for p in chosen]
record["mesh_url"] = mesh_url
# The generated PBR original remains canonical, even if remeshing loses
# materials. Persist it before requesting any optional derivative.
mesh_path = props_dir / f"{asset}.glb"
falapi.download(mesh_url, mesh_path)
record["mesh"] = str(mesh_path)
print(f" mesh : {mesh_path}")
if retopo:
print(" retopology : quad remesh ...")
try:
retopo_url = falapi.retopologize(mesh_url, quad=True)
record["retopo_url"] = retopo_url
retopo_path = props_dir / f"{asset}_retopo.glb"
falapi.download(retopo_url, retopo_path)
record["retopo_mesh"] = str(retopo_path)
except falapi.FalError as exc:
print(f" !! retopology failed, keeping raw mesh: {exc}", file=sys.stderr)
if split:
print(" part split : segmenting ...")
try:
parts = falapi.split_parts(mesh_url)
paths = []
for i, u in enumerate(parts):
pp = props_dir / f"{asset}_part{i:02d}.glb"
falapi.download(u, pp)
paths.append(str(pp))
record["parts"] = paths
print(f" {len(paths)} part(s)")
except falapi.FalError as exc:
print(f" !! part split failed: {exc}", file=sys.stderr)
if render:
# The step that closes the loop. Skipped automatically on a dry run,
# where the "mesh" on disk is a text placeholder rather than a GLB.
if falapi.is_dry_run():
print(" render : skipped (dry run mesh is a placeholder)")
else:
turn_dir = sp.dir / "turntables" / asset
print(f" render : {frames} frames @ {size}px ...")
fr, used = r3.turntable(mesh_path, turn_dir, n_frames=frames,
size=size, backend=backend)
clip = sp.dir / "turntables" / f"{asset}.mp4"
r3.frames_to_video(fr, clip)
record["turntable"] = {"backend": used, "frames": len(fr), "clip": str(clip)}
print(f" {used} backend, {len(fr)} frames -> {clip}")
print(" this clip is now ordinary footage: grade it, cut it, "
"screen it, or use it as a conditioning reference")
manifest = props_dir / f"{asset}.json"
manifest.write_text(json.dumps(record, indent=2), encoding="utf-8")
print(f" manifest : {manifest}")
return record
def main() -> None:
ap = argparse.ArgumentParser(description="Mint 3D props from a style pack (stage 2b).")
ap.add_argument("--genre", required=True)
ap.add_argument("--root", default="stylepacks")
ap.add_argument("--from-stills", type=int, default=0,
help="lift a prop from N pack stills as multi-view input (1-8)")
ap.add_argument("--prompt", default="", help="generate a prop from text instead")
ap.add_argument("--plate", action="store_true",
help="with --prompt: generate a clean single-object image first, "
"then mesh THAT. Almost always better than text-to-3d or than "
"lifting from busy reference stills")
ap.add_argument("--name", default=None, help="asset name (default derived)")
ap.add_argument("--no-pbr", action="store_true", help="skip PBR texture maps")
ap.add_argument("--retopo", action="store_true", help="quad remesh for editability")
ap.add_argument("--split", action="store_true", help="segment into editable parts")
ap.add_argument("--no-render", action="store_true", help="skip the turntable render")
ap.add_argument("--frames", type=int, default=48)
ap.add_argument("--size", type=int, default=768)
ap.add_argument("--backend", default="auto", choices=["auto", "blender", "software"])
ap.add_argument("--face-count", type=int, default=None,
help="polygon budget, 40k-1.5M on the pro endpoint")
ap.add_argument("--tier", default=None, choices=["best", "fast", "value", "game"],
help="cost/quality tier for the 3D endpoints")
ap.add_argument("--dry-run", action="store_true")
a = ap.parse_args()
if a.dry_run:
falapi.enable_dry_run()
if a.tier:
for slot in ("image_to_3d", "text_to_3d"):
try:
print(f" {slot} -> {falapi.use_tier(slot, a.tier)}")
except falapi.FalError:
pass
if not a.prompt and not a.from_stills:
a.from_stills = 3
mint3d(a.genre, a.root, a.from_stills, a.prompt, a.plate, a.name, not a.no_pbr,
a.retopo, a.split, not a.no_render, a.frames, a.size, a.backend,
a.face_count)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 193k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 193k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 193k | Updated | Claude CodeCodex | Verified | Install |