Programování GPU („shaders“) © Josef Pelikán, MFF UK Praha

Obsah architektura programovatelných GPU vertex shaders fragment shaders texture shaders (historie) programování GPU low-level: assembler vyšší programovací jazyky: Cg, HLSL, GLSL

Schéma programovatelné GPU Primitive Assembly Clip Project Viewport Cull Per-Fragment Operations Frame Buffer Operations Pixel Unpack Pixel Pack Pixel Groups Textures Fragments Vertices Fragme nt Process or Vertex Process or Geom. App Memory Pixels Texture Memory Frame Buffer Pixel Transfer Geom. Rasterize Pixels Read Control

Vývoj NVIDIA GeForce 3 (2001) první programovatelná GPU, DirectX 8.0: VS,PS v tomtéž roce: ATI Radeon 8500, Microsoft Xbox, NVIDIA GeForce 4 Titanium velmi omezený rozsah shaderů (fragment shader se spíš podobá krátkému konfiguračnímu scriptu, je dovoleno jen pár assembler instrukcí), texture shaders OpenGL: ARB_vertex_program extension (univerzální), fragment shading – podle výrobců DirectX 8.1 PS (jen ATI), VS zůstává 1.1, Radeon 9000

Vývoj II NVIDIA GeForce FX (2002) – CineFX architektura ATI Radeon DirectX 9.0: VS, PS 2.0 rozsah programů se podstatně zvětšil: 256 instrukcí konstantní paměť (uniform variables): 256 vektorů několik dalších formátů dat, FPU typ „half“, apod. OpenGL: ekvivalentní funkce přes různá rozšíření 2004: DirectX 9.0c: VS, PS 3.0 NVIDIA GeForce 6800, 6xxx (NV4x čipy), PCI-E bus ATI stále nemá VS, PS 3.0 kompatibilní kartu (2005/II)

Shader model 3.0 GPU se blíží univerzálním výpočetním jednotkám velké množství instrukcí (tisíce, není omezen) podmíněné skoky, smyčky, podprogramy, rekurze,.. vertex shader má přístup do texturové paměti („vertex texturing“, 4 jednotky) OpenGL: ekvivalentní funkce přes NV_* rozšíření NV4x pokroky v HW: dvakrát více přístupů do textury v jednom cyklu FP16 a FP32 se dají použít všude, HDR grafika (128bpp) MRT (multiple render targets), 16x anizoatrop. filtr, SLI (více GPU), HW geometric instancing, lepší anti-alias,...

SW shaders Pixar od 1989: RenderMan shaders univerzální popis lokálního světelného modelu aplikace textur, šumu,... díky SW implementaci mohou být velmi silné inspirace pro návrháře HW a 3D API film „Toy Story“ (na trhu v r. 1995) první veřejná ukázka schopností systému RenderMan finální generování grafiky („final rendering“): měsíce CPU na RISC stanicích Sun (farma: 117 SPARCstations) cca 1300 různých shaderů !

Příklad RenderMan shaderu (textura) surface turbulence ( float Kd =.8, Ka =.2 ) { float a, scale, sum; float IdotN; point M; /* convert to texture coordinate system */ M = transform( "marble", P ); scale = 1; sum = 0; a = sqrt( area(M) ); while ( a < scale ) { sum += scale * float noise( M/scale ); scale *= 0.5; } Oi = sum; Ci = Cs * Oi * (Ka + Kd * I.N * I.N / (I.I * N.N) ); }

Další příklady shaderů (svět. modely) light phong ( float intensity = 1.0; color color = 1; float size = 2.0; point from = point "shader" (0,0,0); point to = point "shader" (0,0,1); ) { uniform point R = normalize( to - from ); solar( R, PI/2 ) Cl = intensity * color * pow( R.L/length(L), size ); } light reflection ( string texturename = ""; float intensity = 1.0 ) { solar() Cl = intensity * color environment( texturename, -L ); }

