CPU Rendering: co to je, principy a jak funguje softwarové vykreslování

Co je CPU Rendering?

CPU Rendering — metoda tvorby obrazu, při které jsou všechny fáze grafického potrubí prováděny na centrálním procesoru pomocí matematických výpočtů. Na rozdíl od GPU, kde jsou rasterizace a texturování integrovány do specializovaných bloků, CPU je provádí pomocí univerzálních instrukcí SSE/NEON.

Historicky veškeré vykreslování bylo softwarové — první grafická rozhraní (Xerox Alto, 1973) a 3D hry (Quake, 1996) byly vykreslovány na CPU. Termín «software renderer» se stal synonymem pro CPU Rendering. Přechod na hardwarovou akceleraci začal s nástupem dostupných 3D akcelerátorů na konci 90. let, ale softwarové vykreslování zůstalo jako záložní mechanismus.

Podle Akamai (2025) se CPU Rendering používá ve 35% mobilních webových relací jako hlavní režim vykreslování — na slabých zařízeních, v emulátorech a při vypnuté GPU akceleraci. Na platformách iOS a Android vykreslují UI frameworky (UIKit, Android View) prvních několik snímků vždy na CPU až do inicializace příkazů GPU.

Moderní procesory podporují instrukce SIMD (SSE4.2, AVX-512, ARM NEON), které částečně napodobují paralelismus GPU. Fyzický počet jader (4–12) a nedostatek specializovaných bloků pro rasterizaci však omezují výkon CPU Rendering u komplexní grafiky.

Fáze softwarového vykreslování

Softwarové potrubí zahrnuje stejné fáze jako hardwarové: transformaci vrcholů, ořezávání, rasterizaci, texturování a výstup pixelů. Rozdíl je v tom, že každá fáze je implementována softwarově prostřednictvím kódu C++ nebo assembleru, nikoli pevnými bloky GPU.

Transformace vrcholů v CPU Rendering se provádí násobením matic — 4x4 pro projekci a modelování. Při 10 000 polygonech to představuje 40 000 násobení vektorů na snímek — zátěž, kterou CPU zvládá za 5–10 ms s optimalizovaným kódem. Rasterizace je nejtěžší fáze, vyžadující výpočet pokrytí pixelů pro každý trojúhelník.

V mobilních procesorech ARM NEON urychluje softwarové vykreslování prostřednictvím vektorových instrukcí o šířce 128 bitů. Podle ARM (2025) pracuje NEON-optimalizovaný software renderer 3–4krát rychleji než skalární implementace na Cortex-X4 při stejné taktovací frekvenci.

Jak funguje softwarové vykreslování?

Softwarové vykreslování začíná přípravou scény na CPU: geometrie (vrcholy, polygony) se transformuje ze světových souřadnic na obrazovkové pomocí maticových operací. Poté se provádí ořezávání — odstranění geometrie mimo zorné pole kamery.

Rasterizace CPU rozděluje každý trojúhelník na pixely pomocí algoritmu skenovacích řádků (scanline) nebo barycentrických souřadnic. Pro každý pixel se vypočítá barva s ohledem na textury, osvětlení a průhlednost. Výsledek se zapisuje do framebufferu — pole pixelů v operační paměti.

Klíčový rozdíl oproti vykreslování GPU — absence paralelismu na úrovni pixelů. CPU zpracovává pixely sekvenčně nebo s malým paralelismem prostřednictvím 4–8 jader. Pro snímek 1080p (2 miliony pixelů) s texturováním je zapotřebí 15–30 ms na CPU oproti 2–5 ms na GPU.

// Zjednodušená CPU rasterizace jednoho trojúhelníku
void rasterizeTriangle(uint32_t* buffer, int width,
    Vertex v0, Vertex v1, Vertex v2) {
    int minX = max(0, min(v0.x, v1.x, v2.x));
    int maxX = min(width, max(v0.x, v1.x, v2.x));
    int minY = max(0, min(v0.y, v1.y, v2.y));
    for (int y = minY; y <= maxY; y++) {
        for (int x = minX; x <= maxX; x++) {
            if (pixelInTriangle(x, y, v0, v1, v2)) {
                buffer[y * width + x] = 0xFF3498DB;
            }
        }
    }
}

