Grafiska pipelinens funktion

Transkript

1 LUNDS TEKNISKA HÖGSKOLA CAMPUS HELSINGBORG Grafiska pipelinens funktion Ludvig von Sydow EDT62, HT17 Datorarkitekturer med Operativsystem

2 Sammanfattning Denna rapport syftar till att beskriva hur en graphics pipeline är uppbyggd och vad skillnaden är mellan en graphics fixed-function pipeline och en programmerbar pipeline. Mot bakgrund av detta syfte så har rapporten utgått utifrån följande frågeställningar: Vilka steg har en graphics pipeline? Vad är det för skillnad på en fixed-function pipeline och en programmerbar pipeline? Pipelinen går ut på att från värden på vertex som kommer in i pipelinen ska bearbetas i 4 olika steg för att kunna visa en 3D bild på en 2D display. Rapporten inkluderar en förklaring av dessa steg och vad de gör samt en jämförelse mellan en fixed-function pipeline och en programmerbar pipeline. Resultatet visar att en programmerbar pipeline är mycket mer flexibel och tillfredställande för användare och utvecklare än en fixed-function pipeline. Slutsatserna som presenteras är att steget till programmerbar pipeline är positivt för användare då GPU:s blir mer flexibla och kan användas till mer program än för fixed-function pipelines. 1

3 1 Inledning 1.1 Bakgrund För att ett datorspel eller annan datoranimation med 3D grafik ska gå att visas på en skärm måste systemet ha ett grafikkort. Ett grafikkort eller GPU, Graphics Processing Unit, kan sitta i ett videokort eller på moderkortet. Meningen med ett grafikkort är att den får 3D data från processorn och omvandlar detta till en 2D bild och beräknar hur detta ska visas på skärmen. Den gör alltså beräkningar för hur den ska rendera data på en skärm. Detta sker i den grafiska pipelinen. 1.2 Syfte och problemformulering Syftet med denna rapport är att visa hur en graphics pipeline fungerar. Frågeställningarna lyder: Vilka steg har en graphics pipeline? Vad är det för skillnad på en fixed-function pipeline och en programmerbar pipeline? 2 Graphics pipeline 2.1 Olika delarna i en Graphics pipeline En graphics pipeline är uppdelad i 4 delar: Vertex, Primitive, Fragment och pixel operations. (Kayvon Fatahalian 2011, bild 13). I Vertex delen så beräknas var topparna, det vill säga vertices, av det som ska renderas är. Sedan organiseras dessa i primitive steget där olika vertices sätts ihop. I nästa steg, fragment, så beräknas vilka pixlar som ska användas och ger dem färg. Efter det så visas det på skärmen i pixel operations steget Vertex I vertex delen tas data in från en input assembler som beroende på teknik finns i GPU eller i CPU. Enligt Hock-Chuan (2012) består en vertex av en vector med följande information: 1. Koordinater i ett 3D plan (x,y,z) 2. Färg(Red-Green-Blue) 3. Vertex-normal (n x, n y, n z ) 4. Textur (s,t som är en referenspunkt) Figur 1: Vertices (Fatahalian, 2012) 2

4 2.1.2 Primitives Primitives skapas utifrån att en eller flera vertices och kan se ut på många olika sätt. Exempelvis kan de se ut som trianglar där varje hörn har information om färg, position, textur och dess normal. Då vertices inte är grid-aligned så är inte primitives det heller. (Hock- Chuan, 2012) Figur 2: Primitives (Fatahalian, 2012) Fragments För att bilden ska visas rätt på skärmen måste alla primitives vara rätt anpassade till skärmen. Detta görs i ett rasterization steg genom att varje primitive genomgår en raster-scan som innebär att skärmen tar reda på vilken färg varje pixel har, från vänster till höger och uppifrån och ner, då skapas det fragment inom varje primitiv. Ett fragment har en position (x,y,z) där x och y matchas med skärmens 2D rutnät, z värdet anger vilket djup som fragmentet har. Utöver detta så har varje fragment samma värden som de vertices som anger primitiven. (Hock- Chuan, 2012) Figur 3: Fragments (Fatahalian, 2012) 3

