Skip to content

performance.md

Latest commit

 

History

History
390 lines (291 loc) · 7.38 KB

performance.md

File metadata and controls

390 lines (291 loc) · 7.38 KB

Performance Optimization Guide

Performance optimization strategies and best practices for Life in Between XR.

Table of Contents

Performance Targets

Frame Rate

  • Minimum: 30 FPS
  • Target: 60 FPS
  • Consistent: Avoid frame drops

Memory

  • Target: < 500 MB
  • Peak: < 1 GB
  • Monitor: For memory leaks

Battery

  • Target: Reasonable drain
  • Monitor: During extended use
  • Optimize: Reduce unnecessary work

Network

  • Minimize: API calls
  • Cache: When possible
  • Batch: Multiple requests

Profiling

Unity Profiler

Access: Window > Analysis > Profiler

Key Metrics:

  • CPU usage
  • GPU usage
  • Memory usage
  • Rendering stats

Usage:

  1. Connect to device or use Editor
  2. Start profiling
  3. Use app normally
  4. Analyze results
  5. Identify bottlenecks

Profiler Sections

  1. CPU Usage:

    • Script execution time
    • Rendering time
    • Physics time
    • Garbage collection

  2. Memory:

    • Total allocated
    • Texture memory
    • Mesh memory
    • Audio memory

  3. Rendering:

    • Draw calls
    • Batches
    • Triangles
    • SetPass calls

Profiling Best Practices

  • Profile on actual device
  • Profile during typical usage
  • Profile extended sessions
  • Compare before/after optimizations

Optimization Strategies

Draw Call Optimization

Goal: Minimize draw calls

Strategies:

  1. Batching:

    • Use static batching for static objects
    • Use dynamic batching for small objects
    • Combine meshes when possible

  2. Atlas Textures:

    • Combine textures into atlases
    • Reduce texture switches
    • Use texture arrays

  3. LOD Groups:

    • Use LOD for complex objects
    • Reduce detail at distance
    • Optimize polygon count

Texture Optimization

Strategies:

  1. Compression:

    • Use appropriate compression
    • ETC2 for Android
    • Reduce texture sizes

  2. Mipmaps:

    • Enable mipmaps
    • Reduce memory usage
    • Improve performance

  3. Texture Size:

    • Use appropriate sizes
    • Power of 2 dimensions
    • Reduce unnecessary detail

Script Optimization

Strategies:

  1. Cache References:

    // Bad
void Update() {
    GetComponent<Renderer>().material.color = Color.red;
}

// Good
private Renderer m_renderer;
void Awake() {
    m_renderer = GetComponent<Renderer>();
}
void Update() {
    m_renderer.material.color = Color.red;
}

  2. Avoid Allocations:

    • Avoid creating objects in Update()
    • Reuse objects
    • Use object pooling

  3. Optimize Loops:

    • Minimize loop iterations
    • Cache array lengths
    • Use foreach sparingly

AR Performance

ARCore Optimization

Strategies:

  1. Plane Detection:

    • Limit plane detection frequency
    • Use appropriate plane detection mode
    • Disable when not needed

  2. Tracking:

    • Optimize tracking settings
    • Reduce tracking overhead
    • Use appropriate tracking mode

  3. Anchors:

    • Limit number of anchors
    • Remove unused anchors
    • Optimize anchor updates

AR Best Practices

  • Lighting: Ensure good lighting
  • Movement: Move device smoothly
  • Surfaces: Use textured surfaces
  • Distance: Maintain appropriate distance

3D Model Optimization

Model Guidelines

  1. Polygon Count:

    • Target: < 10k triangles per model
    • Use LOD for complex models
    • Simplify geometry

  2. Texture Optimization:

    • Compress textures
    • Use appropriate sizes
    • Combine textures

  3. Material Optimization:

    • Use simple shaders
    • Avoid complex materials
    • Batch objects with same material

LOD (Level of Detail)

Implementation:

  1. Create multiple LOD levels
  2. Use LOD Group component
  3. Set appropriate distances
  4. Test on device

Example:

  • LOD 0: Full detail (close)
  • LOD 1: Medium detail (medium distance)
  • LOD 2: Low detail (far)
  • LOD 3: Billboard (very far)

UI Performance

UI Optimization

Strategies:

  1. Canvas Optimization:

    • Use separate canvases
    • Static vs. dynamic separation
    • Reduce canvas updates

  2. Text Optimization:

    • Use TextMesh Pro
    • Cache text components
    • Minimize text updates

  3. Image Optimization:

    • Use sprite atlases
    • Compress images
    • Use appropriate formats

UI Best Practices

  • Minimize UI updates
  • Use object pooling for dynamic UI
  • Cache UI component references
  • Optimize animations

Memory Management

Memory Optimization

Strategies:

  1. Asset Management:

    • Unload unused assets
    • Use Resources.UnloadUnusedAssets()
    • Load assets on demand

  2. Texture Management:

    • Compress textures
    • Use appropriate formats
    • Unload unused textures

  3. Object Pooling:

    • Reuse objects
    • Avoid frequent instantiation
    • Pool frequently created objects

Memory Leaks

Prevention:

  • Remove event listeners
  • Unsubscribe from events
  • Dispose of resources
  • Clear references

Detection:

  • Use Profiler
  • Monitor memory over time
  • Check for increasing memory

Best Practices

General Optimization

  1. Profile First:

    • Don't optimize prematurely
    • Profile to find bottlenecks
    • Optimize based on data

  2. Incremental Optimization:

    • Optimize one thing at a time
    • Test after each change
    • Measure improvements

  3. Platform-Specific:

    • Optimize for target platform
    • Test on actual devices
    • Consider device limitations

Code Optimization

  1. Avoid in Update():

    • Expensive operations
    • Object creation
    • Component lookups

  2. Use Coroutines:

    • For delayed operations
    • For spread-out work
    • For async operations

  3. Optimize Data Structures:

    • Use appropriate collections
    • Cache frequently accessed data
    • Minimize data copying

Asset Optimization

  1. Import Settings:

    • Optimize import settings
    • Use appropriate compression
    • Set correct quality

  2. Asset Organization:

    • Organize assets logically
    • Remove unused assets
    • Use asset bundles if needed

Performance Checklist

Before Release

  • Frame rate acceptable (30+ FPS)
  • Memory usage reasonable (< 500 MB)
  • No memory leaks
  • Battery usage acceptable
  • Network usage optimized
  • Profiled on target devices
  • Tested extended sessions
  • Performance consistent

Optimization Priorities

  1. Critical:

    • Frame rate
    • Memory leaks
    • Crashes

  2. Important:

    • Memory usage
    • Battery usage
    • Network usage

  3. Nice to Have:

    • Minor optimizations
    • Quality improvements

Tools

Unity Tools

  • Profiler: Performance analysis
  • Frame Debugger: Rendering analysis
  • Memory Profiler: Memory analysis
  • Stats Panel: Runtime stats

External Tools

  • Android Profiler: Device profiling
  • Logcat: Android logs
  • GPU Profiler: GPU analysis

Monitoring

Runtime Monitoring

Monitor performance in production:

  • Frame rate
  • Memory usage
  • Crash reports
  • User feedback

Analytics

Track performance metrics:

  • Average frame rate
  • Memory usage
  • Battery impact
  • Network usage

Last Updated: 2024