
Výkon her ve Flutteru: jak udržet 60 FPS na telefonech střední třídy
Jak udržet stabilních 60 FPS ve Flutter hrách na telefonech střední třídy: profilování v DevTools, smyčka přes Ticker, RepaintBoundary a atlasy spritů.
Publikováno 13 min
Na této stránce
Mobilní hra spuštěná na špičkovém vývojářském telefonu dokáže snadno zamaskovat závažné architektonické nedostatky. Skutečný test nastává ve chvíli, kdy stejný kód nainstalujete na běžný smartphone střední třídy a animace začnou ztrácet snímky při každém částicovém efektu nebo přechodu obrazovky. Udržení stabilní snímkové frekvence ve Flutteru vyžaduje přesné pochopení toho, jak engine rozděluje práci mezi procesorová vlákna, proč zbytečné přestavby stromu widgetů přetěžují vykreslování a jak spolehlivě měřit záseky (jank).
V Psittacus Studio vytváříme mobilní logické hry v čistém Flutteru. Naším prvním projektem je Polydocu, hra postavená na luštění sudoku. I zdánlivě statická mřížka 9x9, obohacená o animovaná políčka, dynamické nápovědy, počítadla a přechody scén, dokáže na dostupnějším hardwaru okamžitě vyčerpat časový rozpočet snímku, pokud k ní přistupujete jako k běžné formulářové aplikaci. Tento průvodce shrnuje naše praktické poznatky z profilování a optimalizace herního kódu na reálných zařízeních.
Časový rozpočet snímku: 16,6 milisekundy v praxi
Při cílení na 60 snímků za sekundu má každý snímek k dispozici přesně 16,6 milisekundy na dokončení všech výpočtů a vykreslení pixelů. Na moderních displejích s frekvencí 120 Hz se toto časové okno zkracuje na 8,3 milisekundy. Pokud aplikace limit nestihne, grafický řadič zopakuje předchozí snímek, což hráč okamžitě vnímá jako nepříjemné škubnutí.
Flutter organizuje vykreslování do dvou hlavních vláken:
- UI vlákno (UI thread). Vykonává aplikační kód v Dartu: zpracovává dotyková gesta, počítá herní logiku, sestavuje widgety, vyhodnocuje rozvržení prvků a generuje strom vrstev (layer tree).
- Rastrovací vlákno (raster thread). Přebírá strom vrstev vytvořený UI vláknem a převádí kreslicí příkazy na GPU instrukce pomocí renderovacího enginu Skia nebo Impeller.
Z oficiální dokumentace k profilování výkonu ve Flutteru vyplývá zásadní pravidlo: zpoždění na rastrovacím vlákně téměř vždy pramení z příliš náročných kreslicích operací zadaných v kódu Dartu. Prvním krokem optimalizace proto musí být zjištění, které vlákno překračuje stanovený limit. Přesouvání matematických výpočtů do samostatného izolátu ničemu nepomůže, pokud grafický čip nestíhá opakované rozostřování obrazovky.
+------------------------------------------------------------+
| Total Frame Window: 16.6 ms (at 60 Hz) |
+------------------------------+-----------------------------+
| UI Thread: Dart execution, | Raster Thread: GPU commands |
| layout, widget construction | and pixel rasterization |
+------------------------------+-----------------------------+
Obě vlákna pracují pro každý snímek v sekvenci za sebou. Pokud UI vlákno spotřebuje 11 ms na logiku a widgety a rastrovací vlákno dalších 9 ms na vykreslení, snímek zabere celkem 20 ms a nestihne se zobrazit včas, ačkoli ani jedno z vláken samo o sobě nepřekročilo 16,6 ms.
Spolehlivé měření výkonu a nástroje DevTools
Posuzovat plynulost hry v režimu debug je zásadní chybou. Režim ladění spouští neustálé aserce, obsahuje kód pro Hot Reload a běží v JIT kompilaci, která záměrně upřednostňuje pohodlí vývojáře před optimalizací chodu.
Všechna spolehlivá měření musí probíhat v režimu profile na fyzickém telefonu:
# Debug mode: unoptimized, useful only during feature implementation
flutter run
# Profile mode: compiled AOT, DevTools services enabled
flutter run --profile
Pro rychlou kontrolu přímo na displeji telefonu slouží integrovaný overlay výkonu:
MaterialApp(
showPerformanceOverlay: true,
checkerboardRasterCacheImages: true,
home: const GameScreen(),
)
Horní graf sleduje zatížení rastrovacího vlákna, zatímco dolní graf zobrazuje práci UI vlákna. Červeně zvýrazněné sloupce okamžitě upozorňují na snímky, které přesáhly hranici 16,6 ms.
Podrobný rozbor poskytuje záložka Performance v sadě Flutter DevTools. Při běžném vývoji využijete tři klíčové nástroje:
- Časová osa (Timeline Flame Chart). Rozděluje každý snímek na jednotlivé fáze, kde jasně vidíte trvání sestavování widgetů, rozvržení a volání canvasu.
- Statistiky rastru (Raster Stats). Zaznamenávají čas vykreslování jednotlivých vrstev na GPU, což okamžitě odhalí pozadí scény, které spotřebovává většinu dostupného času.
- Přepínače vrstev (Layer Toggles). Umožňují za běhu dočasně vypnout vrstvy ořezu (clip), průhlednosti (opacity) nebo stínů, čímž snadno izolujete náročné kompoziční kroky.
Pro odhalení nechtěných přestaveb widgetů v protokolu stačí zapnout diagnostický přepínač v metodě main:
void main() {
debugPrintRebuildDirtyWidgets = true;
runApp(const GameApp());
}
Při aktivaci tohoto nastavení konzole vypisuje každý widget označený jako dirty, což velmi usnadňuje odstranění zbytečných řetězců přestaveb.