Vektorový procesor nahrazuje modul zpracování vrcholů: transformace vrcholů transformace a normalizace normálových vektorů výpočet/transformace texturovacích souřadnic výpočet osvětlení (primární a sekundární barva ve vrcholu) nemůže ovlivnit: počet vrcholů! (nelze přidat ani ubrat vrchol * ) typ / topologii geometrických primitiv (neví o topologii!)  * částečné řešení: degenerace primitivu

Prostředí VS 1.1 Pomocné registry (až 12 vektorů) Vertex-shader (až 128 instrukcí) Konstanty („uniforms”) (až 96 vektorů) Vstupní data vrcholu (až 16 vektorů) Výstupní data vrcholu (až 13 vektorů) Souřadnice, normála, 2 barvy, mlha, velikost bodu (sprite), 8 texturových souřadnic Aplikace

VS 2.0, VS 3.0 VS 2.0: od NVIDIA GeForce FX, ATI Radeon 9500 jen kvantitativní vylepšení více instrukcí (256), více konstantních registrů (256) VS 3.0: od NVIDIA GeForce 6xxx přístup do texturové paměti („vertex texturing“)  např. pro „displacement mapping“  předpočítané složitější funkce (šum,..)  pro opravdu konstantní a velká data prakticky neomezený počet instrukcí (  32k)  zřejmě se ani nevyužije

Fragmentový procesor nahrazuje modul zpracování fragmentů: aritmetické operace s interpolovanými hodnotami čtení dat z textur aplikace textur a jejich kombinace (včetně závislosti) výpočet osvětlení („Phong shading“), mlhy,.. závěrečná syntéza barvy fragmentu možnost modifikace hloubky fragmentu „z“ nemůže ovlivnit: počet fragmentů! (nelze přidat ani ubrat * fragment) polohu fragmentu na obrazovce [x,y]

Prostředí FS 1.x Pomocné registry Fragment-shader ALU Textury Difusní a lesklé světlo hloubka „z” Texturové souřadnice RGBA Konstanty („uniforms”) Aplikace

Prostředí FS ≥2.0 Pomocné registry Fragment-shader ALU Textury Libovolné atributy fragmentu (barvy, tex. souř., normála, jiné vektory,..) hloubka „z” RGBA Konstanty („uniforms”) Aplikace

Fragment shader model 2.0 FS 2.0: od NVIDIA GeForce FX, ATI Radeon 9500 první skutečný „shader model“ (podobný RenderMan-u) libovolná data (atributy) mohou být spojena s fragmentem (perspektivně-korektní interpolace) libovolné aritmetické operace s daty (texturovými souř.!) závislost textur (texel. data se dají použít k adresování) více instrukcí (96), více konstantních registrů (256?) náhrada dřívějšího mechanismu „texture shaders“

Fragment shader model 3.0 FS 3.0: od NVIDIA GeForce 6xxx prakticky neomezená délka (  32k) podmíněné skoky, smyčky, podprogramy, apod. silnější sada aritmetických operací (i rychlé transcendentní funkce, derivace) MRT („Multiple Render Targets“) – současný zápis do více výstupních fragmentů (do více bufferů)  odložené stínování, urychlení víceprůchodových alg.,.. důraz na výpočetní sílu FS (návrh HW) mnoho nezávislých „pipelines“ (2005/II: 16)

Spolupráce VS a FS VS povinně produkuje pouze 3D souřadnice vrcholu v „clip space“  aby bylo možné 3D primitiva rasterizovat ostatní data jsou nepovinná (texturovací souřadnice, primární a sekundární barva, apod.) pokud se nepoužívá FS, musí být k dispozici všechna data pro FFP ! spolupráce VS a FS: grafický HW neví, jaká data si mezi sebou posílají rasterizační jednotka je interpoluje (perspektivně korektně)

