Unity 2d Core

Unity 2D Core

Sprite import settings (pixel art)

Texture Type        Sprite (2D and UI)
Sprite Mode         Single (or Multiple for sprite sheets)
Pixels Per Unit     32 (or 16 / 64 — pick ONE project-wide)
Mesh Type           Tight (saves overdraw on alpha sprites)
Pivot               Bottom for floor-anchored entities; Center for projectiles
Filter Mode         Point (no filter) for crisp pixel art; Bilinear for smooth art
Compression         None (pixel art) — Compression artifacts wreck pixels
Generate Mip Maps   Off for 2D

For HD vector-style art: keep PPU consistent; use Bilinear filter; allow ASTC/Crunch compression (mobile size).

Sprite Atlas v2

Atlas = combine many sprites into one texture so they share a draw call.

Window > 2D > Sprite Atlas
- Type: Master (default) or Variant (low-res derivation)
- Include in Build: ON
- Allow Rotation / Tight Packing: tune for empty space vs runtime cost
- Object for Packing: drag folders/sprites in

Variants: a 0.5 scale Variant of a Master atlas → mobile gets the smaller textures, desktop the master. Toggle by build target.

SpriteAtlasManager.atlasRequested for late-bound atlases (Addressables-friendly).

Sorting

Three orthogonal mechanisms, applied in this order:

1. Sorting Layer — broad strokes (Background, World, Characters, FX, UI).
2. Order in Layer — fine integer within a layer.
3. Sorting Group — wraps a parent + children so they sort as one unit (a knight + their weapon + their VFX).

Sorting Group is the key tool for multi-part 2D characters — without it, Z-fighting between sprite parts ruins the look.

// Optional dynamic order based on Y (top-down RPGs)
void LateUpdate() => _renderer.sortingOrder = -(int)(transform.position.y * 100);

9-slice

For UI panels, banners, expandable decorations:

Sprite Editor → Border (left/right/top/bottom in pixels)
Sprite Renderer → Draw Mode = Sliced (or Tiled)

Drag the Sprite Renderer scale → corners stay rigid, edges stretch / tile.

PPU consistency

Pick one PPU for all sprites in a level. Mixing 16 and 32 sprites in the same scene creates inconsistent pixel sizes and sub-pixel sampling artifacts.

For mixed art assets that genuinely have to coexist: use Sprite > Edit Sprite to set custom physics shapes and pivots, but keep PPU equal.

Pixel Perfect Camera

Add PixelPerfectCamera component to your Camera. Settings:

Reference Resolution    320 × 180  (or 480 × 270, 640 × 360 — base canvas)
Assets PPU              same as your sprites
Crop Frame              Letterbox (preserves aspect, adds black bars)
                        or Stretch Fill (stretches; only for tiny variations)
Pixel Snapping          ON  (snaps every renderer to integer pixels)
Upscale Render Texture  ON for clean integer scaling

Without Pixel Perfect Camera you get sub-pixel jitter as the camera moves.

AI-assisted sprite pipeline (Aseprite-native tools)

For static sprites (props, items, environments, tiles) AI generators are productive. No AI tool today produces ship-ready output zero-touch — every sprite needs an Aseprite cleanup pass before importing into Unity.

Tools that install as Aseprite extensions

All four install via Edit > Preferences > Extensions > Add Extension and expose AI panels inside the Aseprite UI.

License pitfalls (avoid for shipping)

• Leonardo.ai free tier — Leonardo retains rights to your outputs. Paid only for full ownership.
• Recraft free tier — outputs owned by Recraft, made public in gallery.
• Scenario.com free tier — "personal/evaluation only", do not ship.
• Midjourney / DALL-E / Recraft — produce anti-aliased "pixel-styled" output, not crisp pixels. Need 8× nearest-neighbour downscale + palette quantise to be usable as sprites.

Mandatory cleanup before Unity import

1. Spritefusion Pixel Snapper (spritefusion.com/pixel-snapper) — free Rust CLI that snaps off-grid pixels back onto integer coordinates and quantises the palette. Run on every AI-generated sprite before opening in Aseprite.
2. Aseprite touch-up — palette unification, edge cleanup, transparency. Even Retro Diffusion / PixelLab outputs benefit from a quick pass.
3. Unity import settings (set on the asset, not in code):

   Texture Type        Sprite (2D and UI)
   Pixels Per Unit     match project-wide PPU (see "PPU consistency" section)
   Filter Mode         Point  (no filter)        — anti-aliasing ruins pixel art
   Compression         None                       — JPEG-style compression destroys palette
   Generate Mip Maps   OFF                        — 2D doesn't need mips
   Wrap Mode           Clamp (or Repeat for tileable backgrounds)
   

Decision tree (what to use when)

For animation-specific AI tools (walk cycles, 4/8-directional sprites), see the unity-2d-animation skill — it's a different problem.

Anti-patterns

Production checklist

• Single project-wide PPU
• All gameplay sprites in a Sprite Atlas v2
• Sorting Layers + Sorting Group strategy documented
• Pixel Perfect Camera configured (if pixel art)
• Atlas Variants set up for mobile (if shipping mobile)
• Filter / Compression appropriate to art style
• No sub-pixel jitter when camera follows player