tea-x-random/unity-game-skills / skills/unity-graphics
unity-graphics
VerifiedTake 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"):
- Real textured surfaces, not flat fills. Solid-color ground/background and procedural blobs are placeholders, not a look.
- Cohesive generated art across all primary surfaces — ground, backdrop, hero props, and UI share one art direction.
- 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)
- Bias to a verified, screenshot-proven result, not docs. A change is "done" when a
manage_scenescreenshot looks intentional andmanage_graphicsrender stats stay in budget — not when a setting matches a tutorial. - Keep gates lean. Decide art direction and the URP/quality tier once, then proceed with sensible mobile defaults. Don't prompt at every slider.
- Edit through MCP, never raw YAML.
.mat,.shader, URP assets, lighting data, andVolumeprofiles are GUID/fileID YAML — hand-editing corrupts references. Go throughmanage_graphics,manage_material,manage_texture,manage_shader,manage_scene, andexecute_code. - 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 thedocsgroup). Trust order: reflection > project assets > docs > memory. - Verify with two signals every pass: a
manage_scene(action="screenshot")ANDmanage_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
renderPipelineis empty/Built-in and you want URP: installcom.unity.render-pipelines.universal(viamanage_packages), create a URP asset + Universal Renderer, and assign it in Graphics + Quality settings. Do this throughexecute_codedrivingUniversalRenderPipelineAsset+GraphicsSettings.defaultRenderPipeline, thenrefresh_unity. Seereferences/urp-mobile-recipes.md. - The
manage_graphics,manage_material,manage_texture,manage_shadertools live in thevfx/ core groups. If a call says the tool is unavailable, runmanage_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(semanticpalette.rolesfirst).GameTheme.cscolor 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
lightingblock (key/fill/rim/shadow/fog qualities). The key light's direction MUST matchcraft.light_direction, which equals composition.yamlshadow_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 followrendering.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
UnityPerMaterialblock). 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 withmanage_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
Volumewith 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.SetQualityLevelviaexecute_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, thenstats_getto 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.
- Confirm URP active (Step 0); enable
vfxgroup. - 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. - One directional light aimed per the spec's
craft.light_direction/ compositionkey_light_direction, Baked + Light Probes for movers;bake_lighting. - Add fog for depth and a gradient/skybox backdrop.
- Add a global Volume: Tonemapping (ACES), gentle Color Adjustments, Vignette, low Bloom on emissive accents only.
- Add particle pops on key gameplay events for juice.
- Screenshot +
stats_get; trim materials/overdraw until 60fps and the frame looks designed, not primitive.
References
references/urp-mobile-recipes.md— ordered MCP /execute_coderecipes: 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
Imagestrips) 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.colorreads 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.
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: 198k | 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: 194k | 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: 194k | 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: 194k | Updated | Claude CodeCodex | Verified | Install |