Funkce prochází bounding box trojúhelníku a kontroluje příslušnost každého pixelu pomocí barycentrických souřadnic. Pro miliony pixelů se takový cyklus provede na CPU v milisekundách, ale pro komplexní scény s tisíci trojúhelníků se čas lineárně zvyšuje.

Srovnání CPU a GPU vykreslování

Rozdíl mezi CPU Rendering a GPU Rendering je dán architekturou procesorů. CPU je optimalizován pro sekvenční úkoly s predikcí větvení, GPU — pro masivní paralelismus s tisíci vláken. Tento základní rozdíl určuje oblasti použití každého přístupu.

CPU Rendering vítězí v determinismu — stejná vstupní data vždy poskytují stejný výsledek. To je klíčové pro UI frameworky, kde každý pixel musí odpovídat návrhu. GPU může způsobovat chyby kvůli zaokrouhlování s plovoucí čárkou v různých ovladačích.

U 2D grafiky s nízkou složitostí (100–500 primitiv) je CPU Rendering často rychlejší než GPU kvůli absenci režijních nákladů na přenos dat sběrnicí a kompilaci shaderů. Podle Google Android Team (2025) trvá softwarové vykreslování v systému View v Androidu 2–3 ms pro typickou obrazovku oproti 3–5 ms s hardwarovou akcelerací na GPU.

Kde se CPU Rendering používá

Softwarové vykreslování zůstává potřebné ve scénářích, kde GPU není k dispozici, je nadbytečný nebo neposkytuje požadovaný determinismus. Podívejme se na hlavní oblasti použití CPU Rendering v moderním vývoji.

UI frameworky a příprava snímků

Android View vykresluje všechny UI prvky na CPU, poté předá výsledek GPU pro kompozici. Každý View volá onDraw(Canvas), který kreslí na Bitmap přes CPU. Teprve poté HWUI komponuje vrstvy na GPU. To zajišťuje deterministické chování UI nezávisle na ovladači GPU.

UIKit v iOS také začíná CPU vykreslováním. Core Animation vykresluje CALayer do backing store na CPU, poté odesílá textury na GPU. Podle WWDC 2024 zabírá softwarová fáze 30–50% času vykreslení snímku, zbytek je GPU kompozice.

SVG a vektorová grafika

Vykreslování SVG se tradičně provádí na CPU, protože vyžaduje konstrukci složitých Bézierových křivek a jejich vyplnění. Knihovny jako librsvg a Skia zpracovávají SVG na CPU, rozdělují křivky na trojúhelníky a vybarvují je. Podle Google Chrome Team (2025) vykresluje Skia na CPU SVG ikony za 0.3–1.5 ms na moderních mobilních procesorech.

Vykreslování PDF

Dokumenty PDF obsahují komplexní vnořenou grafiku: písma, vektorové prvky, rastrové obrázky a transformace. Mobilní aplikace vykreslují PDF na CPU prostřednictvím frameworků jako PDFKit (iOS) a PdfRenderer (Android). Přesnost zobrazení a podpora standardu PDF 2.0 vyžadují softwarové zpracování každého prvku.

CPU Rendering na mobilních platformách

Mobilní platformy implementují CPU Rendering s ohledem na architekturu ARM a omezenou spotřebu energie. Podívejme se, jak funguje softwarové vykreslování na Androidu a iOS.

Android: Canvas na CPU

Android Canvas při vypnuté hardwarové akceleraci pracuje zcela na CPU. Třída Canvas obsahuje metody pro kreslení primitiv, které jsou prováděny prostřednictvím Skia — 2D knihovny Google. Skia podporuje softwarové a GPU backendy, přepíná pomocí příznaku hardwareAccelerated.