Oddělení herní smyčky od stromu widgetů
Častou chybou začínajících herních vývojářů ve Flutteru je pokus řídit animaci voláním setState v periodickém časovači:
// Problematic pattern: triggers full widget tree rebuilds every frame
Timer.periodic(const Duration(milliseconds: 16), (_) {
setState(() {
character.updatePosition();
});
});
Volání setState šedesátkrát za sekundu nutí framework k neustálému porovnávání prvků ve stromu widgetů, přepočítávání geometrie a vytváření nových instancí. Na procesorech střední třídy tento způsob brzy způsobí přetížení UI vlákna.
Správná architektura zcela odděluje stav herního světa od widgetů. K aktualizaci stavu použijeme Ticker, zatímco vykreslování na plátno Canvas obstarává CustomPainter:
class GameRunnerState extends State<GameRunner>
with SingleTickerProviderStateMixin {
late final Ticker _ticker;
Duration _previousTime = Duration.zero;
final GameState _gameState = GameState();
final ValueNotifier<int> _renderTrigger = ValueNotifier<int>(0);
@override
void initState() {
super.initState();
_ticker = createTicker(_onTick)..start();
}
void _onTick(Duration currentTime) {
if (_previousTime == Duration.zero) {
_previousTime = currentTime;
return;
}
final double dt = (currentTime - _previousTime).inMicroseconds / 1000000.0;
_previousTime = currentTime;
_gameState.update(dt);
_renderTrigger.value++;
}
@override
void dispose() {
_ticker.dispose();
_renderTrigger.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return CustomPaint(
painter: BoardPainter(_gameState, _renderTrigger),
size: Size.infinite,
);
}
}
Příslušný CustomPainter naslouchá signálu k překreslení a provádí čisté kreslení bez zásahu do stromu widgetů:
class BoardPainter extends CustomPainter {
BoardPainter(this.state, Listenable repaint) : super(repaint: repaint);
final GameState state;
@override
void paint(Canvas canvas, Size size) {
// Avoid object allocations inside the hot paint path
for (final entity in state.entities) {
entity.render(canvas);
}
}
@override
bool shouldRepaint(covariant BoardPainter oldDelegate) => false;
}
Protože metoda shouldRepaint vrací false, vykreslování se spouští výhradně přes dodaný objekt Listenable. Strom widgetů zůstává během celé hry zcela nedotčen.
Pro dynamické hry s nepřetržitou fyzikou představuje zavedenou volbu engine Flame. Komponenty ve Flame mají vlastní životní cyklus update(double dt) a render(Canvas canvas), což herní logiku rovněž odděluje od layoutu Flutteru. U deskových a logických her typu sudoku však přímý CustomPainter nabízí maximální kontrolu bez externích závislostí.
Promyšlené nasazení RepaintBoundary
Widget RepaintBoundary vytváří pro svůj podstrom samostatnou vrstvu vykreslování. Engine tento obsah vyrenderuje do vyrovnávací paměti mimo obrazovku a ponechá si jej v mezipaměti, takže v následujících snímcích může rovnou použít hotový rastr bez opakování kreslicích operací.
Každá hranice však spotřebovává operační paměť a přidává kompoziční krok na GPU. Vkládání hranic naslepo často vede k horšímu výkonu.
Nasazení RepaintBoundary má reálný přínos ve dvou situacích:
- Statické pozadí pod pohybujícími se prvky. Herní deska se nakreslí pouze jednou a grafický čip skládá pohyblivé objekty přes uloženou texturu, aniž by pozadí znovu počítal.
- Často animovaný drobný prvek uvnitř statického rozhraní. Pohyblivá část se překresluje ve své vlastní vrstvě a nezpůsobuje zneplatnění okolních kontejnerů.
Stack(
children: [
// Static background: rasterized once and cached
const RepaintBoundary(
child: StaticBoardBackground(),
),
// Dynamic overlay: repainted every frame without dirtying the background
RepaintBoundary(
child: AnimatedParticleSystem(),
),
],
)
Vyvarujte se obalování jednotlivých políček v husté mřížce nebo prvků, které se tak jako tak mění v každém snímku. Pokud se obsah neustále mění, engine musí mezipaměť vrstvy v každém kroku zahazovat a tvořit znovu. Přínos každé hranice si vždy ověřte v záložce Raster Stats v DevTools.
Omezení nákladných volání saveLayer
Některé kombinace widgetů nutí engine k vnitřnímu vyvolání metody saveLayer. Tento mechanismus alokuje dočasnou vyrovnávací paměť mimo obrazovku, vykreslí do ní potomky, aplikuje požadovanou průhlednost či filtr a výsledek sloučí s hlavní obrazovkou. Na grafických čipech telefonů střední třídy s omezenou paměťovou propustností vedou opakovaná volání saveLayer k okamžitým propadům snímků.
Typickým viníkem bývá animování běžného widgetu Opacity:
// Costly: allocates an offscreen buffer on every animation tick
Opacity(
opacity: animationValue,
child: const HeavyBoard(),
)
// Efficient: animates opacity via layer compositing without saveLayer
FadeTransition(
opacity: animationController,
child: const HeavyBoard(),
)
FadeTransition upravuje průhlednost přímo na úrovni vlastnosti vrstvy v kompozitoru, čímž eliminuje nutnost vytvářet mezipaměť mimo obrazovku.
Kombinace saveLayer s filtry barev či obrazu navíc dokáže vyřadit z provozu vnitřní rastrovou mezipaměť Flutteru, jak dokládá hlášení chyby 51975 ve Flutteru. Pokud engine nedokáže přesně spočítat ořezový obdélník pro filtrovaný prvek, zneplatní mezipaměť i pro sousední objekty a přinutí GPU překreslit celou scénu znovu.
Z tohoto důvodu je vhodné dynamické rozostření pomocí BackdropFilter omezit pouze na statické pauzovací obrazovky nebo dialogy. Průběžný blur na pozadí aktivní hry při 60 FPS levnější mobilní GPU spolehlivě zahltí.
Optimalizace dekódování textur a atlasy spritů
Práce s grafikou představuje ve 2D hrách častý zdroj záseků. Problémy nastávají ve dvou fázích: při dekódování souborů a při nadměrném počtu samostatných textur.
Škálování během dekódování
Flutter ve výchozím nastavení dekóduje obrázky v jejich původním rozlišení. Načtení textury o rozměrech 2048x2048 pixelů do políčka o velikosti 250x250 pixelů plýtvá pamětí RAM a zbytečně vytěžuje UI vlákno přepočtem velikosti.
Cílové rozměry vždy určete pomocí parametrů cacheWidth nebo cacheHeight:
Image.asset(
'assets/board_background.png',
fit: BoxFit.cover,
cacheWidth: (displayWidth * MediaQuery.of(context).devicePixelRatio).round(),
)
Podle dokumentace třídy ImageCache činí standardní limit paměti pro obrázky 100 MB nebo 1000 položek. Při překročení tohoto limitu systém starší obrázky z paměti odstraňuje a při dalším zobrazení je musí načítat a dekódovat znovu.
Na nižší úrovni umožňuje funkce instantiateImageCodec s parametrem targetWidth provést zmenšení obrázku přímo v jádře enginu před alokací paměti.
Sdružování spritů do texturových atlasů
Vykreslování desítek samostatných obrázků vyžaduje neustálé přepínání textur v paměti GPU a vytváří velké množství kreslicích volání (draw calls). Spojením jednotlivých fází animace a políček do jednoho atlasu spritů umožníte enginu odbavit desítky objektů v jediném grafickém příkazu.
Flutter toto podporuje metodou Canvas.drawAtlas. V enginu Flame zajišťuje totéž mixin HasAutoBatchedChildren, který automaticky sloučí komponenty se společnou texturou:
class ParticleGroup extends PositionComponent with HasAutoBatchedChildren {
// Child components referencing the same sprite atlas
// render in a unified draw pass without texture swaps
}
U statických dlaždicových desek se vyplatí vyrenderovat celou mřížku do jednoho obrazového bufferu při načítání úrovně, namísto kreslení stovek samostatných políček v každém snímku herní smyčky.
![]()
Vykreslovací enginy: Impeller versus Skia
Současný Flutter využívá Impeller na systému iOS a v novějších verzích Androidu, zatímco starší konfigurace spoléhají na engine Skia. Hlavní předností Impelleru je odstranění záseků způsobených kompilací shaderů (shader jank), protože všechny potřebné varianty kódu shaderů jsou předkompilovány už při sestavení aplikace.
Při optimalizaci je vhodné chování hry porovnat na obou enginech:
# Force Impeller backend
flutter run --profile --enable-impeller
# Run with Skia backend for comparative baseline
flutter run --profile --no-enable-impeller
Porovnání časů snímků na obou enginech jasně ukáže, zda propad výkonu souvisí s ovladači konkrétního hardwaru, nebo se slabinami ve vlastním kódu hry. Podobný metodický postup popisuje také průvodce řešením janku na freeCodeCamp.
Podrobnosti o časování a synchronizaci s obnovovací frekvencí displeje rozebírá Andrea Bizzotto v článku Timer vs Ticker, kde vysvětluje chování snímkového plánovače při proměnlivém zatížení procesoru.
Poctivé měření plynulosti na reálném telefonu
Testovat hru výhradně na vývojářském počítači nebo v emulátoru vytváří falešný pocit bezpečí. Výkonné procesory desktopů snadno zakryjí neefektivitu, která mobilní čip okamžitě zahltí.
Pravidla pro spolehlivou testovací metodiku:
- Stálé referenční zařízení. Jako hlavní testovací telefon používejte fyzický smartphone s Androidem střední třídy, starý dva až tři roky.
- Kontrola teploty. Přehřátý čip automaticky snižuje frekvenci jader (thermal throttling). Testy neprovádějte ihned po odpojení z nabíječky nebo po dlouhé kompilaci.
- Stav baterie. Pod 20% kapacity baterie operační systémy zapínají úsporné režimy, které zkreslují výsledky. Testujte vždy při nabití nad 50%.
- Opakovatelné scénáře. Testovací průchody hrou řiďte automatizovaným skriptem, což zajistí identické podmínky při porovnávání verzí kódu.
Průměrný počet snímků za sekundu (Average FPS) je zavádějící údaj. Hra dosahující průměru 58 FPS může každých pár sekund na 150 ms zamrznout, což hráčský zážitek úplně zničí. Rozhodující jsou časy snímků na úrovni 95. a 99. percentilu (p95 a p99).
Následující pomocná třída zaznamenává trvání snímků při profilovacích bězích:
class FrameDurationTracker {
final List<double> _history = List<double>.filled(120, 0.0);
int _cursor = 0;
void recordFrame(double durationMs) {
_history[_cursor % _history.length] = durationMs;
_cursor++;
}
double calculateP95() {
final List<double> samples = List<double>.from(_history)..sort();
final int index = (samples.length * 0.95).floor();
return samples[index];
}
bool isTargetMet() => calculateP95() <= 16.6;
}
Pravidelné sledování percentilů umožňuje odhalit přetížení snímkového rozpočtu dříve, než se dostane do produkčního vydání.

