summerengine/summer/create-asset-sheet

create-asset-sheet — Generate a coherent pack of 2D assets

This skill turns a single prompt into a categorized pack of isolated, named 2D assets ready to drop into a game. Generating assets one by one loses visual coherence between them and leaves you matting backgrounds by hand; one sheet keeps the pack consistent.

Pipeline:

1. Generate a sheet of N isolated assets in one image-gen call.
2. Remove the background so each asset can stand on its own.
3. Detect, name and classify each asset in one vision pass (bounding box + snake_case name + category per region).
4. Crop each region.
5. Optionally upscale any small slice, preserving aspect.
6. Save as a single pack ArtAsset with packFiles: [{url, name, type}] and metadata.sliceBboxes.

Categories the classifier outputs (used to route into downstream pipelines): character | terrain | nature | lighting | water | decorative | buildings | ui | vfx

When to use

• "Make me a Japanese village tileset."
• "Generate a sci-fi UI kit — buttons, panels, icons."
• "I need 12 fantasy props for a dungeon — chest, torch, skeleton, gold, etc."
• "Give me a character pack: 6 cute monsters."
• "Build a forest biome — trees, rocks, plants, ground tiles."

When NOT to use

• The user wants a single asset → pixel-art or character-portrait.
• The user wants character animation (walk cycle, attack frames) → sprite-sheet.
• The user wants 3D models of a planned pack → not yet supported in one shot; loop concept-art → image-to-3D per item, or use asset-strategy to pick the right path.
• The user wants terrain tiles that connect seamlessly (auto-tiling / Wang tiles) → tileable-texture is the right home for edge logic; this skill produces standalone tiles, not edge variants.

The cleanest path: the studio wizard

The most reliable way to run this flow is the Create Asset Sheet wizard in Summer Studio's guided workflows. Open it for the user with summer open workflows (or studio.open) if they're working in the browser. The wizard:

• Offers a 2D / 3D mode toggle (2D is the slice flow described here; 3D is a soft pointer to concept-art + per-asset image-to-3D for now)
• Surfaces six prompt templates (tile sheet, UI kit, menu, character pack, biome, freeform)
• Lets the user upload an existing sheet if they have one (skip generation)
• Shows variants in a grid with full-screen lightbox + arrow-key toggling
• Runs the full slice pipeline on click
• Has per-slice HD upscale + bulk "Upscale all"
• Saves as a pack ArtAsset visible in the user's library

If the user is in a chat / agent context, use the programmatic path below. It calls the same server-side slicer as the Studio wizard.

Programmatic path (chat / agent driving the engine)

1. Load the exact current recipe. Call

summer_call({op: "docs.workflows", input: {workflowId: "asset-pack"}}). Follow its ordered steps and report any manual handoff instead of pretending it ran.

1. Generate the sheet. Call assets.generate_image with a prompt like:

`` <theme> asset sheet: <comma-separated list of items>. Each item isolated with empty space around it, transparent or neutral background. ``

• Pick model by style: pixel art → grok-imagine, painterly / illustrative / structured grids → gpt-image-2.
• Square (aspectRatio: "1:1", the default, about 1024x1024) is the sweet spot. Larger sheets fragment in the slicer when individual assets get below ~64px.
• Keep the asset list to 6–20 items per sheet. Past 20, model attention degrades and slices get muddy.

1. Slice, remove background, detect, name, classify, crop, and save. Pass

the returned image asset id to:

`` assets.slice_sheet({ assetId: "<generated asset id>" }) ``

This is the same cloud slicing pipeline used by the Studio flow. It answers slices (each with url, name, category, bbox) and source; keep the names and categories, and do not reimplement the vision boxes locally. Slicing spends credits: dryRun: true shows how many.

1. Optional upscale. The Studio wizard has per-slice HD upscale. Over MCP, for any crop where the longest side is under 256px, call assets.generate_image with the slice url as referenceImageUrl and this prompt:

`` Recreate this exact <name> at high resolution. Preserve every detail, the exact pose, the exact style. Sharper edges, more detail. Transparent background. Single isolated asset, no scene. ``

• Don't upscale everything: each upscale is a paid generation, and large slices gain little.

1. Import what the game needs. The slices are image URLs, not assets: import

them with summer_import_from_url_batch (upscaled ones by their assetId with summer_import_asset_by_id). Keep the source pack in My Assets so the agent and the human Studio session see the same result.

Prompt patterns that work

Tile sheet (terrain + props + buildings):

<setting> tile sheet: <terrain tiles>, <props>, <buildings>. Each item isolated with empty space around it.

UI kit:

<theme> game UI kit: round button, square button, panel background, slider, toggle switch, progress bar, icon set, banner header.

Menu screen:

<theme> main menu UI: title banner, Start Game button, Settings button, Quit button, <background style>, ornate frame, decorative element.

Character pack:

<theme> character pack, single front-facing frame each: <character 1>, <character 2>, ... <character N>. Each isolated.

Biome:

<biome name> biome assets: <flora>, <terrain features>, <rocks/water/sky elements>. Each item isolated.

Common failure modes

Without Summer Engine

In a session without Summer Engine tools (the assets profile; the summer-assets skill has the whole loop), the studio wizard path works as written. On the programmatic path, stop after assets.slice_sheet and skip summer_import_asset_by_id: save each piece where the person asked with assets.get and out (the summer-assets skill says how), and tell them the paths.

What this skill does NOT do (yet)

• Per-asset planning and individual generation, where each asset is generated separately at full resolution.
• 3D pack assembly. The 3D mode in the wizard is a placeholder pointer to concept-art + image-to-3D for now.
• Character animation routing. Once a slice is classified as character, the next step (sprite-sheet generation) is a separate skill that the user has to invoke manually.
• Terrain auto-tiling / Wang-tile generation. Use tileable-texture for that.
• Level composition / scene assembly. Use design-level.

<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->

From a shell

No Summer MCP tools in this session? Run each one as a command; when summer --version is missing or below 4.0, use npx -y summer-engine@latest in place of summer. Fields are flags in kebab-case (--scene-path res://main.tscn) or one --input '<json>', and summer ops describe <op> prints the exact input. The summer-cli skill has the rest.

<!-- /shell-commands -->