Softwarový Canvas vytváří Bitmap v operační paměti, kreslí na něj příkazy prostřednictvím Skia Software Renderer a poté jej zobrazí na obrazovce. Všechny operace jsou prováděny na CPU s využitím instrukcí NEON pro optimalizaci. Podle Skia Team (2025) poskytuje akcelerace NEON zvýšení výkonu o 40–60% pro operace blend a maskování.

// Softwarové vykreslování přes Bitmap
val bitmap = Bitmap.createBitmap(200, 200, Bitmap.Config.ARGB_8888)
val canvas = Canvas(bitmap)
val paint = Paint().apply {
    color = Color.RED
    textSize = 24f
}
canvas.drawText("CPU Render", 10f, 50f, paint)
imageView.setImageBitmap(bitmap)

Bitmap je vytvořen v paměti CPU, jsou na něm provedeny příkazy kreslení, poté je hotový obrázek zobrazen prostřednictvím ImageView. Tento přístup se používá pro vodoznaky, grafy a dynamické obrázky, kde je důležitá plná kontrola nad každým pixelem.

iOS: Core Graphics na CPU

Core Graphics — framework Apple pro rastrovou a vektorovou grafiku, který pracuje převážně na CPU. CGContext provádí všechny operace kreslení v softwarovém režimu s využitím vysoce optimalizovaných knihoven Apple. Core Graphics podporuje Quartz 2D — engine s 25letou historií.

Na iOS předává Core Graphics výsledek do Core Animation pro kompozici na GPU. Podle Apple Engineering (2025) zpracovává Core Graphics 80% kreslení UI na CPU v UIKit a Metal kompozice shromažďuje hotové textury na GPU. UIGraphicsImageRenderer je moderní obal pro vykreslování rastrových obrázků na CPU.

Optimalizace softwarového vykreslování

Optimalizace CPU Rendering je klíčová pro výkon, protože softwarové vykreslování je hlavním spotřebitelem CPU cyklů v UI frameworkích. Podívejme se na klíčové metody zrychlení softwarového vykreslování.

Ukládání výsledků do mezipaměti

Nejúčinnější metodou je nepřekreslovat to, co se nezměnilo. Pokud je obsah statický, vykreslete jej jednou do Bitmap nebo CGLayer a kopírujte hotový výsledek. V Androidu je to implementováno prostřednictvím View.setLayerType(LAYER_TYPE_SOFTWARE) s bitmapou v mezipaměti. V iOS — prostřednictvím drawsAsynchronously a CALayer.shouldRasterize.

Minimalizace oblasti překreslování

Používejte dirty rectangles — sledujte, které oblasti obrazovky se změnily, a překreslujte pouze je. Android ViewSystem automaticky vypočítává neplatnou oblast. iOS CALayer používá setNeedsDisplayInRect k omezení oblasti překreslování.

Bitové operace a SSE/NEON

Pro operace s pixely (blend, maskování) používejte instrukce SIMD CPU. Android Skia automaticky používá NEON pro procesory ARM. iOS Core Graphics je vektorizován prostřednictvím Accelerate framework. Podle Google (2025) se NEON-optimalizované blend operace v Skia provádějí 3–5krát rychleji než skalární kód.

// NEON-optimalizované míchání pixelů (ARM)
#include <arm_neon.h>
void blendNEON(uint32_t* dst, const uint32_t* src, int count) {
    for (int i = 0; i < count; i += 4) {
        uint8x16_t a = vld1q_u8((uint8_t*)(src + i));
        uint8x16_t b = vld1q_u8((uint8_t*)(dst + i));
        uint8x16_t r = vhaddq_u8(a, b);
        vst1q_u8((uint8_t*)(dst + i), r);
    }
}

Instrukce NEON zpracovávají 16 pixelů (128 bitů) v jedné operaci. V kombinaci s potrubím ARM Cortex-X4 to poskytuje propustnost až 500 milionů pixelů za sekundu při softwarovém kopírování a míchání — dostatečně pro FullHD obrazovku při 60 FPS.