Skip to content

tea-x-random/unity-game-skills / skills/unity-graphics

unity-graphics

Verified

Take a basic-looking Unity casual-iOS scene to a premium, intentional look. Use for URP setup, mobile rendering, lighting (baked lighting, light probes, reflection probes), materials and shaders (URP/Lit, URP/Unlit, GPU instancing, SRP batcher), post-processing (Volume, bloom, color adjustments, vignette), draw calls, batches, overdraw, quality settings, tiered quality, visual polish, art direction, and render quality. Triggers when screenshots look flat/primitive or the user asks for premium, stylized, polished, AAA-on-mobile, or less-basic 3D visuals on iOS.

Unity Graphics (Casual iOS)

Own the render/visual pass for casual iOS games in Unity. Convert flat, primitive-looking screenshots into an intentional, stylized, performance-safe look that still hits 60fps on phones.

The AAA visual bar (don't ship flat)

A premium look requires three things, and missing any one reads as amateur ("MS Paint"):

  1. Real textured surfaces, not flat fills. Solid-color ground/background and procedural blobs are placeholders, not a look.
  2. Cohesive generated art across all primary surfaces — ground, backdrop, hero props, and UI share one art direction.
  3. A properly LIT and composed scene. A scene of raw sprites/meshes on a solid color stays flat until it is lit + composed.

Division of labor: art direction, per-surface asset sourcing, and the visual scorecard are owned by unity-aaa-graphics (the sibling skill that decides what art to generate and gates the result). This skill provides the render-pipeline mechanics — URP, lighting, materials, post — that you MUST actually apply on top of that art. Generating real art is necessary but not sufficient: raw assets dropped on a solid color still look flat until this skill's lighting + composition pass runs.

Amateur anti-patterns to refuse:

  • Flat solid-color ground or background (use a textured surface + designed backdrop/gradient).
  • Procedural SDF blobs standing in for primary surfaces or hero props (procedural is a fallback skin and for UI shapes — see below — not a substitute for real art).
  • No lighting and no shadows — an unlit scene reads flat regardless of asset quality.
  • A hard-oval vignette used as the only "lighting." Vignette is mood trim, not light.

Core Doctrine (same spine as the rest of the unity-* set)

  1. Bias to a verified, screenshot-proven result, not docs. A change is "done" when a manage_scene screenshot looks intentional and manage_graphics render stats stay in budget — not when a setting matches a tutorial.
  2. Keep gates lean. Decide art direction and the URP/quality tier once, then proceed with sensible mobile defaults. Don't prompt at every slider.
  3. Edit through MCP, never raw YAML. .mat, .shader, URP assets, lighting data, and Volume profiles are GUID/fileID YAML — hand-editing corrupts references. Go through manage_graphics, manage_material, manage_texture, manage_shader, manage_scene, and execute_code.
  4. Unity 6 render APIs differ from memory. The model's built-in knowledge is ~Unity 2022.3. On Unity 6 (6000.x), RenderGraph, URP Volume components, and Renderer Features changed. Before writing any shader or render C#, verify against the live Editor with unity_reflect / unity_docs (enable the docs group). Trust order: reflection > project assets > docs > memory.
  5. Verify with two signals every pass: a manage_scene(action="screenshot") AND manage_graphics(action="stats_get") render stats (draw calls / batches / SetPass / tris). One without the other is not verification.

Step 0 — Confirm the pipeline before touching visuals

Read mcpforunity://project/info and check renderPipeline.

  • Casual iOS uses URP. Not HDRP (too heavy for phones), not Built-in (no SRP Batcher, dated). If it reports HDRP or Built-in, flag it and plan a switch to URP.
  • If renderPipeline is empty/Built-in and you want URP: install com.unity.render-pipelines.universal (via manage_packages), create a URP asset + Universal Renderer, and assign it in Graphics + Quality settings. Do this through execute_code driving UniversalRenderPipelineAsset + GraphicsSettings.defaultRenderPipeline, then refresh_unity. See references/urp-mobile-recipes.md.
  • The manage_graphics, manage_material, manage_texture, manage_shader tools live in the vfx / core groups. If a call says the tool is unavailable, run manage_tools(action="enable_group", group="vfx") first. Volume / post-FX actions require URP (or HDRP) to be the active pipeline.

Explicit input — art-spec.yaml drives palette, lighting, and post

When the project has an art-spec.yaml (canonical path + legacy roots in docs/PIPELINE_CONVENTIONS.md), this skill CONSUMES it — never improvise a scene-local look:

  • Palette: materials, backdrop/skybox, and fog colors come from the spec's palette (semantic palette.roles first). GameTheme.cs color hexes MUST equal art-spec palette hexes exactly — colors only (typography/spacing/radii are GameTheme-native, no art-spec source).
  • Lighting: implement the spec's lighting block (key/fill/rim/shadow/fog qualities). The key light's direction MUST match craft.light_direction, which equals composition.yaml shadow_and_contact.key_light_direction — ONE light direction shared by baked-in art, contact shadows, and the realtime sun. Do not invent a second source of truth for light direction.
  • Post & shaders: the global Volume implements rendering.post; materials follow rendering.shader_family.

No art-spec (exploratory/prototype)? Proceed with this skill's defaults, flag the look as unlocked, and route to unity-art-direction before production art.

Mobile-first lighting

Lighting is REQUIRED for a premium scene, not optional polish: raw sprites/meshes on a solid color stay flat until they are lit and grounded with shadows. Never leave the scene unlit. That said, realtime per-pixel lighting is the most common framerate killer on phones — default to baked.

  • Bake static lighting. Mark static geometry, set lights to Baked (or Mixed only when you truly need a realtime caster), and bake lightmaps via manage_graphics(action="bake_lighting"). Baked GI gives soft, premium shading for free at runtime.
  • At most one realtime light, ideally a single directional sun. Every extra realtime light multiplies draw cost; point/spot realtime lights on mobile are a last resort.
  • Light Probes for moving/dynamic objects so they pick up the baked ambience instead of looking flat and detached. Place a probe group across the playable area.
  • Reflection Probes sparingly — one baked probe for a shiny hero object is fine; blanketing the scene is not. Prefer baked, low-resolution.
  • Shadows: keep one shadow-casting light, low cascade count (1), tight shadow distance, and hard or low-res soft shadows. Most casual scenes look great with baked AO and a single blob/contact shadow instead of full realtime shadows.

Materials

  • URP/Lit for surfaces that need real shading; URP/Unlit for stylized flat-color/gradient art. Unlit is the cheapest path and looks intentional for hyper-casual — lean on it.
  • Enable GPU Instancing on every shared material (enableInstancing) so repeated props batch.
  • Keep materials SRP Batcher compatible (URP shaders are by default; custom shaders must use a CBUFFER UnityPerMaterial block). SRP Batcher + GPU instancing are how you keep draw calls low.
  • Keep material and texture variants low — fewer unique materials = fewer SetPass calls. Share one atlas/material across many objects.
  • Author with manage_material (create, set shader, set _BaseColor/_BaseMap/_Smoothness/_Metallic, toggle instancing). Compress textures with manage_texture (ASTC for iOS).

Post-processing on mobile (conservative)

A premium frame is lit AND tone-mapped: apply a mobile-safe post pass — don't leave the scene raw. Post is a force-multiplier for "premium" but only if you stay cheap. (Vignette is mood trim layered on top of real lighting, never the lighting itself.)

  • Use one global Volume with a profile. Enable post on the renderer asset and tick Post Processing on the Camera.
  • Safe, cheap-ish: Bloom (low threshold, modest intensity), Color Adjustments / White Balance / Tonemapping (ACES or Neutral), Vignette, slight Lift/Gamma/Gain. These define the mood.
  • Avoid on low-end phones: SSAO, Depth of Field, Motion Blur, Chromatic Aberration at strength, full-res Bloom. They cost fill rate the GPU doesn't have.
  • Tonemapping on a clean color palette does most of the work. Add bloom last, sparingly, on emissive accents only.

Performance-safe visual detail (look premium cheaply)

Detail you can afford on a phone:

  • Stylized flat-color / gradient palette instead of PBR realism — reads as "designed," batches well, no heavy textures.
  • Bake AO into textures / vertex colors so shading looks grounded with zero realtime cost.
  • Vertex colors for cheap per-object tinting and gradients without extra materials.
  • Fog (linear/exponential) for depth and to hide draw distance — a strong, near-free mood tool.
  • Billboards / impostors for distant detail (trees, clouds, crowds) instead of real geometry.
  • Particle pops / juice (collect, land, win bursts) for perceived quality — small, short-lived, additive.
  • A skybox or gradient backdrop + a clear focal palette beats any amount of glow on primitives.

Build forms and palette first; add bloom/particles last. Glow on primitives is not premium.

Procedural sprites as a FALLBACK skin (2D, no art needed). Real generated art (see unity-aaa-graphics) is the default and the upgrade; this procedural path is the PLACEHOLDER for when an asset-generator key is MISSING or quota-blocked. It is also legitimately useful for UI shapes (rounded cards, buttons, dividers) even alongside real art. A rounded-rect sprite from a signed-distance field into a Texture2D (soft anti-aliased alpha edge), created once and reused via a 9-slice Image (Sprite.Create(..., border) + Image.type = Sliced), gives crisp rounded corners at any size. Tint comes from Image.color, so highlights still work. Pair with the warm palette above and the board/buttons read as designed cards, not flat rectangles. Swap in generated art through the same Image.sprite slot as soon as a generator key is available.

When art is genuinely blocked (no image-gen key / quota), the same SDF approach yields a coherent placeholder skin with zero external assets: rounded-rect 9-slice tiles/buttons and recognizable icon tokens — e.g. a simple character/mascot face composited from circle/ellipse SDFs with proper alpha-over blending. Cache each generated Sprite in a static field (generate once) so you pay the rasterization cost a single time, and tint per-use via Image.color. This keeps a colorful, cohesive board on screen with no external assets — but treat it as a stopgap, NOT a premium look. Flat fills and procedural blobs are not a substitute for real textured, lit art; restore the generated-art path (unity-aaa-graphics) the moment the generator is unblocked.

Procedural icon library for action bars / HUD (fallback when art is blocked). Beyond shapes, you can draw a clean vector-style icon set at runtime — lightbulb, undo arrow, trash, home, heart — at ~256px from SDF primitives (circle, rounded box, thick segment/capsule, plus union/subtract), rendered white-on-transparent so each tints via Image.color and is anti-aliased by edge coverage. Cache each once in a static field. This reads like a real game-icon set with no external assets and is a solid stand-in for HUD/icon glyphs when a generator key is missing — prefer generated icon art (unity-aaa-graphics) when available. Present them as themed icon buttons — palette-tinted rounded tile + dark icon + label — which read far better than plain white buttons for near-zero cost.

Region/grid borders (Queens/Sudoku/region-map puzzles). Draw bold dark dividers only on region BOUNDARIES — an edge where a cell's 4-neighbor is a different region or the board edge — and thin light gridlines elsewhere; this contrast is what makes a colored region read as one solid blob instead of loose cells. Implementation that works: per-cell thin Image strips on boundary edges only, each strip's pivot CENTERED on the edge so it straddles the cell-spacing gap and meets the neighbor's strip as one continuous thick line — no global texture alignment needed. Only boundary edges get strips, so it stays perf-friendly.

Cohesive themed art direction (when asked for ANY named look). A theme-neutral recipe that reads as intentional, regardless of the aesthetic requested: a single unified GROUND treatment + a single unified PANEL treatment + a deliberately limited, coherent palette (chosen so gameplay regions stay distinguishable for puzzle readability) + generous negative space + one or two signature motifs, with gloss and saturation dialed to match the chosen theme (high gloss/candy for playful, low gloss/muted for minimal). The recipe is the same across themes — only the tokens change: e.g. zen-minimal, neon-retro, watercolor-storybook, or flat-pastel all plug the same slots (ground, panels, palette, motif). Because the whole look flows from the palette, a token swap in one theme ScriptableObject reskins the entire game instantly — author themes as data, not per-element color.

Flat-2D depth kit (fallback that lifts a flat board off "MS Paint" with zero art). Three cheap procedural overlays, each generated once and cached in a static field: (a) a vertical 2-stop gradient backdrop (a tiny Texture2D stretched full-screen) instead of a flat fill; (b) a radial vignette overlay (transparent center → dark edges, ~0.5 strength), full-screen and non-raycast; (c) soft drop shadows = an offset dark rounded-rect Image inserted directly BEHIND a panel via SetSiblingIndex(targetIndex). Together they add depth and focus on a 2D uGUI board when no art is available. The gradient backdrop is a baseline minimum (never ship a flat solid fill), but this kit is a fallback, not the premium target — generated backdrop/surface art (unity-aaa-graphics) plus a lit, composed scene is the upgrade.

Quality settings & tiered quality

  • Define quality tiers (e.g. Low for old devices, High for recent) differing in shadow distance/resolution, MSAA, render scale, pixel light count, and post-FX enabled.
  • On iOS, gate by device class at startup and pick the tier (QualitySettings.SetQualityLevel via execute_code).
  • Old-device tier: render scale < 1.0, no MSAA or 2x, shadows off or blob-only, post = tonemap + vignette only. New-device tier: render scale 1.0, MSAA 2–4x, baked shadows, bloom on.

Budgets & verification (target 60fps)

  • Pull stats with manage_graphics(action="stats_get") — watch draw calls / batches / SetPass calls / triangles / overdraw.
  • Casual-iOS rough budgets: keep batches low (tens, not hundreds), SetPass calls minimal via SRP Batcher + instancing, tris modest, and overdraw under control (transparent/particle overlap is the usual culprit).
  • Every visual change: manage_scene(action="screenshot", include_image=true) to confirm it looks intentional, then stats_get to confirm it stays in budget. If a screenshot is dominated by primitives or flat planes, it's not done.

Basic scene → premium casual look (recipe)

Premium = real generated art (sourced via unity-aaa-graphics) ON the surfaces, with ALL of the mechanics below actually applied on top. Skipping the lighting/backdrop/post steps leaves the scene flat even with good art.

  1. Confirm URP active (Step 0); enable vfx group.
  2. Set the palette from art-spec palette.roles/arrays (no spec: a deliberate 3–6 color choice): stylized URP/Unlit or URP/Lit flat-color materials, GPU instancing on.
  3. One directional light aimed per the spec's craft.light_direction / composition key_light_direction, Baked + Light Probes for movers; bake_lighting.
  4. Add fog for depth and a gradient/skybox backdrop.
  5. Add a global Volume: Tonemapping (ACES), gentle Color Adjustments, Vignette, low Bloom on emissive accents only.
  6. Add particle pops on key gameplay events for juice.
  7. Screenshot + stats_get; trim materials/overdraw until 60fps and the frame looks designed, not primitive.

References

  • references/urp-mobile-recipes.md — ordered MCP / execute_code recipes: URP install + asset/renderer, mobile-friendly URP asset (shadows/HDR/MSAA tradeoffs), stylized unlit material, baked lighting workflow, conservative post Volume.
  • references/checklists/mobile-render-quality.md — render-quality gate before claiming premium.
  • references/checklists/perf-safe-visual-detail.md — cheap-but-premium technique checklist.

Final Response

Report the pipeline confirmed (URP), lighting approach (baked + probes), material/instancing/SRP-batcher state, post-FX used (and what was deliberately avoided), before/after render stats, and the verifying screenshot. State "loaded" vs "executed" precisely. Do not claim premium without a real, non-primitive screenshot plus in-budget stats.

Field notes & lessons

  • Framed procedural-SDF guidance as a FALLBACK skin (key missing / quota-blocked), not a premium path — rounded-rect 9-slice tiles/buttons plus icon tokens (e.g. a simple character face) composited from circle/ellipse SDFs with alpha-over blending, statically cached (generate once), tinted via Image.color. Real generated art (unity-aaa-graphics) is the default and the upgrade.
  • Added region/grid borders (bold dividers only on region boundaries via edge-centered-pivot Image strips) and a flat-2D depth kit (gradient backdrop + radial vignette + behind-panel drop shadow, statically cached).
  • Added procedural icon library (lightbulb/undo/trash/home/heart from SDF primitives, white-on-transparent so they tint via Image.color, statically cached) and themed icon buttons (tinted tile + dark icon + label) over plain white buttons.
  • AAA-casual action buttons are LAYERED, not flat. Recipe: SoftDisc drop-shadow (dark, offset down) + tintable ShadedCircle "ball" (grayscale with a top→bottom value gradient so a flat Image.color reads as 3D) + a SEPARATE white TopGloss specular overlay (key: multiply-tint can't brighten past the tint, so bake the specular as its own white low-alpha sprite on top) + bold white icon + label. This layered round-glossy-button-with-shadow recipe gives a dimensional, "made-by-a-studio" button when that's the look you want (keep buttons flat rects if the direction is minimal).
  • Added a cohesive themed art-direction recipe (theme-neutral: ground + panels + limited palette + negative space + signature motif; gloss/saturation matched to the theme); the look flows from the palette so one theme-object swap reskins the whole game.
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: 198kUpdated Claude CodeCodexVerifiedInstall
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: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
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: 194kUpdated Claude CodeCodexVerifiedInstall