Programování GPU ( shaders ) 2004-2005 Josef Pelikán, MFF UK Praha http://cgg.ms.mff.cuni.cz/~pepca/ Josef.Pelikan@mff.cuni.cz
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 Texture Memory Geom. Vertex Processor Vertices Primitive Assembly Clip Project Viewport Cull Geom. Rasterize Fragment Processor Per-Fragment Operations App Memory Pixel Unpack Pixel Transfer Pixels Textures Fragments Frame Buffer Operations Pixels Pixel Pack Pixel Groups Read Control Frame Buffer
Vývoj NVIDIA GeForce 3 (2001) první programovatelná GPU, DirectX 8.0: VS,PS 1.0-1.1 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 1.2-1.4 (jen ATI), VS zůstává 1.1, Radeon 9000
Vývoj II NVIDIA GeForce FX (2002) CineFX architektura ATI Radeon 9500-9700 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 Aplikace Konstanty ( uniforms ) (až 96 vektorů) Vstupní data vrcholu (až 16 vektorů) Vertex-shader (až 128 instrukcí) Výstupní data vrcholu (až 13 vektorů) Pomocné registry (až 12 vektorů) Souřadnice, normála, 2 barvy, mlha, velikost bodu (sprite), 8 texturových souřadnic
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 Aplikace Konstanty ( uniforms ) Pomocné registry Difusní a lesklé světlo Fragment-shader ALU RGBA hloubka z Texturové souřadnice Textury
Prostředí FS 2.0 Aplikace Konstanty ( uniforms ) Pomocné registry Libovolné atributy fragmentu (barvy, tex. souř., normála, jiné vektory,..) Fragment-shader ALU RGBA hloubka z Textury
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;...
Shaders v OpenGL 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
Související OpenGL rozšíření 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
Vertex programy 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 pro NVIDIA 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 II 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 III 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
Fragment programy 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 II 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 pro NVIDIA NV_fragment_program ( FP1.0, fp30, PS2.0) F32 (R) i F16 (H) floating-point aritmetika, int12 (X) limity: 32-64 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 II 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
Rozšíření kolem GLSL 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)
Příklady 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 82915 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
Literatura Tomas Akenine-Möller, Eric Haines: Real-time rendering, 2 nd edition, A K Peters, 2002, ISBN: 1568811829 Randima Fernando, Mark J. Kilgard: The Cg Tutorial, Addison-Wesley, 2003, ISBN: 0321194969 OpenGL ARB: OpenGL Programming Guide, 4 th edition, Addison-Wesley, 2004, ISBN: 0321173481 Randi J. Rost: OpenGL Shading Language, Addison-Wesley, 2004, ISBN: 0321197895 http://developer.nvidia.com/ http://www.shadertech.com/