Programovací jazyky „low-level“ programování (assembler) používalo se ve starších profilech (mezikód pro Cg, HLSL) jednoduchá sada instrukcí (např. 17 u VS 1.1) vyšší programovací jazyky nutnost kvůli složité HW architektuře GPU (optimalizace) NVIDIA: Cg („C for graphics“) od 2002 NVIDIA a Microsoft: HLSL („High Level Shading Language“) od 2003 OpenGL ARB (původně 3Dlabs): GLSL („OpenGL Shading Language“) od 2001 syntakticky jsou si dost podobné (zejména Cg a HLSL)

Příklad v Cg (Phongovo stínování) void phongVertex ( float4 position : POSITION, float3 normal : NORMAL, out float4 oPosition : POSITION, out float4 color : COLOR, uniform float4x4 modelViewProj, uniform float3 globalAmbient, uniform float3 lightColor, uniform float3 lightPosition, uniform float3 eyePosition, uniform float3 Ka, uniform float3 Kd, uniform float3 Ks, uniform float shininess ) { // 3D variant of world space vertex position: float3 P = position.xyz; // 3D variant of world space normal vector: float3 N = normal; // light direction vector (world space, normalized): float3 L = normalize( lightPosition - P );

Příklad v Cg // max( cos(alpha), 0 ): float cosa = max( dot(N,L), 0 ); // view vector (world space, normalized): float3 V = normalize( eyePosition - P ); // Blinn's half vector (world space, normalized): float3 H = normalize( L + V ); // cos(beta)^shininess: float cosb = pow( max( dot(N,H), 0 ), shininess ): if ( cosa <= 0 ) cosb = 0; // total ambient color: float3 ambient = Ka * globalAmbient; // total diffuse color: float3 diffuse = Kd * lightColor * cosa; // total specular color: float3 specular = Ks * lightColor * cosb; // output values: vertex position in clip space oPosition = mul( modelViewProj, position ); // sum of all color components: color.xyz = ambient + diffuse + specular; color.w = 1; }

Příklad v shader-assembleru !!ARBvp1.0 # ARB_vertex_program generated by NVIDIA Cg compiler PARAM c12 = { 0, 1, 0, 0 }; TEMP R0, R1, R2; ATTRIB v18 = vertex.normal; ATTRIB v16 = vertex.position; PARAM c0[4] = { program.local[0..3] }; PARAM c10 = program.local[10]; PARAM c5 = program.local[5]; PARAM c9 = program.local[9]; PARAM c4 = program.local[4]; PARAM c8 = program.local[8]; PARAM c11 = program.local[11]; PARAM c7 = program.local[7]; PARAM c6 = program.local[6]; DP4 result.position.x, c0[0], v16; DP4 result.position.y, c0[1], v16; DP4 result.position.z, c0[2], v16; DP4 result.position.w, c0[3], v16; ADD R2.xyz, c7.xyzx, -v16.xyzx; DP3 R0.x, R2.xyzx, R2.xyzx; RSQ R1.w, R0.x; ADD R0.yzw, c6.xxyz, -v16.xxyz; DP3 R0.x, R0.yzwy, R0.yzwy; RSQ R0.x, R0.x; MUL R1.xyz, R0.x, R0.yzwy;...

nízká úroveň: assemblery OpenGL rozšíření různé profily, odlišné přístupy (ATI, NVIDIA, 3Dlabs) vyšší jazyk GLSL vyvíjí 3Dlabs, součástí OpenGL 2.0 (malá podpora) univerzální vyšší jazyk Cg vyvíjen firmou NVIDIA při běhu je zapotřebí „Cg runtime“ (např. „cg.dll“, „cgGL.dll“), dvoustupňový překlad Cg programy lze používat ≈beze změny i v DirectX Shaders v OpenGL

obecná rozšíření: ARB_vertex_program, ARB_vertex_shader, ARB_fragment_program, ARB_fragment_program_shadow, ARB_shader_objects, ARB_fragment_shader specifická rozšíření NVIDIA: NV_vertex_program, NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option, NV_fragment_program, NV_fragment_program_option, NV_fragment_program2, NV_vertex_program3 specifická rozšíření ATI: EXT_vertex_shader, ATI_fragment_shader, ATI_text_fragment_shader Související OpenGL rozšíření

ARB_vertex_program základní verze programů pro „vertex procesor“ – profil „ARBvp1.0“ (ekvivalent DirectX 8.0 = VS 1.0) limity: 16 atributů vrcholu, 96 uniformních parametrů, 12 temp. vektorů, 1 index-registr, 128 instrukcí zdarma: „swizzling“, negace argumentů instrukční sada (27): ABS, ADD, ARL, DP3, DP4, DPH, DST, EX2, EXP, FLR, FLC, LG2, LIT, LOG, MAD, MAX, MIN, MOV, MUL, POW, RCP, RSQ, SGE, SLT, SUB, SWZ, XPD EXT_vertex_shader (zavedla firma ATI) jiný způsob zadávání shaderu (volání glShaderOp*EXT) instrukční sada: trochu užší než ARBvp1.0 Vertex programy

NV_vertex_program základní verze pro NVIDIA GPU – profil „VP1.0“ limity: přesně jako ARBvp1.0 rezidentní programy, „tracking“ matic z aplikace do VP „vertex state program“ (jednorázově pro uniform. par.) instrukční sada (17): ADD, ARL, DP3, DP4, DST, EXP, LIT, LOG, MAD, MAX, MIN, MOV, MUL, RCP, RSQ, SGE, SLT NV_vertex_program1_1 („VP1.1“, „vp20“) přidány 4 instrukce ( ABS, DPH, RCC, SUB ) „position-invariant vertex program“ – počítá pozici úplně přesně jako OpenGL FFP (může být rychlejší) Vertex programy pro NVIDIA

NV_vertex_program2 (profil „VP2.0“, „vp30“) podstatné rozšíření profilů VP1.x (dřív než „ARBvp1.0“) zhruba ekvivalentní DirectX VS 2.0 podmíněné, nepodmíněné skoky, podprogramy (4 úrovně) 4 podmínkové příznaky, podle nich podmíněný zápis uživatelské ořezávání zdarma: absolutní hodnota jakéhokoli argumentu limity: 16 atributů vrcholu, 256 uniformních parametrů, 16 temp. vektorů, 2 index-vektory (10bit), 256 instrukcí nové instrukce (+18): ARA, ARR, BRA, CAL, COS, EX2, FLC, FLR, LG2, RET, SEQ, SFL, SGT, SIN, SLE, SNE, SSG, STR, varianty zapisující do podmínkových příznaků („*C“) Vertex programy pro NVIDIA II

NV_vertex_program2_option rozšiřuje profil ARB_vertex_program, aby obsahoval možnosti NV_vertex_program2 (ten existoval dříve!) direktiva „ OPTION NV_vertex_program2; “ NV_vertex_program3 („vp40“, cca DirectX VS 3.0) formálně: „ OPTION NV_vertex_program3; “ přístup k texturám ( TEX, TXB, TXL, TXP ) zásobník pro adresové registry ( PUSHA, POPA ) relativní adresování (na vstupu i výstupu programu) druhý vektor podmínkových příznaků zdarma: saturace („clamping“) na výstupu instrukce Vertex programy pro NVIDIA III

ARB_fragment_program základní verze programů pro „fragment procesor“ – profil „ARBfp1.0“ (silnější než DirectX PS 1.1) uniformní parametry, přístup ke stavům OpenGL limity: 10 atributů fragmentu (interpolovaných z vrcholů), 24 uniformních parametrů, 16 temp. vektorů, 48 ALU instrukcí, 24 TEX instrukcí, 4 zřetězené textury zdarma: „swizzling“, negace argumentů, „clamping“ výsl. instrukční sada (33): ABS, ADD, CMP, COS, DP3, DP4, DPH, DST, EX2, FLR, FRC, KIL, LG2, LIT, LRP, MAD, MAX, MIN, MOV, MUL, POW, RCP, RSQ, SCS, SGE, SIN, SLT, SUB, SWZ, TEX, TXB, TXP, XPD Fragment programy

ARB_fragment_program_shadow odstranění závislosti na ARB_shadow direktiva „ OPTION ARB_fragment_program_shadow; “ přidány cíle „ SHADOW1D “, „...2D “ a „...RECT “ ATI_fragment_shader zadávání operací přes „glColorFragmentOp*ATI()“ a „glAlphaFragmentOp*ATI()“ 1 až 2 „průchody“: celkem až 8+8 instrukčních párů podobá se NV_texture_shader, NV_register_combiners ATI_text_fragment_shader jiný systém zadávání programu (zdrojový kód) Fragment programy II

NV_fragment_program („FP1.0“, „fp30“, ≈PS2.0) „F32“ ( R ) i „F16“ ( H ) floating-point aritmetika, int12 ( X ) limity: temp. vektorů, 16 tex. jedn., 1024 instrukcí, neomezené čtení z textur, neomezené řetězení textur „lokální“ parametry (konstanty), podmínkové příznaky, podmíněný zápis výsledku op., absolutní hodn. na vstupu, „clamping“ na výstupu, podmíněné zrušení fragmentu instrukční sada (45): ADD, COS, DDX, DDY, DP3, DP4, DST, EX2, FLR, FLC, KIL, LG2, LIT, LRP, MAD, MAX, MIN, MOV, MUL, PK2H, PK2US, PK4B, PK4UB, POW, RCP, RFL, RSQ, SEQ, SFL, SGE, SGT, SIN, SLE, SLT, SNE, STR, SUB, TEX, TXD, TXP, UP2H, UP2US, UP4B, UP4UB, X2D varianty: aritm. ( R,H,X ), zápis do podm. přízn., „clamping“ Fragment programy pro NVIDIA

NV_fragment_program_option rozšiřuje profil ARB_fragment_program, o možnosti NV_fragment_program (ten existoval dříve!) direktiva „ OPTION NV_fragment_program; “ NV_fragment_program2 („fp40“, cca DX PS3.0) formálně: „ OPTION NV_fragment_program2; “ podmíněné skoky, podprogramy, smyčky s pevným opakováním i s podmínkou ( BRK ) normalizace vektoru, dělení skalárem, 2D skalár. součin,.. explicitní LoD do textury, proměnná cyklu při adresaci instrukce (+14): BRK, CAL, DIV, DP2[A], IF/ELSE/ENDIF, LOOP/ENDLOOP, REP/ENDREP, RET, TXL Fragment programy pro NVIDIA II

ARB_shader_objects překlad programů, linkování, zapojování do GL stavu, hlášení o chybách,... ARB_vertex_shader vertex programy v jazyce GLSL ARB_fragment_shader fragmentové programy v jazyce GLSL ARB_shading_language_100 první verze GLSL (dnes existuje verze 1.10 – součást OpenGL 2.0) Rozšíření kolem GLSL

NVIDIA GeForce FX 5200 ARB_vertex_program, ARB_shader_objects, NV_vertex_program, NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option, ARB_fragment_program, ARB_fragment_program_shadow, NV_fragment_program, NV_fragment_program_option, ARB_vertex_shader, ARB_fragment_shader, ARB_shading_language_100 Intel G ARB_vertex_program, ARB_fragment_program ATI Radeon 8500 ARB_vertex_program, EXT_vertex_shader, ATI_fragment_shader ATI Radeon 9000 ARB_vertex_program, EXT_vertex_shader, ATI_fragment_shader Příklady

Literatura Tomas Akenine-Möller, Eric Haines: Real-time rendering, 2 nd edition, A K Peters, 2002, ISBN: Randima Fernando, Mark J. Kilgard: The Cg Tutorial, Addison-Wesley, 2003, ISBN: OpenGL ARB: OpenGL Programming Guide, 4 th edition, Addison-Wesley, 2004, ISBN: Randi J. Rost: OpenGL Shading Language, Addison- Wesley, 2004, ISBN: