Auto Setting Optimizer 2

About Auto Setting Optimizer 2 – Unity Editor Tool & Plugin

Auto Setting Optimizer 2 Unity Asset Overview

The Auto Setting Optimizer 2 utility acts as a runtime dynamic performance evaluation and settings scaling layer designed for Unity applications. Built around a decoupled controller pattern, the asset decouples hardware benchmarking logic from render setting mutation, preventing tight coupling between game logic and platform-specific graphics APIs.

Core Architectural Components

The system relies on three main execution layers:

• Hardware & Hardware-Capability Assessor: Queries SystemInfo properties (such as SystemInfo.graphicsMemorySize, SystemInfo.processorCount, and SystemInfo.graphicsDeviceType) upon application launch to establish a baseline quality preset profile.
• Runtime Frame Timing Evaluator: Monitors target frame rates using a low-overhead, rolling-window delta-time calculator. To avoid frame-rate spikes caused by isolated garbage collection passes, the evaluator utilizes exponential moving averages (EMA) across configurable sample buffers.
• Profile State Machine & Mutation Dispatcher: Executes dynamic tier shifting (e.g., Ultra down to High, or Medium up to High) based on customizable stability thresholds, dispatching C# events to notify registered camera systems and lighting managers.

ScriptableObject Data Strategy

The system uses ScriptableObject assets to define quality presets and optimization profiles. Rather than hardcoding quality tiers directly into C# scripts, each profile stores explicit parameters for field-of-view thresholds, shadow draw distances, MSAA sample counts, render scaling factors, and anisotropic filtering levels. This approach allows developers to duplicate, version-control, and swap setting profiles across target platforms (Standalone, Mobile, Console) without recompiling codebase assets.

Inspector Configuration & Workflow

The custom editor extension for Auto Setting Optimizer 2 enhances developer productivity by presenting complex performance matrices in a organized layout inside the Unity Inspector. Through serialized property drawers, parameters are organized logically based on dynamic threshold triggers and targeted render settings.

Configuration Blueprint

When configuring the optimizer, parameters are mapped directly into specialized inspector modules:

• Target FPS & Tolerance Window: Defines target frame rates (e.g., 60 FPS) alongside upper and lower tolerance margins to prevent constant rapid profile swapping (hysteresis).
• Cooldown Timers: Configures stabilization duration timers ensuring the system waits a set number of seconds before applying lower or higher quality tiers following an environment load or scene transition.
• Camera & Pipeline Overrides: Provides direct bindings for active Unity Camera components, standard Render Pipeline settings, or Universal Render Pipeline (URP) Asset instances.

Quick-Start Unity Integration Guide

Integrating Auto Setting Optimizer 2 into a project requires attaching the main optimizer controller to a persistent scene object and binding dynamic camera adjustments through C# delegates.

Step-by-Step Setup

1. Instantiate the core manager prefab into your initial bootstrap scene.
2. Assign your target OptimizerSettingsSO ScriptableObject profile to the manager component.
3. Reference your main rendering Camera within the manager’s Inspector slots.
4. Attach custom trigger listeners via code to adjust gameplay-specific properties (e.g., particle density, dynamic occlusion distances) upon quality shift events.

Implementation Example: Custom Quality Event Listener

Below is a clean C# integration bridge showing how to register custom events dispatched by the setting optimizer manager without creating GC allocations:

using UnityEngine;

namespace TechnicalAnalysis.Optimization
{
    public class CustomQualityBridge : MonoBehaviour
    {
        [SerializeField] private AutoSettingOptimizerManager optimizerManager;
        [SerializeField] private Camera mainCamera;

        private void OnEnable()
        {
            if (optimizerManager != null)
            {
                optimizerManager.OnQualityProfileChanged += HandleQualityProfileChanged;
            }
        }

        private void OnDisable()
        {
            if (optimizerManager != null)
            {
                optimizerManager.OnQualityProfileChanged -= HandleQualityProfileChanged;
            }
        }

        private void HandleQualityProfileChanged(QualityProfile newProfile)
        {
            if (mainCamera == null) return;

            // Apply camera dynamic clip distances based on profile settings
            mainCamera.farClipPlane = newProfile.CameraFarClipDistance;
            
            // Log architectural state changes
            Debug.Log($"[Optimizer] Applied state: {newProfile.ProfileName} | Shadow Distance: {newProfile.ShadowDistance}");
        }
    }
}

Performance Profiling & Optimization Analysis

A high-frequency optimization tool must not create performance issues of its own. Analysis under Unity’s Profiler reveals a minimal CPU and memory footprint when configured according to production standards.

Garbage Collection & Memory Management

The monitoring routines inside Auto Setting Optimizer 2 execute without runtime heap allocations. Sample buffers for frame time calculations use pre-allocated fixed-size arrays or struct buffers. Dynamic string concatenations are avoided entirely within the sample evaluation loops, ensuring that zero garbage collection (0 B GC Alloc) activity is generated during active gameplay updates.

IL2CPP and Ahead-Of-Time (AOT) Compilation

The core C# source code avoids heavy reflection calls during dynamic updates. Hardware specifications are queried once at startup and cached in memory. Method execution pathways rely on lightweight C# delegates rather than dynamic string-based SendMessage routines, ensuring full compatibility with IL2CPP compilation across mobile and console target platforms without requiring complex link.xml stripping exceptions.

Related Unity Tools Assets