5 2.1.4 Pixel Operations För att bilderna ska kunna visas på skärmen så skickas värdena från processen till framebuffer. Frame-buffer är en speciell del av GPUns minne där färgvärdena från varje pixel lagras. Här läser sedan displayen varje pixels värden och visar sedan dessa. Beroende på pixelns z-värde så visas olika färger på varje pixel. (Hock-Chuan, 2012) Kommenterad [LvS1]: Hur kan vi skriva? Figur 4: Pixels (Fatahalian, November 2012) Processing Varje del förutom den sista är uppdelad i två olika steg, generation och processing. I Generation så tar man emot data från föregåendes process steg där textur har lagts till. Exempelvis så efter att primitiverna fragmenterats så går fragmenten in i processing-steg där varje fragment får en egen färg. Dessa delar av pipelinen kallas i moderna system för shaders som vi kommer prata om lite senare. (Hock-Chuan, 2012) Figur 5: Shaded fragments (Fatahalian, 2012) 4

6 2.2 Fixed-function pipeline Då grafikkort först började produceras var det fixed-function pipelines som användes. I varje processteg i pipelinen så fanns det inbyggda matematiska formler som var komplexa och därmed inte enkla att ändra på. Genom att ställa in vissa inställningar och skicka in matriser med relevanta värden så kunde användaren få grafikkortet att göra användbara saker. Detta sätt var väldigt oflexibelt. I fragments processteg så får pixlarna färg och textur. Om användaren vill få en viss funktion inom detta steg, så fick man i en fixed-function pipeline ställa in detta genom inställningar snarare än programmering. Dessa inställningar kallas för texture environment. Texture enviornment är den del man kan göra flest inställningar i men inte den enda. Man kan exempelvis göra inställningar i vertex-delen med men dessa gick inte att justera lika mycket. vertex-delen är mycket hårdkodad vilket göra denna ännu mer oflexibel. ( 2015) 2.3 Programmable pipeline En programmable pipeline är ser ungefär likadan ut som en fixed-function pipeline. Den enda skillnaden är att i en programmerbar pipeline kan justeringar göras i varje processteg med hjälp av programmering. Dessa steg är nu mycket flexibla och användaren kan programmera beteendet för varje steg. Varje steg har nu en shader Shaders En shader är ett program skapat av användaren som exekveras i process-steget i varje del. Syftet med en shader är att den ska exekvera ett av de programmerbara steg som finns i pipelinen. Det finns några shaders som användaren kan programmera, några exempel är vertex shader, geometry shader och fragment shader. Dessa shaders kan programmeras i språk som OpenGL eller DirectX som båda är språk som påminner om C ( 2015). Figur 6: Graphics pipeline (Hock-Chuan, 2012) 5

7 3 Slutsats En graphics pipeline består av fyra grund-delar som är vertex, primitives, fragments och pixel operations. Dessa är i sin tur uppdelade i två steg enviornment och processing där den förstnämnda tar emot data från tidigare steg medans den senare gör beräkningar och skickar vidare. Skillnaden mellan en fixed-function pipeline och en programmerbar är inte stor. Däremot den lilla skillnad som finns mellan dem resulterar i stor förändring för användaren. En fixedfunction pipeline har hårdkodade matematiska formler i processtegen vilket gör hela processen oflexibel och användaren får oftast anpassa sig till pipelinen snarare än tvärtom. Shaders medför en stor flexibilitet för användaren och kan med denna enkelt anpassa grafiken efter programmet. En slutsats som kan belysas är att utvecklingen från att gå från fixed-function pipeline till programmerbar pipeline är att GPU generellt sätt blivit mer mångsidiga och kan användas till många olika saker. Innan denna utveckling skedde så var GPU:s isolerade och specialanpassade för ett visst program eller liknande. Nu kan en GPU användas effektivt med många olika sorters program oberoende av behovet vilket i sin tur är positivt för den alldagliga användaren. 6

8 Källförteckning OpenGL wiki (hämtade 25/11 17) Följande sub-sidor har används: 1. Fixed_function_pipeline (April 2015) 2. Shader (May 2015) Chua Hock-Chuan, Juli (hämtad 26/11 17) Kayvon Fatahalian, November f12/www/lec_slides/462_gpus.pdf (hämtad 4/12 17) Mark, Maj 2014, (hämtad 26/11 17) 7