OpenGL ES: co to je, architektura a aplikace

Co je OpenGL ES?

OpenGL ES (Open Graphics Library for Embedded Systems) — je podmnožina desktopového OpenGL API, přizpůsobená pro mobilní zařízení, herní konzole a vestavěné systémy. Specifikaci vyvíjí konsorcium Khronos Group a je zdarma dostupná všem výrobcům. Na rozdíl od desktopového OpenGL odstraňuje OpenGL ES zastaralé funkce pevného pipeline a ponechává pouze programovatelný pipeline shaderů — to snižuje spotřebu energie a zjednodušuje ovladače.

Hlavní oblast použití OpenGL ES — vykreslování grafiky v reálném čase. API se používá v mobilních hrách (Unity, Unreal Engine), navigačních aplikacích, AR řešeních založených na ARCore a ARKit a také v systémových rozhraních Android a iOS. Podle údajů StatCounter, 2026 podíl zařízení s podporou OpenGL ES 3.0+ přesahuje 92 % mezi aktivními chytrými telefony.

Klíčovou výhodou OpenGL ES je multiplatformnost. Stejná aplikace napsaná v OpenGL ES může běžet na Android, iOS, Linux a Windows s minimálními změnami. Díky tomu je API optimální volbou pro projekty zaměřené na více platforem bez přepisování grafického enginu.

Pevný vs programovatelný pipeline

Rané verze OpenGL (před 2.0) používaly pevný pipeline — sadu předdefinovaných fází zpracování vrcholů a pixelů. Vývojář mohl pouze nastavit parametry: polohu světelných zdrojů, vlastnosti materiálů, transformační matice. Programovatelný pipeline, zavedený v OpenGL ES 2.0, nahradil pevné fáze shadery — malými programy prováděnými na GPU. To dalo vývojářům plnou kontrolu nad zobrazením geometrie.

Přechod na programovatelný pipeline byl revolucí pro mobilní grafiku. Vývojáři získali možnost implementovat složité efekty: PBR (Physically Based Rendering), dynamické stíny, následné zpracování a HDR. Pevný pipeline vyžadoval méně kódu, ale neumožňoval vytvářet jedinečné vizuální styly. Moderní mobilní hry plně fungují na programovatelném pipeline.

Architektura OpenGL ES: renderovací pipeline

Grafický pipeline OpenGL ES se skládá z několika po sobě jdoucích fází, z nichž každá transformuje vstupní data na cestě od vrcholů k pixelům na obrazovce. Porozumění architektuře pipeline je klíčové pro optimalizaci výkonu vykreslování na mobilních zařízeních s omezeným rozpočtem energie a tepla.

První fáze — vertex shader — zpracovává každý vrchol nezávisle. V této fázi se aplikují transformace: přechod z lokálního prostoru modelu do světového prostoru, poté do prostoru kamery a nakonec do ořezového prostoru (clip space). Transformace jsou definovány pomocí uniformních matic MVP (Model-View-Projection), které se aktualizují každý snímek při pohybu kamery nebo objektů.

Po sestavení primitiv (bodů, čar, trojúhelníků) následuje rasterizace — proces určování, které pixely obrazovky každé primitivum pokrývá. Rasterizátor generuje fragmenty — potenciální pixely s interpolovanými atributy (barva, normály, UV souřadnice). Počet fragmentů přímo závisí na rozlišení obrazovky a ploše projekce primitiva.

Fragment shader se provádí pro každý vygenerovaný fragment. Vypočítává konečnou barvu pixelu s ohledem na textury, světelné zdroje a materiály. Na výstupu fragment shaderu prochází série per-fragment testů: depth test určuje, zda je fragment viditelný; stencil test omezuje vykreslování podle masky; blending míchá barvu fragmentu s barvou již zapsanou v snímkovém bufferu.

Stavy kontextu OpenGL ES

OpenGL ES funguje jako konečný automat (state machine): všechna nastavení — aktuální shader, připojené textury, zapnuté testy — jsou uložena v globálním stavu kontextu. Změna stavu pomocí glEnable, glBindTexture nebo glUseProgram ovlivňuje všechny následující příkazy kreslení. Každé přepnutí stavu způsobuje režii v ovladači, proto je seskupování draw volání podle stavu hlavní optimalizační technikou.

