Scenario Orbit Views

Overview

Asking an image model to "show it from behind" guesses the geometry, and each angle drifts in size, pose, and ground contact. The reliable route puts a 3D step in the middle: rebuild the subject as an untextured mesh, render a gray clay layout for every camera, then let a reference-capable image model repaint each layout from the original picture. The mesh fixes silhouette, scale, and perspective; the picture supplies identity, colors, and finish. Connection and the core generation loop: see the scenario skill. Image-to-3D model choice: scenario-3d. The background panorama: scenario-skyboxes. If a sibling skill named here is missing from your available skills, ask the user to install it (npx skills add scenario-labs/skills --skill <name>); unattended, proceed from tool schemas and flag the gap.

The Blender steps run locally in a shell with Blender 4.x or later; everything that generates goes through MCP tools. Check for Blender before the first paid step (on macOS it is usually /Applications/Blender.app/Contents/MacOS/Blender, not on the PATH). When it is missing, ask the user to install it, or unattended, stop and report it: no MCP tool renders a mesh from chosen cameras.

Quick reference

Step	How
Source picture	One subject, whole body with margin, plain background, a known camera (slightly above eye level, turned about 30 degrees)
Mesh	recommend an image-to-3D model, geometry only (texture is not needed), asset_download the GLB
World	A skybox panorama in the same art style, flat open floor all around the viewpoint
Camera zero	render_grounded.py --search, then match_view.py, confirmed by eye
Layouts	render_grounded.py, then compose_layout.py: background, clay, real cast shadow per camera
Upload	upload_asset with file_size, PUT the parts, upload_asset_complete, one per layout
Repaint	Reference-capable image model, referenceImages: [layout, source], prompt below
No background	Background-removal model on the same repainted frame, then studio_shadow.py
Wait	jobs_wait takes at most 32 ids per call; re-call with pending_job_ids

All four scripts are run by the agent in a local shell, not by the MCP server. render_grounded.py runs inside Blender (blender -b --factory-startup --python render_grounded.py -- ...); the other three need Python with Pillow and numpy. Each prints its usage when run without arguments.

Worked example: eight views plus top-down of one character

1. upload_asset the user's picture (or generate one with a plain background and the camera above), upload_asset_complete.

2. recommend an image-to-3D model with the user's words ("untextured mesh from one image"), plus max_cost_cu when the user set a budget, then model_schema_get and model_run with dry_run=true to price (image-to-3D jobs are expensive; a dry run rejects a payload missing its required image, so a quote for the whole chain before the source exists prices against any uploaded picture), then wait=false and jobs_wait. asset_download the GLB and save it with curl -L.

3. Find a skybox model with search (target="models", query="skybox", public=true, as scenario-skyboxes teaches; recommend has no skybox capability and can return a generic image model whose edges do not wrap) and generate one panorama in the picture's style, prompting for "viewpoint standing in the middle of an open empty floor at eye level, the floor clearly visible all around, no people". Download it.

4. blender ... render_grounded.py -- --glb hero.glb --out search --search, then python3 match_view.py hero.png search/cameras.json. The top row's azimuth and elevation are <az> and <el> below; open the matching search/search_az..._el...png next to the picture to confirm, since front and back can score alike.

5. blender ... render_grounded.py -- --glb hero.glb --pano world.png --out views --az0 <az> --elev <el> --only 00,02,04,06,08,10,12,14,top (the eye ring has 16 cameras, 22.5 degrees apart; --height sets the panorama eye height, --yaw turns the world, --zoom the framing). Keys count from camera zero, not from the subject's front, so with a turned source key 08 shows the back at that same turn; for views square to the subject, render into another --out with --az0 set to the search frame where it faces the camera squarely. Then python3 compose_layout.py views. Look at every layout: the clay must stand on the floor, with the shadow under it.

6. Upload each layout_<key>.jpg. recommend an image model for reference-guided repainting, and check that its model_schema_get lists referenceImages (1024 square, a high quality tier and an opaque background worked well). Price one with dry_run=true (the quote covers one view: multiply by the view count before launching), then launch one model_run per view with wait=false, referenceImages: ["<layout asset>", "<source asset>"], and:

   Image 1 is the exact final frame: a plain gray clay 3D model standing on the ground of a finished background, with its real cast shadow, seen from the exact camera angle wanted. Image 2 is the original design reference of the {kind}. Repaint the gray clay model as {what}, matching Image 2 for identity, design, materials and colors: {details}. {finish}. Follow the clay model exactly: same silhouette, pose, proportions, position and size in frame, and the same camera angle. {ground}; keep the cast shadow of Image 1. Keep the background of Image 1: same place, composition, perspective and horizon, in {background style}, crisp and detailed. Light the {kind} with the scene: {light}. No gray clay left, no extra characters or objects, no text.

   {ground} names the contact, for example "Her boots stand on the wet cobblestones exactly where the clay feet touch the ground". Add a line for parts the picture never shows (a shield on the back, a count of bags).

7. jobs_wait in batches of 32 or fewer. asset_download every result and build a contact sheet of all views. Regenerate only the views that fail; a fresh run of the same prompt usually fixes a one-off.

8. Transparent set: recommend a background-removal model, read its image field from model_schema_get, run it on each repainted asset id (not on a new studio repaint), download, then python3 studio_shadow.py views/clay_<key>.png cut_<key>.png studio_<key>.png. It prints how much of the clay body the cutout covers and how much lies outside it: a view far off the others, or with corners not clear, lost part of the subject or kept background, so rerun its removal.

Common mistakes

• Repainting each angle independently on a plain background: scale drifted 7 to 53 percent between views in testing. Repaint the grounded layout, and cut out that same frame.
• Compositing the subject over a flat background photo: it floats and the horizon does not move with the camera. The dome floor is what gives true perspective from above and below.
• Adding a third reference, such as a previous view of the same angle: its mistakes are copied (one run gained an extra bag on every back view). Keep two references unless the extra one is verified clean.
• A "harmonize" pass over a finished view: it re-crops the frame and breaks the alignment with the clay.
• Skipping camera zero: view 00 then does not match the picture the user started from.
• Hardcoding model ids or prices: discover with recommend, price with dry_run=true.
• Passing more than 32 ids to jobs_wait, or polling job_get.
• Trusting a view without looking: check contact sheets for extra limbs, wrong sides, and leftover gray clay.