Shipping a modern PC or Console game means dealing with an ocean of different hardware. To solve this, the industry adopted a standard: creating dozens of sliders and toggles in the options menu. Shadow Cascades, Texture Streaming, Ray Tracing, Anti-Aliasing.
We give control back to the player. But is this really the best solution?
The truth is that most players don't want to be performance engineers. They want to click "Play" and have a smooth experience. When the game stutters or the frame rate abruptly drops, the player doesn't blame their own graphics card, they blame the studio. And this reflects almost immediately in Steam reviews.
The Cost of Settings Engineering
Creating a robust settings menu in Unity (whether in Built-in, URP, or HDRP) consumes weeks of technical engineering. The team needs to:
- Create and balance Quality Tiers (Low, Medium, High, Ultra).
- Write dozens of scripts to bind UI elements (uGUI or UI Toolkit) to Unity's graphics API.
- Deal with the dreaded "Cyan Flash" or "Pink Flash", the stutter that occurs when a player changes a graphics quality setting and Unity has to compile a brand new shader in real-time.
At Ation Studios, we went through this multiple times. We knew we needed a solution that was Zero-Code for the UI, but heavy on backend engineering.
Prewarming Architecture
The biggest issue with manual quality swaps is shader variants. When you change URP shadows from Hard to Soft, a new shader variant is required.
To solve this once and for all, we built a cache extractor in our Automatic Graphics Settings (AGS) package. With one click in the Project Optimizations panel, AGS scans all scenes in the Build Settings, extracts the Keywords and Shaders in use, and generates a global AGS_ShaderCollection file. At runtime, the manager calls the WarmUp method invisibly, ensuring the cyan flash completely disappears, making LOD or Tier transitions perfectly smooth. The best part is you don't need to write a single line of code for this. It also allows pre-compiling specific shaders for each scene.
Dynamic Scalability
Even with a perfect menu, game intensity varies. A calm scene might run at 120 FPS, but a battle filled with particles and Screen Space Reflections (SSR) can drop the framerate to 25 FPS.
To protect the experience, we implemented a Dynamic Performance Monitor that analyzes raw data from Unity's FrameTimingManager. Instead of waiting for the player to pause the game and lower the quality, the tool acts preventively.
We use a SoftScaling strategy:
- The system calculates moving FPS averages.
- If the average drops below 90% of the target, AGS progressively disables the heaviest effects (SSR, Volumetric Clouds, SSGI) in the background.
- If the drop persists, it subtly reduces the render scale.
- When the action calms down for a few seconds, the effects are re-enabled.
All of this happens without the player even noticing.
Engineering's Best Friend
Building systems from scratch for every project is not scalable. That is why we packaged this architecture into Automatic Graphics Settings (AGS). It scans the UI using Reflection, connects all sliders and dropdowns to the graphics pipeline, applies SRP Batching and Texture Streaming optimizations, and injects the FPS monitor all in less than 5 minutes, without writing a single line of code.
The good news is that you don't need to reinvent the wheel in your studio.
AGS is already available on the Unity Asset Store, and soon for Unreal Engine and Godot as well. If you want to cut weeks off your development schedule and bulletproof your game against FPS drops, check out the documentation and try AGS today.
Lançar um jogo para PC ou Console modernos significa lidar com um oceano de hardwares diferentes. Para resolver isso, a indústria adotou um padrão: criar dezenas de sliders e botões no menu de opções. Shadow Cascades, Texture Streaming, Ray Tracing, Anti-Aliasing.
Nós damos o controle ao jogador. Mas será que isso é realmente a melhor solução?
A verdade é que a maioria dos jogadores não quer ser um engenheiro de performance. Eles querem clicar em "Jogar" e ter uma experiência fluida. Quando o jogo apresenta stuttering (engasgos) ou quedas bruscas de FPS, o jogador não culpa a própria placa de vídeo, ele culpa o estúdio. E isso se reflete quase que imediatamente nas reviews da Steam.
O Custo da Engenharia de Configurações
Criar um menu de configurações robusto no Unity (seja no Built-in, URP ou HDRP) consome semanas de engenharia técnica. A equipe precisa:
- Criar e balancear os Quality Tiers (Low, Medium, High, Ultra).
- Escrever dezenas de scripts para amarrar os botões da UI (uGUI ou UI Toolkit) à API de gráficos do Unity.
- Lidar com o temido "Cyan Flash" ou "Pink Flash", o engasgo que ocorre quando o jogador muda uma qualidade gráfica e o Unity precisa compilar um shader inédito em tempo real.
Na Ation Studios, passamos por isso múltiplas vezes. Sabíamos que precisávamos de uma solução que fosse Zero-Code para a interface, mas de engenharia pesada nos bastidores.
Arquitetura de Prewarming
O maior problema das trocas manuais de qualidade são as variantes de shader. Quando você muda as sombras do URP de Hard para Soft, uma nova variante de shader é exigida.
Para resolver isso de vez, construímos um extrator de cache no nosso pacote Automatic Graphics Settings (AGS). Com um clique no painel de Otimizações de Projeto, o AGS escaneia todas as cenas no Build Settings, extrai as Keywords e Shaders em uso, e gera um arquivo global AGS_ShaderCollection. No runtime, o gerenciador invoca o método WarmUp invisivelmente, garantindo que o flash ciano desapareça completamente, tornando as transições de LOD ou Tier perfeitamente suaves. A vantagem é que você não precisa escrever uma linha de código para isso. E ainda é possível pré-compilar shaders específicos para cada cena.
Escalabilidade Dinâmica
Mesmo com um menu perfeito, a intensidade do jogo varia. Uma cena calma pode rodar a 120 FPS, mas uma batalha com partículas e Screen Space Reflections (SSR) pode derrubar o framerate para 25 FPS.
Para proteger a experiência, implementamos um Dynamic Performance Monitor que analisa os dados brutas do FrameTimingManager do Unity. Em vez de depender do jogador pausar o jogo para baixar a qualidade, a ferramenta age preventivamente.
Utilizamos uma estratégia de SoftScaling:
- O sistema faz médias móveis de FPS.
- Se a média cair abaixo de 90% do alvo, o AGS desativa progressivamente os efeitos mais pesados (SSR, Volumetric Clouds, SSGI) em background.
- Se a queda persistir, ele reduz sutilmente a resolução de renderização.
- Quando a calmaria volta por alguns segundos, os efeitos são reativados.
Tudo isso acontece sem o jogador sequer perceber.
A Ferramenta a Favor da Engenharia
Construir sistemas do zero para cada projeto não é escalável. Foi por isso que empacotamos essa arquitetura no Automatic Graphics Settings (AGS). Ele varre a UI usando Reflection, conecta todos os sliders e dropdowns aos gráficos, aplica otimizações de SRP Batching e Texture Streaming e injeta o monitor de FPS tudo em menos de 5 minutos, sem escrever uma única linha de código.
A boa notícia é que você não precisa reinventar a roda no seu estúdio.
O AGS já está disponível na Unity Asset Store e logo em breve para Unreal Engine e Godot também. Se você quer cortar semanas do seu cronograma de desenvolvimento e blindar seu jogo contra quedas de FPS, confira a documentação e experimente o AGS hoje mesmo.
Automatic Graphics Settings
Effortlessly build robust graphics menus, manage cross-platform presets, and maintain smooth FPS.
View Asset