Praktický kontrolní seznam optimalizace
Základní pravidla pro každodenní práci na hrách ve Flutteru:
- Výkon měřte vždy v režimu
--profilena fyzickém telefonu střední třídy. - Oddělte herní smyčku od stromu widgetů pomocí tříd
TickeraCustomPainter. - Zabraňte vytváření objektů uvnitř metod
updateapaint. ObjektyPaintmějte předpřipravené. RepaintBoundaryumisťujte uvážlivě: pouze kolem statických pozadí nebo izolovaných dynamických prvků.- Nahraďte animovaný widget
OpacitykomponentouFadeTransition, abyste předešli volánísaveLayer. - Obrázky dekódujte přesně na cílovou velikost pomocí
cacheWidthacacheHeight. - Příbuzné sprity sdružujte do texturových atlasů, abyste snížili počet volání GPU kreslení.
- Plynulost hodnoťte podle percentilů p95 a p99, nikoli podle aritmetického průměru snímků.
FAQ: Často kladené otázky
Hodí se Flutter pro komerční 2D hry?
V oblasti 2D příležitostných, deskových, karetních a logických her nabízí Flutter skvělý výkon, rychlý vývojový cyklus a spolehlivé rozhraní pro iOS i Android. U náročných 3D projektů nebo rozsáhlých částicových simulací zůstávají vhodnější specializované enginy jako Godot nebo Unity.
Proč se hra při prvním zobrazení nového prvku zadrhne?
Počáteční zásek bývá způsoben opožděným načítáním souborů, rastrováním písem nebo kompilací shaderů pod enginem Skia. Grafiku i zvuky je vhodné přednačíst už na úvodní obrazovce hry. Na zařízeních s Impellerem je problém s kompilací shaderů během hraní zcela vyřešen.
Pomáhá RepaintBoundary v posuvných seznamech?
V komponentách jako ListView Flutter vkládá RepaintBoundary kolem každé položky automaticky, aby posun nezneplatňoval viditelné sousední prvky. Přidávat další ruční hranice uvnitř builderu položek se nedoporučuje, protože příliš mnoho vrstev zbytečně zatěžuje GPU kompozitor.
Má se dekódování obrázků přesunout do samostatného izolátu?
Běžně to není potřeba. Vnitřní systém Flutteru už dekódování obrázků deleguje do nativních C++ vláken na pozadí. Předávání polí bajtů mezi izoláty v Dartu vytváří režii s kopírováním dat, která často převýší případný zisk. Izoláty je lepší šetřit pro náročné výpočty logiky, jako je generování map či hledání cest.
Jak přizpůsobit herní smyčku displejům s frekvencí 90 Hz a 120 Hz?
Všechny posuny v herním světě musí být násobeny delta časem (dt), nikoli pevným krokem. Pokud výkon zařízení neumožňuje stabilně dosáhnout 8,3 ms na snímek, je bezpečnější uzamknout běh na 60 FPS, což zaručí rovnoměrný a klidný rytmus animace.
Jak najít widget, který se neustále přestavuje?
V debug režimu nastavte debugPrintRebuildDirtyWidgets = true. Konzole vypíše seznam všech widgetů, které se v daném snímku přestavují. Snadno tak odhalíte komponenty, jejichž stav je nutné přesunout mimo strom widgetů.
Zdroje a doporučené čtení
- Dokumentace výkonu uživatelského rozhraní ve Flutteru - Přehled modelu vláken a diagnostického overlaye.
- Průvodce zobrazením Performance v DevTools - Postup analýzy časové osy a vrstev vykreslování.
- Architektura renderovacího enginu Impeller - Fungování předkompilovaných shaderů a hardwarové akcelerace.
- Dávkování grafiky v enginu Flame - Využití texturových atlasů a
HasAutoBatchedChildren. - Specifikace třídy ImageCache - Správa mezipaměti obrázků ve Flutteru.
- Technická specifikace instantiateImageCodec - Nízkoúrovňové dekódování grafiky s volbou cílové velikosti.
- Rozbor Timer vs Ticker od Andrey Bizzotta - Detailní srovnání způsobů časování snímků.
- Praktický návod na optimalizaci na freeCodeCamp - Řešení reálných problémů s plynulostí zobrazení.
- Hlášení 51975 v repozitáři Flutter - Vliv volání
saveLayers filtry na zneplatnění mezipaměti rastru.
Zjistěte více o našem přístupu k vývoji: seznamte se s naší herní filozofií v našem sudoku dobrodružství Polydocu, zjistěte, odkud se berou nápady na hry, a přečtěte si, jak vnímáme přístupnost v mobilních hrách.
Napsal Maksymilian Jackowski v Psittacus Studio, tvůrci Polydocu, mobilního sudoku dobrodružství.
Polydocu - sudoku v podobě dobrodružství
Devět číslic, výprava džunglí, papoušek Poly a žádné umělé překážky. Zapište se na seznam čekatelů a pošleme vám zprávu v den vydání.
Jeden e-mail v den vydání, žádný spam.




