home / skills / dev-gom / claude-code-marketplace / unity-scene-optimizer

unity-scene-optimizer skill

safe

/plugins/unity-dev-toolkit/skills/unity-scene-optimizer

This skill analyzes Unity scenes for rendering, texture, and hierarchy bottlenecks and provides actionable optimization recommendations.

npx playbooks add skill dev-gom/claude-code-marketplace --skill unity-scene-optimizer

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.2 KB

---
name: Unity Scene Optimizer
description: Analyzes scenes for performance bottlenecks (draw calls, batching, textures, GameObjects). Use when optimizing scenes or investigating performance issues.
allowed-tools: Read, Grep, Glob
---

# Unity Scene Optimizer

Analyzes Unity scenes and provides performance optimization recommendations for rendering, physics, memory, and platform-specific concerns.

## What This Skill Analyzes

### 1. Rendering Performance
Analyzes draw calls (target: <100 mobile, <2000 desktop), identifies batching opportunities, recommends material consolidation and static batching.

### 2. Texture Optimization
Reviews compression formats (BC7/ASTC), mipmap usage, texture atlasing, and platform-specific import settings.

### 3. GameObject Hierarchy
Targets: <500 GameObjects mobile, <2000 desktop. Identifies deep nesting, recommends object pooling and LOD groups.

### 4. Lighting and Shadows
Recommends baked lighting over realtime (1-2 lights mobile, 3-4 desktop), minimal shadow-casting lights.

### 5. Physics Optimization
Analyzes Rigidbody count, collider complexity, collision matrix configuration. Recommends simple colliders over Mesh colliders.

### 6. Mobile-Specific
Platform targets: 60 FPS iOS (iPhone 12+), 30-60 FPS Android. See [mobile-checklist.md](mobile-checklist.md) for complete requirements.

## Optimization Workflow

1. **Measure**: Frame Debugger, Stats, Profiler metrics
2. **Identify**: GPU/CPU/Memory/Physics bottlenecks
3. **Apply**: Quick wins (static batching, compression) → Medium (atlases, pooling, LOD) → Major (hierarchy refactor, culling)
4. **Validate**: Compare before/after metrics

See [optimization-workflow.md](optimization-workflow.md) for detailed steps and timelines.

## Platform-Specific Targets

| Platform | Draw Calls | Triangles | Texture Memory | Lights |
|----------|-----------|-----------|----------------|--------|
| **Mobile Low** | <50 | <20k | <100MB | 1 |
| **Mobile Mid** | <100 | <50k | <250MB | 1-2 |
| **Mobile High** | <150 | <100k | <500MB | 2-3 |
| **PC Low** | <500 | <200k | <1GB | 3-4 |
| **PC Mid** | <1000 | <500k | <2GB | 4-6 |
| **PC High** | <2000 | <1M | <4GB | 6-8 |
| **Console** | <1000 | <800k | <3GB | 4-6 |

## Tools Reference

Frame Debugger, Profiler, Stats Window, Memory Profiler. See [tools-reference.md](tools-reference.md) for usage and commands.

## Output Format

Provides: Current metrics, bottleneck identification, prioritized recommendations, performance impact estimates, implementation steps.

## When to Use vs Other Components

**Use this Skill when**: Analyzing scene performance, identifying bottlenecks, or getting optimization recommendations

**Use @unity-performance agent when**: Implementing complex optimizations, profiling at runtime, or troubleshooting specific performance issues

**Use @unity-architect agent when**: Redesigning scene architecture, implementing object pooling systems, or planning large-scale optimizations

**Use /unity:optimize-scene command when**: Running comprehensive scene analysis with detailed reports

## Related Skills

- **unity-script-validator**: For script-level performance issues
- **unity-template-generator**: For optimized component templates

Overview

This skill inspects Unity scenes and produces actionable performance recommendations for rendering, textures, physics, memory, and platform-specific constraints. It summarizes current metrics, pinpoints bottlenecks, and returns prioritized fixes with estimated impact and implementation steps. Use it to quickly triage scene slowdowns and guide optimization efforts before deeper profiling or refactors.

How this skill works

The optimizer scans scene data (draw calls, GameObject hierarchy, materials, textures, lights, colliders, rigidbodies) and compares values against platform targets (mobile, PC, console). It flags issues such as excessive draw calls, large texture memory, deep hierarchy nesting, and expensive colliders, then suggests quick, medium, and major optimizations. Outputs include current metrics, bottleneck classification (GPU/CPU/memory/physics), prioritized recommendations, and validation steps.

When to use it

Before publishing or building to confirm platform performance budgets
When frame rate drops or memory spikes are observed during QA
While optimizing a heavy scene for mobile or lower-end hardware
When consolidating art assets (materials, textures, atlases)
During sprint reviews to estimate optimization effort and impact

Best practices

Measure first: capture Profiler, Frame Debugger, and Stats before changes
Target platform budgets (draw calls, triangles, texture memory) and tune to the lowest expected device
Prefer static batching and GPU instancing for many similar objects
Use compressed textures, mipmaps, and atlases to reduce memory and draw calls
Replace complex MeshColliders with primitive colliders and use pooling for dynamic objects

Example use cases

Analyze a mobile level that drops below 60 FPS and get prioritized fixes
Audit a scene after importing a large art pack to identify texture and material consolidation opportunities
Validate optimization work by comparing before/after metrics and estimated impact
Prepare a PC-to-mobile port by adjusting light counts, shadows, and texture settings
Estimate work required to refactor a deeply nested GameObject hierarchy for better culling and LOD

FAQ

Does the skill change scene assets automatically?

No. It provides recommendations and implementation steps. Use the suggestions manually or with other tooling/agents to apply changes.

Which metrics does it report?

It reports draw calls, triangle counts, texture memory, GameObject counts and depth, light/shadow usage, Rigidbody/collider counts, and platform-specific targets.