Verze OpenGL ES a jejich možnosti

OpenGL ES 1.0 a 1.1 (vydány v letech 2003–2004) byly založeny na pevném pipeline. Podporovaly transformace, texturování, osvětlení a blending, ale neumožňovaly programování shaderů. API se používalo v raných mobilních telefonech a zařízeních založených na Symbian a Windows Mobile. Dnes jsou tyto verze považovány za zastaralé — moderní zařízení je nepodporují.

OpenGL ES 2.0 (2007) zavedl programovatelný pipeline s vertexovými a fragmentovými shadery v jazyce GLSL ES. Tato verze se stala standardem pro Android 2.2+ a iOS 5+ a je podporována drtivou většinou zařízení dodnes. OpenGL ES 2.0 — minimální verze potřebná pro běh Unity, Unreal Engine a Cocos2d-x na mobilních platformách.

OpenGL ES 3.0 (2012) přidal několik kritických možností: více renderovacích cílů (MRT), transform feedback, instancing, textury libovolného formátu přes ETC2/EAC. Výkon vykreslování vzrostl o 30–50 % oproti verzi 2.0 díky snížení počtu draw volání. OpenGL ES 3.1 (2014) zavedl výpočetní shadery (compute shaders) a atomické operace s buffery — to umožnilo provádět na GPU nejen grafické, ale i výpočetní úlohy (následné zpracování, simulace látek, výpočty fyziky).

OpenGL ES 3.2 (2015) — poslední verze specifikace — přidala teselační a geometrické shadery, stejně jako rozšířenou sadu float textur a režimů blend. Navzdory vydání modernějšího Vulkan v roce 2016 zůstává OpenGL ES 3.2 aktuálním API díky obrovské základně stávajícího kódu a jednoduchosti přenosu aplikací mezi platformami.

Shadery v OpenGL ES: GLSL a programovatelný pipeline

GLSL ES (OpenGL Shading Language for Embedded Systems) — programovací jazyk shaderů založený na syntaxi C s dalšími typy pro práci s vektory a maticemi. Každý shader je program kompilovaný do strojového kódu GPU ve fázi inicializace aplikace. Na rozdíl od kódu CPU se shadery provádějí hromadně paralelně: tisíce vrcholů nebo fragmentů jsou zpracovávány současně.

Vertexové shadery

Vertex shader zpracovává každý vrchol sítě. Jeho hlavním úkolem je vypočítat konečnou pozici vrcholu v clip space vynásobením vstupní pozice maticí MVP. Kromě toho může vertex shader vypočítat normály, UV souřadnice, barvy a předávat je fragment shaderu přes varying proměnné. Každé volání vertex shaderu pracuje nezávisle, což umožňuje GPU zpracovávat miliony vrcholů za snímek.

// Jednoduchý vertex shader pro OpenGL ES 3.0
#version 300 es
layout(location = 0) in vec4 a_position;
layout(location = 1) in vec3 a_normal;
layout(location = 2) in vec2 a_texCoord;

uniform mat4 u_mvpMatrix;

out vec3 v_normal;
out vec2 v_texCoord;

void main() {
    gl_Position = u_mvpMatrix * a_position;
    v_normal = mat3(u_mvpMatrix) * a_normal;
    v_texCoord = a_texCoord;
}

Fragmentové shadery

Fragment shader určuje barvu každého pixelu na obrazovce. Přijímá interpolované varying hodnoty z vertex shaderu, vybírá texely z připojených textur a aplikuje osvětlení. Pro správné osvětlení se používá model Phong nebo Blinn-Phong s výpočtem diffuse, specular a ambient složek. Každé volání fragment shaderu odpovídá jednomu pixelu, takže celkový počet volání se rovná ploše projekce objektu na obrazovce.

// Jednoduchý fragment shader s texturou a osvětlením
#version 300 es
precision mediump float;

in vec3 v_normal;
in vec2 v_texCoord;

uniform sampler2D u_texture;
uniform vec3 u_lightDir;

out vec4 fragColor;

void main() {
    vec4 texel = texture(u_texture, v_texCoord);
    vec3 normal = normalize(v_normal);
    float diffuse = max(dot(normal, u_lightDir), 0.0);
    fragColor = vec4(texel.rgb * diffuse, texel.a);
}

V uvedeném příkladu fragment shader vybírá texel z 2D textury podle UV souřadnic, vypočítává diffuse osvětlení jako skalární součin normály a směru světla a násobí barvu texelu intenzitou osvětlení. Mediump — doporučená přesnost pro fragment shadery na mobilních GPU: poskytuje dostatečnou kvalitu při minimální spotřebě energie.

Jak začít s OpenGL ES v mobilních projektech

Pro práci s OpenGL ES na Androidu je třeba vytvořit EGL kontext — plochu, na kterou se bude grafika vykreslovat. Na iOS se používá EGL-podobná vrstva EAGL poskytovaná frameworkem GLKit. V obou případech proces inicializace zahrnuje vytvoření okenní plochy, konfiguraci atributů kontextu a připojení k aktuálnímu vláknu vykreslování.

// Inicializace OpenGL ES 3.0 na Androidu
class MyGLRenderer : GLSurfaceView.Renderer {

    private val vertexShaderCode = "#version 300 es\n..."
    private val fragmentShaderCode = "#version 300 es\n..."

    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
        GLES30.glClearColor(0.1f, 0.1f, 0.2f, 1.0f)
        GLES30.glEnable(GLES30.GL_DEPTH_TEST)
    }

    override fun onDrawFrame(gl: GL10?) {
        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT or GLES30.GL_DEPTH_BUFFER_BIT)
        // bind VBO, set uniforms, draw elements
    }

    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
        GLES30.glViewport(0, 0, width, height)
    }
}

Po vytvoření kontextu musí vývojář nakonfigurovat buffery: vertex buffer (VBO) obsahuje souřadnice vrcholů, normály a UV; index buffer (EBO) určuje pořadí průchodu vrcholů pro tvorbu trojúhelníků. VAO (Vertex Array Object) spojuje konfiguraci všech atributů do jednoho objektu, čímž snižuje počet API volání při změně meshů.

Konfigurace EGL kontextu

EGL (Native Platform Graphics Interface) — mezivrstva mezi OpenGL ES a okenním systémem. Na Androidu EGL spravuje vytváření kreslicí plochy, výběr konfigurace framebufferu (barevná hloubka, stencil, MSAA) a synchronizaci s vsync. Typická konfigurace vyžaduje RGBA8888 s 24bitovým depth bufferem a 8bitovým stencil bufferem. Na iOS roli EGL plní EAGL v kombinaci s CAEAGLLayer.

Optimalizace výkonu OpenGL ES na mobilních zařízeních zahrnuje několik klíčových postupů. Používejte instancing (glDrawArraysInstanced) pro vykreslování mnoha identických objektů — to snižuje počet draw volání. Aplikujte fondy textur a vyhýbejte se přepínání textur mezi draw voláními. Seřaďte objekty podle shaderu, poté podle textury, pak podle meshe — toto pořadí minimalizuje přepínání stavu kontextu.

OpenGL ES vs Metal vs Vulkan

Metal — nízkoúrovňové grafické API od Apple, dostupné na iOS a macOS od čipu A7. Metal poskytuje přímý přístup k GPU s minimální režií ovladače, ale funguje pouze na zařízeních Apple. Podle údajů WWDC 2024 poskytuje Metal až o 40 % vyšší výkon ve srovnání s OpenGL ES na stejném hardwaru díky snížení počtu kontrol stavu za běhu.

Vulkan — multiplatformní nástupce OpenGL ES vyvinutý organizací Khronos Group. Vulkan používá explicitní správu zdrojů: vývojář sám alokuje paměťové fondy, vytváří command buffery a synchronizuje přístup k GPU. To poskytuje maximální kontrolu nad výkonem, ale inicializační kód Vulkanu je 3–4krát rozsáhlejší než u OpenGL ES. Vulkan se doporučuje pro AAA hry a aplikace s náročnou grafikou na Android 7+.

Volba mezi OpenGL ES, Metal a Vulkan závisí na cílových platformách a požadavcích na výkon. OpenGL ES zůstává nejlepší volbou pro multiplatformní projekty, kde je důležitá rychlost vývoje. Metal je preferován pro ekosystém iOS/macOS s maximálním výkonem. Vulkan — volba pro projekty, kde je kritická každá milisekunda snímku a rozpočet vývoje umožňuje investovat do nízkoúrovňové optimalizace.