Számítógépes Grafika Valasek Gábor valasek@inf.elte.hu Eötvös Loránd Tudományegyetem Informatikai Kar 2011/2012. tavaszi félév Tartalom Tartalom Motiváció Grafikus szerelőszalag Áttekintés Modellezési transzformácó Nézeti transzformácó Perspektív transzformácó Vágás Raszterizáció Megjelenítés Triviális hátlapeldobás Festő algoritmus Z-buffer Lokális illumináció Saját szín Konstans árnyalás Gouraud árnyalás Phong árnyalás Emlékeztető Múlt órán megismerkedtünk a sugárkövetéssel Előnyei: A színtér benépesítésére minden használható, ami metszhető sugárral Rekurzióval könnyen implementálható programmal A fény részecske tulajdonságaiból következő hatások szimulálása Ugyanakkor láttuk, hogy vannak hátrányai is: Minden pixelnél minden primitívvel kellett tesztelnünk ezen próbáltunk gyorsítani (dobozolás, térfelosztás) Globális jellegű az algoritmus, nehezen gyorsítható hardveresen A fény hullám természetéből adódó jelenségeket nem tudja visszaadni Valósidejű alkalmazásokhoz túl lassú
Valósidejű grafika Inkrementális képszintézis Fogalmak Sugárkövetésnél tehát ez volt: pixelre indítsunk sugarat: objektummal nézzük van-e metszés Ehelyett próbáljuk meg ezt: objektumra (primitívre): számoljuk ki, mely pixelekre képeződik le és végül csak a legközelebbit jelenítsük meg! Koherencia: Pixelek helyett nagyobb logikai egységekből, primitívekből indulunk ki Pontosság: objektum tér pontosság ( pixel pontosság helyett) Vágás: képernyőből kilógó elemekre ne számoljunk feleslegesen Inkrementális elv: az árnyalási és takarási feladatnál kihasználjuk a nagyobb egységenként szerzett információkat. Összehasonĺıtás Grafikus szerelőszalag Sugárkövetés pixelenként számol amit lehet sugárral metszeni, az használható van tükröződés, fénytörés, vetett árnyékok takarási feladat triviális sok pixel, sok sugár miatt nagy számításigény Inkrementális képszintézis primitívenként számol ami nem primitív, azt azzal kell közeĺıteni külön algoritmus kell ezekhez külön meg kell oldani a koherencia miatt kisebb számításigény A színterünkről készített kép elkészítésének műveletsorozatát nevezik grafikus szerelőszalagnak (angolul graphics pipeline) A valósidejű alkalmazásoknak lényegében a színterünk leírását kell csak átadnia, a képszintézis lépéseit a grafikus szerelőszalag végzi A szerelőszalagban több koordináta-rendszer váltás is történik - minden feladatot a hozzá legjobban illeszkedő rendszerben próbálunk elvégezni
Grafikus szerelőszalag Transzformációk Lépései főbb műveletek szerint: Modellezési transzformáció Nézeti transzformáció Perspektív transzformáció Vágás Homogén osztás Raszterizáció Megjelenítés A grafikus szerelőszalag eredménye egy kép (egy kétdimenziós pixeltömb, aminek minden elemében egy színérték található) A szerelőszalag transzformációinak feladata: a modelltérben adott objektumot eljuttatni a képernyő-térbe Lépései: modell k.r. világ k.r. kamera k.r. normalizált eszköz k.r. képernyő k.r. Szerelőszalag bemeneti adatai Pipeline Ábrázolandó tárgyak geometriai modellje Virtuális kamera adatai (nézőpont és látógúla) A képkeret megadása (az a pixeltömb, amire a színterünk síkvetületét leképezzük) A színtérben található fényforrásokhoz és anyagokhoz tartozó megvilágítási adatok Minden egyes primitív végigmegy az összes lépésen Az egyes lépések az eredményüket a következőnek továbbítják Többféleképpen megadható és csoportosítható - mi csak egy példát írtunk fel (pl. hol színezünk?)
Koordináta-rendszerek Koordináta-rendszerek Modell KR: Az objektumok saját koordináta-rendszerükben adottak. Világ KR: Az objektumok egymáshoz viszonyított helyzete itt adott, ahogy a kamera/szem pozicó és az absztrakt fényforrások pozicója is. Kamera KR: A koordináták a kamera poziciója és orientációjához relatíven adottak. Normalizált eszköz KR: A hardverre jellemző, [ 1, 1] [ 1, 1] [0, 1] kiterjedésű KR. Képernyő KR: A megjelenítendő képnek (képernyő/ablak) megfelelő KR (balkezes, bal-felső sarok az origó). Modellezési transzformácó Nézeti transzformáció A saját (modell) koordináta-rendszerben adott modelleket a világ-koordináta rendszerben helyezi el Tipikusan minden modellre különböző (lehet a színterünk két eleme csak a világtrafóban különbözik!) Jellemzően affin transzformációk Gyakorlatban: ez a Model (vagy World) mátrix a kódjainkban A világ koordináta-rendszert a kamerához rögzített koordináta-rendszerbe viszi át. A transzformáció a kamera tulajdonságaiból adódik. Gyakorlatban: ez a View mátrix.
Kamera transzformácó Kamera transzformácós mátrix Tulajdonságok, mint sugárkövetés esetén: eye, center, up Ebből kapjuk a nézeti koordináta-rendszer tengelyeit: eye center w = eye center u = up w up w v =w u Mátrixot kapjuk: áttérés az eye origójú, u, v, w koordinátarendszerbe: u x u y u z 0 1 0 0 eye x T View = v x v y v z 0 w x w y w z 0 0 1 0 eye y 0 0 1 eye z 0 0 0 1 0 0 0 1 Párhuzamos vetítés Perspektív transzformácó A mátrix ami megadja egyszerű, például az XY síkra való vetítés 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 Emlékeztető: 3. EA A nézeti csonkagúla által határolt térrészt normalizált eszköz KR-be viszi át Ami benne volt a csonkagúlában, az lesz benne a [ 1, 1] [ 1, 1] [0, 1] (vagy [ 1, 1] [ 1, 1] [ 1, 1]) tartományban A transzformáció a kamerán átmenő vetítő sugarakból párhuzamosokat csinál A transzformáció a kamerapozíciót a végtelenbe tolja Gyakorlatban: ez a Projection mátrix
Perspektív transzformácó Középpontos vetítés Emlékeztető: tulajdonságok függőleges és vízszintes nyílásszög (fovx, fovy) vagy az alap oldalainak az aránya és a függőleges nyílásszög (fovy, aspect), a közeli vágósík távolsága (near), a távoli vágósík távolsága (far) Középpontos vetítés Középpontos vetítés Vagyis: x = x z d y = y z d z = z z d = d Az origó, mint vetítési középpont és egy, attól a Z tengely mentén d egységre található, XY síkkal párhuzamos vetítősíkra való vetítés mátrixa: 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 d 0 Homogén osztás után ( z d -vel) a fentit kapjuk
Normalizált látógúla Normalizált látógúla A fenti térből térjünk át egy normalizáltabb gúlába - aminek nyílásszöge x és y mentén is 90 fokos! Mátrix alakban: 1/ tan fovx 2 0 0 0 0 1/ tan fovy 2 0 0 0 0 1 0 0 0 0 1 Normalizált látógúla Vágás Ezután már csak a közeli és a távoli vágosík z koordinátáit kell a normalizálásnak megfelelően átképezni ( 1, 1 vagy 0, 1-re) Ha a közeli vágósíkon elhelyezkedő pontot a z = 0, a távoli vágósíkon elhelyezkedőt pedig a z = 1 síkra akarjuk képezni, akkor ennek mátrixa: 1 0 0 0 0 1 0 0 T Projection = far 0 0 far near 0 0 1 0 near far far near Cél: ne dolgozzunk feleslegesen azokkal az elemekkel, amikből nem lesz pixel (nem jelennek majd meg). Megoldás (kísérlet): 1. Végezzük el a homogén osztást! 2. Vágjunk le, ami kilóg a [ 1, 1] [ 1, 1] [0, 1]-ből! Probléma: vegyünk egy olyan szakaszt, ami átlóg a kamera mögé! Ez a szakasz átmegy egy ideális ponton a szakasz képe nem egyezik meg a transzformált pontokat összekötő szakasszal! Ez az átfordulási probléma.
Vágás homogén koordinátákban Raszterizáció Megoldás (valóban): Vágás homogén koordinátákban Legyen: [x h, y h, z h, h] = M Proj [x c, y c, z c, 1] Cél: (x, y, z) := (x h /h, y h /h, z h /h) [ 1, 1] [ 1, 1] [0, 1], azaz Legyen h > 0, és Ebből kapjuk: 1 < x < 1 1 < y < 1 0 < z < 1 h < x h < h h < y h < h 0 < z h < h Ne feledjük: eddig minden primitív, amiről beszéltünk folytonos objektum volt Azonban nekünk egy diszkrét térben, a képernyő képpontjain kell dolgoznunk A primitívek folytonos teréből át kell térni ebbe a diszkrét térbe, ezt hívják raszterizációnak Raszterizáció Raszterizáció Olyan geometriai primitíveket kell választanunk, amelyeket gyorsan tudunk raszterizálni Mi lehet ilyen? Jó lenne pl. ha egyik pixelhez tartozó felületi pontjának koordinátái alapján könnyen számítható lenne a szomszédos pixelekhez tartozó pontok koordinátái, illetve ha síkbeli is lenne... A háromszög ilyen! Minden egyéb felületet ilyen primitívekkel (lényegében: síklapokkal) közeĺıtünk tesszeláció
Takarási feladat Triviális hátlapeldobás, Back-face culling Feladat: eldönteni, hogy a kép egyes részein milyen felületdarab látszik. Objektum tér algoritmusok: Logikai egységenként dolgozunk, nem függ a képernyő felbontásától. Rossz hír: nem fog menni. Képtér algoritmusok: Pixelenként döntjük el, hogy mi látszik. Ilyen a sugárkövetés is. Feltételezés: Az objektumaink zártak, azaz ha nem vagyunk benne az objektumban, akkor sehonnan sem láthatjuk a felületét belülről. Körüljárási irány: rögzítsük, hogy a poligonok csúcsait milyen sorrendben kell megadni: óramutató járásával megegyező (clockwise, CW) óramutató járásával ellentétes (counter clockwise, CCW) Ha a transzformációk után a csúcsok sorrendje nem egyezik meg a megadással, akkor a lapot hátulról látjuk nem kell kirajzolni, eldobható. Festő algoritmus Festő algoritmus Rajzoljuk ki hátulró előre haladva a poligonokat! Ami közelebb van, azt később a rajzoljuk ami takarva van, takarva lesz. Probléma: hogyan rakjuk sorrendbe a poligonokat? Már háromszögeknél is van olyan eset, amikor nem lehet sorrendet megadni.
Z-buffer algoritmus Z-buffer Képtérbeli algoritmus Minden pixelre nyilvántartjuk, hogy ahhoz milyen mélységérték tartozik (az adott pixelben milyen távolságra volt eddig az abból látható legközelebbi felületdarab) Ha egy primitív raszerizálása során újra erre a pixelre rajzolnánk (Z-test): Ha az új felületdarab Z értéke mélyebben van, akkor ez a pont takarva van nem rajzolunk Ha a régi Z érték van mélyebben, akkor az új pont kitakarja azt (mert az új közelebb van) rajzolunk, eltároljuk az új Z értéket. Z-buffer vagy depth buffer: külön memóriaterület. Képernyő/ablak méretével megegyező méretű tömb. Pontosság: a közeli és távoli vágósík közti távolságtól függ. Minden pixelhez tartozik egy érték a bufferből. Ezzel kell összehasonĺıtani, és ide kell írni, ha a pixel átment a Z-teszten. Gyakorlatban: 16-32 bites elemek Hardveres gyorsítás Pl: közeli vágósík: t, távoli: 1000t, akkor a Z-buffer 98%-a a tartomány első 2%-át írja le. Z-buffer Lokális illumináció Ha már megvannak a primitívjeink pixelekre való leképezései, valahogyan számítsunk színeket by macouno, macouno.com
Saját színnel árnyalás Saját színnel árnyalás Minden objektumhoz/primitívhez egy színt rendelenünk, és kirajzoláskor el lesz a pixelek értéke. Leggyorsabb: az ilumináció gyakorlatilag egyetlen értékadás. Borzasztó: se nem valósághű, se nem szép. Konstans árnyalás, Flat shading Konstans árnyalás A megvilágítást poligononként egyszer számítjuk ki, a szín homogén a lapon belül. Gyors: a műveletek száma a poligonok számától függ, a pixelek számától független. Van hogy használható: íves részeket nem tartalmazó, diffúz, egyszinű objektumokra
Gouraud árnyalás Gouraud árnyalás A megvilágítást csúcspontonként számítjuk ki, a lapon lineáris interpolációval számítjuk a színeket. Lassabb: N db megvilágítás számítás + minden pixelre interpoláció. Szebb: az árnyalás minősége nagyban függ a poligonok számától. Nagy lapokon nem tud megjelenni a csillanás. Phong árnyalás Phong árnyalás Csak a normálvektorokat interpoláljuk, a megvilágítást minden pixelre kiszámítjuk. Leglassabb: pixelek száma db megvilágítás számítás. Legszebb: az árnyalás minősége nem függ a poligonok számától. Csillanás akár poligon közepén is meg tud jelenni.
Gouraud vs Phong árnyalás
Tartalom Számítógépes Grafika Valasek Gábor valasek@inf.elte.hu Eötvös Loránd Tudományegyetem Informatikai Kar 2011/2012. őszi félév Emlékeztető Vágás Motiváció Pontok vágása Szakaszok vágása Szakaszvágás Poligonvágás Raszterizálás Szakasz raszterizálása Háromszög raszterizálása Poligon raszterizáció Inkrementális képszintézis Vágás Inkrementális elv A transzformációk szemszögéből végignéztük a grafikus szerelőszalagot Lényegében egy pont útját követtük végig, a transzformációkon át a képernyőig Most az inkrementális képszintézis szerelőszalagját vizsgáljuk tovább A képernyőn kívüli dolgok azonosítása(3d-ben a nézeti csonkagúlán kívül geometriai elemeket kiszűrése, 2D-ben az ablakkeretre) A nézeti csonkagúla határozza meg a színterünknek azt a részét, amely majd leképeződik a képernyőre (ld. múlt óra) Miért érdemes egyáltalán vágni? Degenerált esetek kiszűrése (ld. pl. múlt óra középpontos vetítés) Ne számoljunk feleslegesen (amit úgyse látunk, ne számoljuk sokat)
Vágás az ablakra Pont vágás: (x, y) R 2, vágjuk a tengelyekkel párhuzamos ablakra (dobjuk el, ha ablakon kívül van). Akkor tartjuk meg a pontot, ha (x, y) [x min, x max ] [y min, y max ]. Megoldás (nem csak tengelypárhuzamos ablakra): a képernyő oldalainak félsíkjaival vágás Szakasz vágás: a szakasznak csak azokat a pontjai akarjuk megtartani, amik benne vannak [x min, x max ] [y min, y max ]-ban. Megoldás: az ablak négy élével, mint négy félsíkkal vágjuk a szakaszt. Poligon vágás: a poligonból egy új poligont akarunk csinálni, ami nem lóg ki az ablakból. Megoldás: A poligon minden oldalát (mint szakaszt) vágjuk. Vágás félsíkra Egy síkbeli elemről el kell dönteni, hogy egy adott félsíkon kívül van-e Félsík megadása: egy határoló egyenesével és egy vektorral, ami a félsík belseje felé mutat (az egyenesre eső pontokat is megtartjuk!) - 2.EA Vágni kell egy elemet, ha nincs a félsíkban Vágás félterre Egy térbeli elemről el kell dönteni, hogy egy adott féltéren kívül van-e Féltér megadása: határoló síkjával és befelé mutató vektorral - 2.EA Vágni kell egy elemet, ha nincs a féltérben Pontok vágása Itt most pontokat vágunk félsíkra (egyenesre), féltérre (síkra) Azaz, azt akarjuk meghatározni, hogy a bemeneti pont az egyenes vagy sík normálisával megegyező irányban fekszik-e az egyenes/sík pontjaihoz képest ( előtte van-e, az egyenes és a normális által meghatározott félsík része-e). Ami mögötte van, nem kell nekünk de ha rajta fekszik, azt is tartsuk még meg Síkra 3D-ben vágunk a nézeti csonkgúla 6 síkja előtti rész (a 6 féltér metszete) ami a tér képernyőre képeződő részét tartalmazza Egyenesre 2D-ben a képernyőn a monitorra kerülő rész 4 egyenes előtti része (4 félsík metszete)
Az egyenes normálvektoros egyenlete a síkban Pont vágása pont-normálvektoros félsíkra Az egyenes megadható egy p = (p x, p y ) pontjával és egy, az egyenes irányára merőleges n = (n x, n y ) 0 normálvektorral: Az egyenes pontjai azon q = (x, y) pontok, amelyek kielégítik a egyenletet. q p, n = 0 (x p x )n x + (y p y )n y = 0 Az q p, n < 0 és q p, n > 0 az egyenesünk által adott két félsíkot határozza meg. Feladat: adott p pont és egy e egyenes (p 0 pontjával és n normálvektorával, n = 1) a síkban. Vágjuk a pontot az e egyenes és n normális által meghatározott félsíkra! Megtartjuk, ha: p p 0, n 0 Ilyenkor a skaláris szorzat eredménye az egyenes egy pontjából az adott pontba mutató vektor előjeles merüleges vetülete a normálisra n = 1 előjeles távolság az egyenestől, ha a normális irányában van a pont, akkor pozitív, ha a normálissal ellentétes irányban negatív (miért?) Előjeles vetület Pont-egyenes távolsága példa
Pont-egyenes távolsága példa Pont vágása pont-normálvektoros félsíkra Ha csak az érdekel minket, hogy előttünk van-e egy pont és nem számít, hogy milyen messze van, akkor nem kell, hogy a normális egységnyi hosszúságú legyen! Hiszen csak a skaláris szorzat előjelére vagyunk kíváncsiak, amit a vektor nemnegatív számmal való szorzása nem változtat, továbbra is csak a bezárt szögtől függ (a cos miatt) Homogén koordinátás alak Pont vágása vonalkoordinátás egyenesre A kibővített (projektív) sík egy egyenese megadható az e = [e1, e2, e3] valós számhármassal, úgynevezett vonalkoordinátákkal, amelyek felhasználásával az egyenes minden x = [x 1, x 2, x 3 ] T pontjára ex = e 1 x 1 + e 2 x 2 + e 3 x 3 = 0 Az sík minden [x 1, x 2, 0] ideális pontjára illeszkedő ideális egyenes vonalkoordinátái [0, 0, 1]. Használjuk ki, hogy a vágásnál már homogén koordinátákban dolgozik a rendszer! Feladat: adott ˆp pont homogén koordinátás alakja és egy e egyenes e vonalkoordinátáival, úgy, hogy e 2 1 + e2 2 + e2 3 = 1 Megtartjuk, ha: e ˆp 0
A sík normálvektoros egyenlete Homogén koordinátás alak A sík megadható egy p = (p x, p y, p z ) pontjával és a síkra merőleges n = (n x, n y, n z ) normálvektorával. Ekkor a sík minden x pontjára: x p, n = 0 A kibővített tér egy síkja is megadható síkkordinátákkal, egy olyan s = [s 1, s 2, s 3, s 4 ] négyessel, amely a sík minden x = [x 1, x 2, x 3, x 4 ] T pontjára sx = s 1 x 1 + s 2 x 2 + s 3 x 3 + s 4 x 4 = 0 Félterek: x p, n < 0, x p, n > 0 Pont vágása síkra Szakasz vágása félsíkra Pont-normálisal adott sík esetén megtartjuk a pontot, ha: p p 0, n 0 Sík-koordinátás (s) megadás esetén (ha s 2 1 + s2 2 + s2 3 = 1) megtartjuk a pontot, ha: A szakasz p és q végpontjait vágjuk az e egyenes és normálisa által meghatározott félsíkra! Az előbb látott módon végezhetjük a vágást! Az eredmény viszont most bonyolultabb egy kicsit s ˆp 0
Szakasz vágása félsíkra Szakasz vágása félsíkra Szakasz vágása félsíkra Szakasz vágása félsíkra - új kezdőpont!
Szakasz vágása félsíkra Szakasz vágása félsíkra Szakasz vágása félsíkra Csak azt a speciális esetet nézzük, amikor a vágó egyenes párhuzamos valamelyik tengellyel. Tegyük fel, hogy az egyik pontja a szakasznak a vágási félsíkon belül, a másik kívül van és a szakasz nem párhuzamos a tengelyekkel (x 1, y 1 ) (x 2, y 2 ) szakasz egyenlete: Vágó egyenes: pl. x = x min x(t) = x 1 + t(x 2 x 1 ) y(t) = y 1 + t(y 2 y 1 ) Megoldás: x min = x 1 + t(x 2 x 1 ) t = x min x 1 x 2 x 1 Metszéspont: x = x min, y = y 1 + x min x 1 x 2 x 1 (y 2 y 1 ) Szakasz vágása - nehézségek Eredmény kezelése: az előbb kapott pont lesz az új végpontja a szakasznak - ahelyett, amelyik kilógott a vágó félsíkból Kivételek: tengelyekkel párhuzamos szakaszok vágása Képernyőre vágásnál is rengeteg eset: négy félsík, két végpont, mindkettő eshet bárhova Feladat: Kell-e vágni? Melyik félsík(ok)ra kell vágni? Triviálisan bent/kint van-e a szakasz? Megoldás: Cohen-Sutherland vágás
Cohen-Sutherland vágás Cohen-Sutherland vágás A képernyő széleit reprezentáló egyenesekkel osszuk kilenc részre a síkot! Mindegyik síkrészhez rendeljünk egy 4 bitből álló bit-kódot: TBRL Számítsuk ki ezt a kódot a szakasz végpontjaira! T = 1, ha a pont az képernyő fölött van, különben 0 B = 1, ha a pont az képernyő alatt van, különben 0 R = 1, ha a pont az képernyőtől jobbra van, különben 0 L = 1, ha a pont az képernyőtől balra van, különben 0 code = Top, Bottom, Right, Left Cohen-Sutherland vágás Cohen-Sutherland vágás code a OR code b == 0: code = (y > y max, y < y min, x > x max, x < x min ), ha a képernyő oldalegyenesei párhuzamosak a tengelyekkel Vizsgáljuk a két végpont bit-kódjait, code a -t és code b -t! Ha code a OR code b == 0: a szakasz egésze (mindkét végpontja) az ablakban van megtartjuk. Ha codea AND code b!= 0: a szakasz az ablak valamelyik oldalán (fölül, alul, jobbra, balra), kívül van eldobjuk. Különben vágni kell: az 1-es bitek adják meg, hogy melyik félsíkra, utána újra számoljuk a bit-kódokat, és az új szakasszal újrakezdjük az algoritmust. code a AND code b!= 0:
Poligonvágás Sutherland-Hodgman poligonvágás Feladat Adott egy vágandó és egy vágó poligon. Keressük azt a poligont, amit a vágandóból kapunk, ha csak a vágó poligonba tartozó részeit vesszük. Röviden: keressük a kettő közös részét. Legyen p tömb a bemeneti-, q a kimeneti-poligon csúcsainak tömbje! Legyen n a csúcsok száma, és p[0] = p[n]! Vágás egyenesre: Ha p[i] bent van az alablakban, és p[i + 1] is: adjuk hozzá p[i]-t a q-hoz. Ha p[i] bent van az alablakban, de p[i + 1] nincs: adjuk hozzá p[i]-t a q-hoz, számítsuk ki p[i], p[i + 1] szakasz metszéspontját a vágó egyenessel, majd ezt is adjuk hozzá q-hoz. Ha p[i] nincs bent az alablakban, de p[i + 1] benne van: számítsuk ki p[i], p[i + 1] szakasz metszéspontját a vágó egyenessel, és ezt adjuk hozzá q-hoz. Ha p[i] nincs bent az alablakban, és p[i + 1] sincs: SKIP Sutherland-Hodgman poligonvágás - Pszeudó-kód Sutherland-Hodgeman: konkáv poligonok PolygonClip(in p[n], out q[m], in line) { m = 0; for( i=0; i < n; i++) { if (IsInside(p[i])) { q[m++] = p[i]; if (!IsInside(p[i+1])) q[m++] = Intersect(p[i], p[i+1], line); } else { if (IsInside(p[i+1])) q[m++] = Intersect(p[i], p[i+1], line); } } } Konkáv poligonokra átfedő éleket hoz létre.
Sutherland-Hodgeman: poligonra vágása poligonnak Mikor vágjunk? A vágópoligon minden élére vágunk, az előző vágás eredmény éllistáját felhasználva kiindulásként Projektív transzformáció előtt a vágósíkok világtérbeli megadásával (mik az egyenletei?) NPKR-ben (projektív trafó után, homogén osztás előtt) a homogén koordináták ellenére ez a legegyszerűbb! Transzformált 3D térben (homogén osztás után) vetítési síkon átmenő objektumok... Szakasz rajzolás Hogyan rajzolunk szakaszt? Egyik leggyakrabb primitív Fontos, hogy szépen tudjuk rajzolni Mégjobb, ha gyorsan is Adott a két végpont. Hogyan tudjuk összekötni őket? Csak miniatűr téglalapjaink vannak (amiket pixelnek nevezünk). Jason Thielke, jasonthielke.com
Szakasz megadása (sokadszor) Naív algoritmus Végpontok: (x 1, y 1 ), (x 2, y 2 ) Tfh. nem függőleges, x 1 x 2, és x 1 < x 2 (ha nem: csere) Szakasz egyenlete: y = mx + b, x [x 1, x 2 ] m = y 2 y 1 x 2 x 1 b = y 1 mx 1 def l i n e 1 ( x1, y1, x2, y2, draw ) : m = f l o a t ( y2 y1 ) / ( x2 x1 ) x = x1 y = f l o a t ( y1 ) while x<=x2 : draw. p o i n t ( ( x, y ) ) x += 1 y += m Naív algoritmus Javítsuk az algoritmust 1. m = float(y2-y1)/(x2-x1) nem pontos y += m a hiba gyűlik y-ban draw.point((x,y)) int-eket vár, lassú a konverzió csak m < 1-re működik helyesen def l i n e 2 ( x1, y1, x2, y2, draw ) : m = f l o a t ( y2 y1 ) / ( x2 x1 ) x = x1 y = y1 e = 0.0 while x<=x2 : draw. p o i n t ( ( x, y ) ) x += 1 e += m i f e >= 0. 5 : y += 1 e = 1.0
Javítsuk az algoritmust 1. Javítsuk az algoritmust 2. Jó: Mindig eltalálja a végpontokat Jó: Egyenletesebben lép az y irányban. Rossz: Még mindig használunk float-okat Rossz: Csak 0 m 1-re működik csak Naív: Javítás: def l i n e 3 ( x1, y1, x2, y2, draw ) : x = x1 y = y1 e = 0.5 while x<=x2 : draw. p o i n t ( ( x, y ) ) x += 1 e += i f f l o a t ( y2 y1 ) / ( x2 x1 ) e >= 0. 0 : y += 1 e = 1.0 Javítsuk az algoritmust 3. Javítsuk az algoritmust 4. def l i n e 4 ( x1, y1, x2, y2, draw ) : x = x1 y = y1 e = 0.5 ( x2 x1 ) while x<=x2 : draw. p o i n t ( ( x, y ) ) x += 1 e += y2 y1 i f e >= 0. 0 : y += 1 e = ( x2 x1 ) def l i n e 5 ( x1, y1, x2, y2, draw ) : x = x1 y = y1 e = (x2 x1 ) while x<=x2 : draw. p o i n t ( ( x, y ) ) x += 1 e += 2 ( y2 y1 ) i f e >= 0: y += 1 e = 2 ( x2 x1 )
Javítsuk az algoritmust 4. Bresenham algoritmus Ez a Bresenham algoritmus (egyik speciális esete) Külön gyűjtjük a hibát e-ben Nem használunk float-okat Tetszőleges meredekségű szakaszokra általánosítható. Nyolcadokra kéne felbontani a síkot, mindegyik külön eset. (Előző javítások végig: 0 m 1) El kell döntenünk, hogy x 2 x 1 vagy y 2 y 1 a nagyobb (merre meredekebb a szakasz). Ha y 2 y 1 a nagyobb, cseréljük fel x i y i, és rajzolásnál is fordítva használjuk! Ha x 1 > x 2, akkor csere: x 1 x 2, y 1 y 2. Az e hibatagot y 2 y 1 -nal növeljük minden lépésben y-nal y 2 y 1 előjele szerint haladunk. Bresenham algoritmus Teljes Bresenham algoritmust 1. def Bresenham ( x1, y1, x2, y2, draw ) : steep = abs ( y2 y1)>abs ( x2 x1 ) i f steep : x1, y1 = y1, x1 x2, y2 = y2, x2 i f x1>x2 : x1, x2 = x2, x1 y1, y2 = y2, y1 Dy = abs ( y2 y1 ) i f y1<y2 : Sy = 1 else : Sy = 1
Teljes Bresenham algoritmust 2. Háromszög raszterizáció x = x1 y = y1 e = (x2 x1 ) while x<=x2 : i f steep : draw. p o i n t ( ( y, x ) ) else : draw. p o i n t ( ( x, y ) ) x += 1 e += 2 Dy i f e >= 0: y += Sy e = 2 ( x2 x1 ) A háromszög oldalait tudjuk vágni - most töltsük ki a belsejét! Ha egy meghatározott bejárási irányban adtuk meg az összes háromszög csúcsát, tudunk félsíkokat adni (tudjuk irányítani az éleket) u.i. ha (t x, t y ) az irányvektora az oldalnak, akkor ( t y, t x ) egy normális lesz Minden pixelre menjünk végig a képernyőn és nézzük meg, hogy a háromszög oldalai által meghatározott síkok jó oldalán van-e! Háromszög raszterizáció Háromszög raszterizáció - okosabban
Háromszög raszterizáció Háromszög raszterizáció Lehetne még okosabban is csinálni, de: gyakorlatban ez a brute-force megközelítés nagyon jól alkalmazható! Nem egy rögzített értékkel akarunk kitölteni, a hanem a csúcsokban adott értékeket akarjuk interpolálni. Felhasználásai: szín (Gouraud-árnyalás), textúra koordinták, normálvektorok Legyen a felület egy pontja p = αp 1 + βp 2 + γp 3, az α, β, γ baricentrikus koordinátákkal adott. Ekkor bármilyen más értéket is végig tudunk interpolálni ugyanígy: c = αc 1 + βc 2 + γc 3 Ez az úgy nevezett Gouraud interpoláció Háromszög kitöltés 1. Baricentrikus koordináták A baricentrikus koordináták számíthatók a következő képletekkel: f o r a l l x : f o r a l l y : α, β, γ = b a r y c e n t r i c ( x, y ) i f α [0, 1] and β [0, 1] and γ [0, 1] : c = αc 1 + β c 2 + γ c 3 draw. p o i n t ( ( x, y ), c ) f 01 (x, y) = (y 0 y 1 )x + (x 1 x 0 )y + x 0 y 1 x 1 y 0 f 12 (x, y) = (y 1 y 2 )x + (x 2 x 1 )y + x 1 y 2 x 2 y 1 f 20 (x, y) = (y 2 y 0 )x + (x 0 x 2 )y + x 2 y 0 x 0 y 2 Ekkor az x, y ponthoz tartozó baricentrikus koordináták: α = f 12 (x, y)/f 12 (x 0, y 0 ) β = f 20 (x, y)/f 20 (x 1, y 1 ) γ = f 01 (x, y)/f 01 (x 2, y 2 )
Háromszög kitöltés 2. Háromszög kitöltés 2. x min = min ( f l o o r ( x i ) ) x max = max( c e i l i n g ( x i ) ) y min = min ( f l o o r ( y i ) ) y max = max( c e i l i n g ( y i ) ) f o r y i n [ y min.. y max ] : f o r x i n [ x min.. x max ] : α = f 12 (x, y)/f 12 (x 0, y 0 ) β = f 20 (x, y)/f 20 (x 1, y 1 ) γ = f 01 (x, y)/f 01 (x 2, y 2 ) i f α>0 and β>0 and γ >0: c = αc 1 + β c 2 + γ c 3 draw. p o i n t ( ( x, y ), c ) Gyorsítás: felesleges minden x, y-t vizsgálni, elég a háromszöget tartalmazó téglalapon végig menni. Inkrementálissá tétel: Most még lassú, nem használjuk, ki hogy sorban megyünk x-en, y-on. Milyenek is ezek az f -ek? Mind f (x, y) = Ax + By + C alakú. Ekkor f (x + 1, y) = f (x, y) + A, ill. f (x, y + 1) = f (x, y) + B Megvalósítás: házi feladat Flood-fill elárasztásos kitöltés Flood-fill szomszédásgok Tetszőleges, már raszterizált poligon kitöltésére alkalmas. Bemenet: raszter kép + annak egy pontja Brute-force: a megadott pontból kiindulva rekurzívan haladunk: Az aktuális pont színe megegyezik a kiindulási pont színével? nem megállunk igen átszínezzük, és minden szomszédra újrakezdjük az algoritmust. Négy szomszéd: fent, lent, jobbra, balra Nyolc szomszéd: az előző négy + a sarkok Rekurzió nagyon durva: gyakorlatban ennél okosabb algoritmusok is vannak aktív éllista stb. (Haladó Grafika)
Tartalom Számítógépes Grafika Valasek Gábor valasek@inf.elte.hu Eötvös Loránd Tudományegyetem Informatikai Kar 2011/2012. őszi félév Textúrázás Bevezetés Textúra leképezés Paraméterezés Textúra szűrés Procedurális textúrák Nem-szín textúrák Inkrementális képszintézis a GPU-n Inkrementális képszintézis DirectX OpenGL Grafikus gyorsítókártya generációk Mi az a textúrázás? Textúrázás Eddig: egyszínű anyag modellek, azaz a teljes felület azonos színű. Kevés ilyen van a valóságban. Finom részleteket szeretnénk megadni. Változó paraméterekre van szükségünk a BRDF-ben. Ezeket a paramétereket, elsősorban színt, adjuk meg a textúrákban.
Textúra megadási módok Leképezési módok Tömbbel : valamilyen 1/2/3 dimenziós tömbből olvasunk, elemei a texel-ek 2D szemléletesen: a geometriánkat a tömbben tárolt képpel fedjük/csomagoljuk be textúratérben vett koordinátákkal azonosítjuk a texeleket, a koordináták [0, 1] intervallumon vannak értelmezve Függvénnyel adjuk meg: valamilyen f (x, y, z) szín függvény segítségével ezt nevezzük procedurális textúrázásnak Két terünk van: képtér (képernyő pixelei) és textúratér (textúra texelei) Honnan, hova képezzünk? Textúratér képtér: textúra alapú leképezés Minden texelhez keressünk a neki megfelelő pixelt. Hatékony. Nem biztos, hogy minden pixel sorra kerül, és ami mégis, nem biztos, hogy csak egyszer. Képtér textúratér: képtér alapú leképezés Minden pixelhez keresünk a neki megfelelő texelt. Inkrementális képszintézishez jól passzol. Szükség van hozzá a paraméterezési és vetítési transzformációk inverzére. Paraméterezés Parametrikus felületek paraméterezése Hogyan tudjuk eldönteni, hogy az egyes felületi pontokhoz a tömb melyik elemét választjuk, vagy a procedurális textúra függvényét milyen paraméterekkel értékeljük ki? A felület minden pontjához textúra koordinátákat rendelünk. A textúra koordináták hozzárendelését a felülethez nevezzük most paraméterezésnek. A továbbiakban 2D textúrákról beszélünk. Parametrikus felület: F R 2 R 3, F(u, v) := (x, y, z) u, v paraméterek természetes módon használhatóak textúra koordinátáknak. Ha D F D tex, akkor u, v-t transzformálni kell. Pl: Henger palást DF = [0, 2π] [0, h], F (u, v) := (cos u, h, sin u) Textúra tér: (ū, v) [0, 1] [0, 1] Transzformáció: ū := u/2π, v := v/h
Háromszögek paraméterezése Háromszögek paraméterezése Legyen adott a háromszög három csúcsa: p i = (x i, y i, z i ) R 3, i {1, 2, 3}, valamint az ezeknek megfelelő csúcsok textúra térben: t i = (u i, v i ) R 2, {1, 2, 3}. Olyan R 3 R 2 leképezést keresünk, amire p i t i, és háromszöget háromszögbe visz át. A legegyszerűbb ilyen leképezés a lineáris leképezés, ami megadható egy 3 3-as mátrixszal. x A x A y A z u u y = B x B y B z v = P v z C x C y C z 1 1 x A x A y A z u u y = B x B y B z v = P v z C x C y C z 1 1 Kilenc ismeretlen, kilenc egyenlet Ez textúra alapú leképezés! Képtér alapú leképezéshez inverz trafó kell: u x v = P 1 y 1 z Textúrázás és sugárkövetés Model KR textúra tér Felület-sugár metszés: világ-koordináta rendszerben Inverz transzformációk: Világ KR Model KR Model KR textúra tér Parametrikus felületek A metszéspont számítás során adódik u, v, nem kell külön számítani. Háromszögek Az előbb levezetett P 1 szükséges. Gyorsítási lehetőség: ha sem maga a háromszög, sem a textúra koordináták nem változnak a csúcsokban, akkor P 1 állandó.
Háromszögek paraméterezése Perspektívikusan korrekt textúrázás Gyakorlatban ez gyorsan számítható inkrementális algoritmussal. Ha a három csúcsban adottak a textúra koordináták, akkor ezeket a háromszögek kitöltésénél használt algoritmussal kiszámíthatjuk minden pixelre. Minden pontra legyen a felület egy pontja p = αp 1 + βp 2 + γp 3, az α, β, γ baricentrikus koordinátákkal adott. Ekkor a p-hez tartozó textúra koordináta is megkapható t = αt 1 + βt 2 + γt 3 alapján A textúra koordináták lineáris interpolációja hibás képet ad, ha a megjelenítendő háromszögön nem csak affin transzformációt végzünk. Értsd: esetek 99%-a. Perspektívikusan korrekt textúrázás Perspektívikusan korrekt textúrázás Tehát u, v lineáris interpolációja nem lesz jó nem affin transzformációk esetén - nem lineárisak a képernyőtérben Transzformálva, homogén osztás előtt a koordinátáink legyenek [x t, y t, z t, w t ] Homogén osztás után: [x s, y s, z s, 1] = [ x t w t, y t w t, z t w t, 1] Ha [x s, y s, z s, 1] szerint interpoláljuk a textúra koordinátákat, akkor az nem lesz jó. Ezzel szemben: ha 1 w -t interpoláljuk, az helyes marad! Sőt, bármilyen q w érték jól interpolálódik! α, β, γ helyett használjuk a világ koordináta-rendszerbeli α w, β w, γ w koordinátákat, és αw w, βw w, γw w interpolálva helyes textúrázást kapunk.
Textu ra k szu re se I Ritka n esik pontosan egy texel egy pixelre. I Nagyı ta s: a pixel me rete kisebb a texele ne l to bb pixel jut egyetlen texelre. OpenGL: GL TEXTURE MAG FILTER I Kicsinyı te s: a pixel me rete nagyobb a texele ne l to bb texel jut egyetlen pixelre. OpenGL: GL TEXTURE MIN FILTER I Egy pixel me rete kisebb egy texele ne l to bb pixel jut egyetlen texelre I Szu re s ne lku l: a pixel ko ze ppontja hoz legko zelebb eso texel e rte ke t haszna ljuk. I Bilinea ris szu re s: a legko zelebbi ne gy texel su lyozott a tlaga t vesszu k. Tova bbi proble ma: ami a textu ra te rben linea ris, az nem az a ke pte rben a perspektı va miatt. Kicsinyı te s Egy pixel me rete nagyobb egy texele ne l to bb texel jut egyetlen pixelre I Pontos mintave teleze s lenne: a pixel ne gyzete t transzforma ljuk el textu ra te rbe, e s az ott kijelo lt texelek a tlaga t vegyu k. I Helyette: a textu ra te rben is ne gyzetet veszu nk. I Gyakorlatban: a textu ra egy tetszo leges ne gyzete nek a lea tlagola sa tu l ero forra s ige nyes, helyette vagy haszna ljunk kevesebb texelt, vagy MIP-map-eket Kevesebb pixel: I Nagyı ta s I I Szu re s ne lku l: a pixel ko ze ppontja hoz legko zelebb eso texel e rte ke t haszna ljuk. Bilinea ris szu re s: a legko zelebbi ne gy texel su lyozott a tlaga t vesszu k. MIP-map-ek I MIP: multum in parvo sok, kis helyen I U.n. pirasmist genera lunk a textu ra bo lbo l, minden szinten felezve a me rete t
MIP-map-ek Procedurális textúrák Szűrés során kiválasztjuk a pixel/texel terület aránynak megfelelő szintet és onnan olvasunk. Az adott MIP-map-en belül is lehet az olvasás szűrés nélküli, vagy lehet bilienárisan szűrt. Trilineáris szűrés: két szomszédos szintet használunk, azokon belül bilineáris szűréssel, és ezeknek vesszük a súlyoztott átlagát. A textúrákat tömb helyett megadhatjuk függvénnyel is. Textúra koordináták a függvény paraméterei. generated with Filter Forge Tulajdonságai Nem-szín textúrák Előnyök: Sokkal kevesebb tárhely Tetszőleges felbontás csak a numerikus pontosság a korlát Nagyításnál nem kell szűrés. (Kicsinyítést sajnos nem oldja meg.) Hátrányok: Nagy számítás igény. Nem lehet vele bármit leírni. Nem módosítható tetszőlegesen. A textúrák segítségével a felületi pont bármilyen tulajdonságát leírhatjuk. Ezek a tulajdonságok lehetnek pl.: felületi normális Bucka ill. normál leképezés elmozdulás Displacement leképezés fényforrás láthatósága Árnyék térképek tükörként visszavert fény Visszaverődés leképezés ill. Környezet leképezés
Bucka vagy normál leképezés Displacement leképezés A textúrával normál vektorokat adunk meg. A felület eredeti normálisai helyett ezeket használjuk a megvilágítás számításakor. Rücskös/érdes felület látszatát adja, amíg nem nézünk rá túl lapos szögben. A feületi pontot tényleges arrébb mozdítjuk. A csak háromszögek csúcsait tudjuk elmozdítani függ a geometria felbontásától. Lapos szögben is helyes látványt kapunk. + = generated with Filter Forge Árnyék térképek Visszaverődés leképezés A fényforrás szemszögéből készítünk egy textúrát, amiben a fényforrástól vett távolságokat tároljuk el. A tényleges rajzolás során ez alapján döntjük el minden pontra, hogy azt éri-e közvetlenül a fény vagy sem. Sík tükrök esetén használható. Külön képet készítünk, textúrába mentve, arról, hogy mi látszik tükörirányban. Ezt textúraként ráfeszítjük a felületre a végső kirajzoláskor. Csak egyszeres tükröződést ad. Tükrönként külön el kell végezni. + =
Ko rnyezet leke peze s I A szı nteru nk ko rnyezete t ve gtelenu l ta volinak tekintju k. I Specia lis textu ra ban ta roljuk. I Rajzola s a tu kro zo do felu letekhez ebbo l olvasunk a tu ko rira ny szerint. DirectX 9 pipeline Inkrementa lis ke pszinte zis DirectX 9 pipeline I Vertex data: a modell-koordina tarendszerbeli pozı cio adatok I Primitive data: o sszeko te si szaba lyok, az elo bbiekbo l hogyan kapunk rajzola si primitı veket I Tesselation: magasabb rendu primitı vek linea ris ko zelı te se, a ko zelı te sek csu cspontjainak vertexpufferbe helyeze se I Vertex processing: a vila g, ne zeti e s projektı v transzforma cio k elve gze se; a modell-koordina tarendszerbo l NPKR-be visz (z [0, 1]
DirectX 9 pipeline DirectX 9 pipeline Geometry processing: vágás, hátlapeldobás, raszterizáció Textured surface: 1/2/3D-s textúra Texture sampler: textúra mintavételező, szűrések stb. Pixel processing: a bejövő fragment színének kiszámítása Pixel rendering: képernyőre kerülő pixel színének meghatározása (mélységi és egyéb tesztek) A fenti fázisok közül kettő programozható, a vertex és a pixel feldolgozás, a többi konfigurálható Vertex shader: bemenete: általában modell-kr-beli pont és egyéb attribútumok kimenete: NPKR-beli pont és egyéb attribútumok Pixel shader: bemenete: a raszterizálás végén előálló fragmentek - az összes attribútum elérhető, amit a vertex shaderben előállítottunk kimenete: egy színérték DirectX 9 pipeline DirectX 10 pipeline Régen a vertex és a pixel feldolgozási fázis sem volt programozható Csak konfigurálni tudtuk őket pl. transzformációs mátrixokat átadni, a DX-be bedrótozott megvilágítási modelleket felparaméterezni stb. Ezt hívták Fixed Function Pipeline-nak
DirectX 10 pipeline DirectX 10 pipeline Input-Assembler stage: a pipeline bemeneti adatainak előállítását végzi Vertex-Shader stage: ld. mint korábban Geometry-Shader stage: bemenetként egész primitíveket kap (háromszögek esetén 3, szakaszoknál 2, pontoknál 1 pont), eldobhatja a bejövő primitívet vagy egy vagy több új primitívet létrehozhat és a szerelőszalagra helyezheti. Ez egy új, programozható fázis Stream-Output Stage: a pipeline-ból a memóriába való adattovábbításra használható, a raszterizálás előtt történik. Adatokat be- és ki is lehet írni raszterizáláshoz. Rasterizer Stage: raszterizálás Pixel-Shader Stage: ld. korábban Output-Merger Stage: a különböző kimeneti adatok (szín-, mélységi- és egyéb információk) felhasználásával a végső eredmény kiszámítása Geometry Shader DirectX 11 pipeline Feladata: új geometria generálása, (vagy régi eltüntetése) A vertex shader által már transzformált primitívekre fut let. Bemenete: teljes primitív (szomszédsági infókkal, ha vannak) Kimenete: újabb primitív[ek], vagy semmi. Kimeneti típusok:pointstream, LineStream, vagy TriangleStream
DirectX 11 pipeline Tesszelációs lépések A DX10-es pipeline-nak megfelelő, de itt a tesszeláció már programozható Emellett a DX11-ben az általános számításokra való felhasználás is előtérbe került ComputeShader Régóta nagy az igény a GPU-kban rejlő számítási kapacitás kihasználására Ui. pl.: Intel Core i7 980 XE: 109 GFLOPS, Nvidia GTX 480: 672 GFLOPS, dupla pontosságban Speciális primitív tipusokat használ négyszög foltok (patches) háromszög foltok iso-vonalak Alapötlet: a transzformációkat az alacsony felbontású foltokon végezzük, és tesszelációval, hardveresen bontjuk fel kisebb darabokra és tesszük részletgazdaggá. Használató: displacement mapping nézet függő dinamikus LOD (level of detail) morph-olások gyorsítása Hull Shader Stage Tesselator Stage Foltonként dolgozza fel a bementi pontokat. Konstansokat rendel a folthoz, amik a tesszelálás módját határozzák meg. Megadja a tesszeláció mértékét. Két külön kimenet: Vezérlő pontok a Domain Shader-nek Konstansok a Tesselator Stage-nek msdn.microsoft.com Nem programozható. Felbontja a tartományt kisebb darabokra (négyszög, háromszög, szakasz). u, v (opcionálisan w) koordinátákat állít elő kimenetként. Láthatatlan kimenet: topológiai információk a primitive assembly-nek
Domain Shader Stage Compute Shader A Tesselator Stage során előállított minden egyes pontra lefut. Bemenete: A Tesselator Stage-től: u, v, (w)-k. A Hull Shader-től: vezérlő pontok A Hull Shader-től: tesszelációs faktorok A bemetekből egyetlen csúcspontot állít elő, és az lesz a kimenet. msdn.microsoft.com Általános célú számításokat tesz lehetővé a GPU-n. Speciális adatszerkezeteket használ. Nincsenek megszorítások a ki- és bemenetekre. Felhasználásai: Képfeldolgozás/post-processing Ray-tracing Fizika AI Testvérei CUDA OpenCL OpenGL pipeline OpenGL 3.x pipeline Más elnevezésekkel, de nagyjából hasonlóak, mint a DX
OpenGL 4.1 pipeline 1. Generáció NVIDIA TNT2, ATI Rage, 3dfx Voodoo3 A standard 2d-s videokártyák kiegészítése Csúcspont transzformációkat még a CPU csinálja! A kártya csak a textúrázást, Z-buffer kezelést végezte 2. Generáció (1999-2000) 3. Generáció (2001) NVIDIA GeForce 256, GeForce 2, ATI Radeon 7500 Átveszik a transzformációk és az árnyalás kezelését a CPU-tól. Az OpenGL és DirectX 7 is támogatja a hardveres csúcspont transzformációkat Multi-textúrázás megjelenése: bump map, light map Konfigurálható (driver szinten), de még nem programozható NVIDIA GeForce 3, GeForce 4 Ti, Xbox, ATI Radeon 8500 A csúcspont pipeline korlátozott programozhatósága Fejlettebb pixel szintű konfigurálás, de még nem programozás 3d-s textúrák, többszörös mintavételezés (antialias-hoz)
4. Generáció (2002) 5. Generáció (2004) NVIDIA GeForce FX, ATI Radeon 9700 A csúcspont és pixel pipeline teljesen programozható (erőforrás-korlátok azért még vannak) Magas szintű árnyaló nyelvek (shading languages) megjelenése (NVIDIA Cg, Microsoft HLSL, OpenGL GLSL) Shader Model 2.0 (simple branching) NVIDIA GeForce 6, ATI Radeon X, GeForce 7 Több puffer szimultán renderelése 64bites pipeline PCIe busz Több memória, hosszabb csúcspont árnyaló programok Shader Model 3.0 (branching and looping in the pixel shader (physics)) HDRI, SLI, TSAA, TMAA 6. Generáció (2007) 7. Generáció (2009-) DirectX 10 Shader Model 4.0 (Unified Shader Model, geometry shader) Unified Shading Architecture Shading performance 2x pixel, 12x vertex above G71 700 Mtransistors 130W to 300W DirectX 11, OpenGL 4.1 Shader Model 5.0 (Compute Shader, Tesselation Shaders: Hull Shader & Domain Shader) Többszállúság Dynamic Shader Linkage: OOP jellegű szolgátatások HLSL-ben 3000+ Mtransistors 1000 GFLOPs
Tartalom Számítógépes Grafika Valasek Gábor valasek@inf.elte.hu Eötvös Loránd Tudományegyetem Informatikai Kar 2011/2012. őszi félév Megvilágítási modellek megvalósítása Absztrakt fényforrások Megvilágítási modellek Shader programok Virtuális világ tárolása Geometria tárolása Brute force tárolás Index pufferek Topológia tárolása Szárnyas-él adatszerkezet Fél-él adatszerkezet Absztrakt fényforrások Jelölések Irányfényforrás csak iránya van egyetlen (világ k.r. beli) vektor megadja a fénysugarakat párhuzamosnak tekintjük távoli fényforrások megadására használható Pont fényforrás csak pozíciója van egy ponttal adjuk meg, világ k.r.-ben Pl.: villanykörte Spot fényforrás iránya, poziciója és fényköre van két szög + egy pont és egy vektor adja meg (világ k.r.!) Pl.: asztali lámpa v := ω a nézeti irány l := ω a megvilágító, a fényt adó pont fele mutató vektor n a felületi normális r: az ideális visszaverődés iránya az l beesési irányból, n normális mellett v, l, n egységvektorok θ a l és a n által bezárt szög φ az r és v által bezárt szög
Jelölések Jelölések Jelölések Ambiens tag A színtéren mindenütt jelenlevő fénymennyiség. Képlet: k a L a. k a a felülettől függ, legyen float4 ambientcolor. A float4 egy rgba négyes, ahol a az átlátszóság Itt a k a számnégyese azt határozza meg, hogy a beeső fényintenzitás hányad részét veri vissza az anyag az R, G, B-nek megfelelő hullámhosszokon L a fénytől, felülettől független, az állandó háttérmegvilágítás intenzitása az RGB hullámhosszokon. Szintén legyen float4 ambientlight, de a 1. Pixel shaderben használható: ambientcolor*ambientlight
Lambert-törvény Spekuláris visszaverődés - Phong modell BRDF: L ref = L i k d cos + θ Ezt neveztük diffúz színnek. k d és L i mint az előbb, de L i az aktuális fényforrás tulajdonsága: float4 diffusecolor float4 diffuselight Kéne még: cos + θ. Kiszámítása: saturate(dot(normal, tolight)) Ismerni kell hozzá normal = n-t és tolight =l-t. Spot fényforrásnál a fénykört is figyelembe kell majd venni. BRDF: L ref = L i k s (cos + φ) n, ahol φ az r tükörirány és a v nézeti irány által bezárt szög. k d és L i (ez egy másik L i ) megint mint az előbb, L i szintén az aktuális fényforrás tulajdonsága: float4 specularcolor float4 specularlight n felület függő konstans, legyen float specularpower Spekuláris visszaverődés - Phong modell Összefoglalva BRDF: L ref = L i k s (cos + φ) n ; r tükörirány és a v nézeti irány. Kéne cos + φ, amihez meg kéne r és v. r a l vektor n-re vett tükörképe. Számítása: float3 reflection = reflect(-tolight, normal) v a nézeti irány, azaz a feületi pontból a kamerába mutató egységvektor. float3 directiontoeye = normalize(eyeposition-worldpos) (cos + φ) n számítása: pow(saturate(dot(reflection, directiontoeye)), specularpower) Felület tulajdonságai ambientcolor diffusecolor specularcolor specularpower normal worldpos Fényforrás tulajdonságai diffuselight specularlight tolight Színtér tulajdonságai ambientlight eyeposition
Összefoglalva Adatstruktúrák Minden felületi-optikai tulajdonságot meg lehet adni konstanssal, vagy akár textúrával. (Sőt, még többet, ha ügyesek vagyunk!) Minden vektor és pont világkoordináta-rendszerben adott. eyeposition-t frissíteni kell, ha változik a nézet! Probléma: a modellünk modell k.r.-ben van, és a Vertex Shader normalizált eszköz k.r.-be visz át! Megoldás: számoltassunk a Vertex Shader-rel világ k.r.-beli koordinátákat is! s t r u c t VS INPUT { f l o a t 4 pos : POSITION ; f l o a t 3 normal : NORMAL; } ; s t r u c t VS OUTPUT { f l o a t 4 pos : POSITION ; f l o a t 3 normal : TEXCOORD0; f l o a t 3 worldpos : TEXCOORD1; } ; Vertex shader Pixel shader VS OUTPUT LightingVS ( VS INPUT i n p u t ) { VS OUTPUT output ; output. pos = mul ( i n p u t. pos, WorldViewProjection ) ; output. worldpos = mul ( i n p u t. pos, World ). xyz ; output. normal = mul ( InvWorld, f l o a t 4 ( i n p u t. normal, 0 ) ). xyz ; } r e t u r n output ; f l o a t 4 LightingPS ( f l o a t 3 normal : TEXCOORD0, f l o a t 3 worldpos : TEXCOORD1) : COLOR0 { normal = normalize ( normal ) ; f l o a t 3 t o L i g h t =??? / / Fenyforras fuggo f l o a t d i f f u s e I n t e n s i t y = s a t u r a t e ( dot ( normal, t o L i g h t ) ) ; f l o a t 3 r e f l e c t i o n = r e f l e c t ( t o L i g h t, normal ) ; f l o a t 3 directiontoeye = normalize ( eyeposition worldpos ) ; / /...
Pixel shader tolight számítása / /... f l o a t s p e c u l a r I n t e n s i t y = pow ( s a t u r a t e ( dot ( r e f l e c t i o n, directiontoeye ) ), specularpower ) ; i f ( d i f f u s e I n t e n s i t y <= 0) s p e c u l a r I n t e n s i t y = 0; r e t u r n ambientcolor ambientlight + d i f f u s e I n t e n s i t y d i f f u s e C o l o r d i f f u s e L i g h t + s p e c u l a r I n t e n s i t y specularcolor s p e c u l a r L i g h t ; } Irány fényforrás Fény iránya, normalizált irányvektor: float3 lightdirection tolight = -lightdirection Pont fényforrás Fény poziciója, helyvektor: float3 lightposition tolight = normalize(lightposition-worldpos) Spot fényforrás Fény iránya, normalizált irányvektor: float3 lightdirection Fény poziciója, helyvektor: float3 lightposition tolight = normalize(lightposition-worldpos) mint pont fényforrás esetén Spot fényforrás hatása Két extra paraméter: belső fénykör: amin belül teljes intenzitással hat külső fénykör: amin kívül abszolúlt nem hat A kettő között folyamatosan csökken a fény intenzitása. A fényköröket a fényforrásból induló, a fény irányával megeggyező állású (végtelen)kúpoknak tekintjük. Egy felületi pont akkor van benne egy kúpban, ha a pontot a fényforrás poziciójával összekötő egyenes a kúpon belül van.
Spot fényforrás hatása Spot fényforrás hatása Az előbbi szakasz iránya pont a tolight. Ha a lightdirection és a -tolight által bezárt szög, kisebb, mint a kúp nyílásszögének a fele, akkor a szakasz benne van a kúpban, azaz a felületi pont is. A szögek helyett elég vizsgálni azok cos-át, ha a max. nyílásszög 180. Adjuk meg a két fénykört, a hozzájuk tartozó kúpok nyílásszögének felének cos-áva: belső fénykör: cosinnercone külső fénykör: cosouttercone smoothstep(min, max, x): 0, ha x<min 1, ha x>max lin. átmenet 0 és 1 között kül. float spotfactor = smoothstep(cosouttercone, cosinnercone, dot(lightdirection, -tolight)) Ezzel kell beszorozni a diffúz és a spekuláris tagot. Pl. diffuseintensity-t és specularintensity Tartalom Virtuális világ tárolása - kérdések Megvilágítási modellek megvalósítása Absztrakt fényforrások Megvilágítási modellek Shader programok Virtuális világ tárolása Geometria tárolása Brute force tárolás Index pufferek Topológia tárolása Szárnyas-él adatszerkezet Fél-él adatszerkezet Hol táruljuk az adatokat? Mem. vagy HDD? Mire optimalizálunk? Rajzolás vagy szerkesztés? Milyen koordináta-rendszerben tároljuk őket? Világ vagy modell kr?
Geometria brute force tárolása Geometria brute force tárolása Legyenek a primitíveink poligonok (bejárási irány megegyezés szerint) Legyünk lusták, és minden poligont tartsuk nyilván az összes csúcsával. Poligonokkal kapcsolatos feladatok: tárolás transzformálás szomszédsági lekérdezések s t r u c t t r i a n g l e { f l o a t x1, y1, z1 ; f l o a t x2, y2, z2 ; f l o a t x3, y3, z3 ; } ; A brute force tárolás elemzése Index pufferek Tárolás: ha vannak poligonoknak közös csúcsai, akkor ezeket többször tároljuk feleslegesen nem túl jó Transzformálás: a közös csúcsokra annyiszor fogjuk elvégezni a transzformációkat, ahányszor szerepelnek nem hatékony Lekérdezések: fogalmunk sincs, ki kinek a szomszédja, csak az összes csúcs bejárásával tudunk eredményre jutni katasztrófa Egyetlen előnye, hogy ennél egyszerűbben már nem is lehetne tárolni. Alapötlet: tároljunk minden csúcsot egyszer, egy nagy közös tömbben! A poligonok csak hivatkozzanak a csúcsok tömbjének elemeire. Ez az index puffer. Minden GPU támogatja.
Index buffer-ek Példa s t r u c t t r i a n g l e { unsigned i n t a, b, c ; } ; s t r u c t vec3 { f l o a t x, y, z ; } ; std : : vector <vec3> v e r t e x B u f f e r ; std : : vector <i n t > i n d e x B u f f e r ; Vegyünk egy N N db négyzetből álló rácsot! Hány darab csúcsot kell tárolni? Mérete index puffer nélkül: 4 csúcs/négyzet, N N négyzet: 4N 2 csúcspont. Mérete index puffer-rel: (N + 1) (N + 1) = N 2 + 2N + 1 csúcs (+ 4N 2 egész szám, index) 4N 2 vs. N 2 + 2N + 1 4N 2 >N 2 + 2N + 1 0 > 3N 2 + 2N + 1 N >1, ha N Z + Példa folyt. index puffer-ek GPU-n Ha több mint egyetlen négyzetünk van, már megéri. Pl. ha N = 10 Mérete index puffer nélkül: 400 csúcsot tárolunk és transzformálunk Mérete index puffer-rel: 121 csúcsot tárolunk és transzformálunk Minden videókártya, amit még nem gyűjtenek a múzeumok támogatja az index puffer-eket. A csúcspontok tömbje (vertex buffer) nem csak pozicókat tartalmaz, hanem normálvektorokat, textúra-koordinátákat, és még sok mást. Egy hivatkozás a vertex buffer-ra mindezekre együtt hivatkozik.
Kocka probléma Kocka probléma Ha egy kockát rakunk össze háromszögekből, akkor egy sarokban lévő csúcs min. három, max. hat háromszögnek a csúcsa. index puffer-rel elég lenne 8 csúcsot nyilvántartani. Mi lesz a normálisokkal? Hogy éles sarkai legyenek a kockának a normálisoknak merőlegesnek kell lennie a lapokra! Oldalanként külön meg kell adni a csúcsokat: összesen 3 8 csúcs kerül az vertex buffer-ba. Kocka probléma Az index pufferes tárolás elemzése A probléma: bár egyetlen térbeli pontot jelöl egy sarok, valójában három különböző felület felületi pontja Mivel a csúcspontokban pozíciókon kívül felületi tulajdonságokat is tárolunk (normális), ezért ilyenkor még index pufferrel sem spróolhatjuk ki a redundanciát! Tárolás: ált. hatékony. Transzformálás: hatékony. Lekérdezések: közös csúcsokat már tudunk, de igazából még mindig fogalmunk sincs.
Szomszédsági viszonyok Szárnyas-él adatszerkezet Néha kellenek a szomszédok, pl. felület-felosztásoknál, degenerált primitívek kiszűrésekor, egyes felhasználói inputok kezelésekor stb. Ismertek a csúcsok számítható mi, minek a szomszédja! Egy csúcsban tetszőleges számú poligon találkozhat dinamikus adatszerkezet kéne Jobb megoldás: Szárnyas-él (winged-edge) adatszerkezet! Az alakzatokat határukkal leíró (B-rep) (boundary representation) reprezentáció egyik gyakran használt topológiatároló adatszerkezete manifold poliéderek esetén Tárolás során csúcsokat, éleket és lapokat különböztet meg Az élek szempontjából tároljuk a felületet Minden élhez fix számú adat tartozik Segítségével pl. gyorsan körbe lehet járni egy poligon éleit, közben megkapva minden szomszédot Szárnyas-él adatszerkezet Egyetlen él adatai Minden lapot egy élsorozat határol - minden laphoz tároljunk egy, az élsorozatához tartozó tetszőleges élre mutató pointert A csúcspontok élekhez illeszkednek (vagy belőle indul ki, vagy ő a célja) - tároljuk valamelyiket a csúcsokhoz! Egy él két csúcsot köt össze - tároljuk ezeket az élben Egy él legfeljebb két laphoz tartozhat - az egyik a baloldali, a másik a jobboldali lap lesz, ezekre mutató pointereket (vagy indexeket) tárolunk A fenti két lapon egyúttal egy-egy élsorozat (az adott lapot alkotó élsorozat) része is az adott él - mindkét élsorozatban tároljuk a rákövetkezőjét és megelőzőjét az adott élnek az adott lap bejárási irányának megfelelően (!)
Egyetlen él adatai Egyéb táblázatok 2*él csúcs lap balra jobbra start vég bal jobb előző köv. előző köv. a B A 0 1 c b d e Csúcsok táblája csúcs ID csúcsból induló él Lapok táblája lap ID lap egy éle Példa: tetraéder Pl.: Egy lap összes szomszéd lapjának felsorolása def allneighbours ( face, edges, v e r t i c e s, faces ) : startedge = faces [ face ] edge = startedge i f edges [ startedge ]. f a c e L e f t == face : while edges [ edge ]. succleft!= startedge : p r i n t edges [ edge ]. faceright edge = edges [ edge ]. succleft else : while edges [ edge ]. succright!= startedge : p r i n t edges [ edge ]. f a c e L e f t edge = edges [ edge ]. succright Shirley, Fundamentals of Computer Graphics
Pl.: Egy lap összes szomszéd lapjának felsorolása Pl.: Egy adott csúcsot tartalmazó összes lap felsorolása Azaz: induljunk el az adott lap reprezentáns éléből (amit tárolunk a laphoz) Ha ennek az élnek a baloldali lapja az adott lap: iteráljunk végig a baloldali éllistán és írjuk ki a jobboldali lapokat (a baloldali a lekérdezést kiváltó lap) Különben a jobboldali lap az adott lap, iteráljunk végig a jobboldali lap éllistáján Az iteráció érjen véget, amint visszaérünk az adott lap reprezentáns élébe def allfaces ( vertex, edges, v e r t i c e s, faces ) : startedge = v e r t i c e s [ v ertex ] edge = startedge done = False while not done : i f edges [ edge ]. v e r t S t a r t == vertex : p r i n t edges [ edge ]. f a c e L e f t edge = edges [ edge ]. predleft else : p r i n t edges [ edge ]. faceright edge = edges [ edge ]. predright Fél-él adatszerkezet Half-edge A winged-edge élét vegyük szét két fél-élre! lényegében az élek lapra vett vetületével dolgozunk! A fél-élhez csak egy lap tartozhat + meg kell jegyeznünk a testvér fél-élét (az adott él másik oldali lapra vett vetületét) A reprezentáció központi eleme a fél-él
Half-edge Fél-él adatszerkezet Szigorú értelemben véve egy fél-élhez pontosan egy csúcs, él és lap tartozik (de gyakorlatban ennél többet tárolni hasznos lehet) A következőt tároljuk egy fél-élben: az fél-él cél csúcspontja (vertex), a fél-él testvére (sym), a fél-él lapja (face) és a lapot körbefogó fél-élsorozatban a rákövetkezője (next) A lapokhoz egy tetszőleges alkotó fél-él pointerét jegyezzük fel A csúcspontokhoz egy befutó fél-élt HE sym sym = HE, HE next sym vertex = HE vertex stb. Pl.: Adott lap körbejárása def faceloop (HE ) : loop = HE do : p r i n t HE loop = HE. next while loop!= HE
Ajánlott irodalom Számítógépes Grafika Valasek Gábor valasek@inf.elte.hu Eötvös Loránd Tudományegyetem Informatikai Kar 2012/2013. őszi félév Differenciálgeometria jegyzet: http://numanal.inf. elte.hu/ schipp/jegyzetek/anal_3.pdf Tartalom Görbék Görbék reprezentációja Törött vonal Hermite interpoláció Catmull-Rom spline Kochanek-Bartels spline Bézier görbék B-spline görbék Műveletek görbékkel Felületek Bilineáris felület Bézier felület Spline felületek Műveletek felületekkel Subdivision felületek Motiváció Doo-Sabin Loop Módosított pillangó Catmull-Clark Topológia tárolása Szárnyas-él adatszerkezet Görbék Fél-él adatszerkezet Színterek tárolása Színtérgráf CSG Hétköznapi modellek, intuíció CSG alapján fa a (sík)görbék a sík/tér pontjainak valamilyen szépen viselkedő részhalmazai Matematikai megadásuk lehet explicit: y = f (x) parametrikus: p(t) = [x(t), y(t)], t [a, b] implicit: f (x, y) = 0 Térben hasonló, de az f (x, y, z) = 0 implicit egyenlet ott egy felületet határoz meg! DE két felület metszeteként már implicit megadható a görbe, azaz a tér azon pontjainak halmaza, amelyekre f (x, y, z) = 0 és g(x, y, z) = 0 együtt teljesül
Görbék reprezentációja Parametrikus görbe De hogyan tudunk egy görbét eltárolni, mik azok az információk, amik őt egyértelműen meghatározzák? Például egy szakaszt egyértelműen meghatározza a két végpontja, egy kört a középpontja és sugara stb. Mi a helyzet a nem ilyen szép, matematikai görbékkel, az úgynevezett szabadformájú görbékkel? Ott miket kell tárolni? Egy adott reprezentáció mellett hogyan tudok egyéb dolgokat lekérdezni (sebesség és gyorsulásvektor stb.)? Egy Γ R 3 halmaz egyszerű sima reguláris görbe, ha létezik olyan φ C 1 leképezése az I R intervallumnak R 3 -ba úgy, hogy φ : I Γ bijekció és φ (t) 0, t I. A φ leképezés a Γ görbe egy paraméterezése. Parametrikus görbe Parametrikus görbe Ha a t paramétert az időnek tekintjük, akkor egy p(t) : I R 3 görbe esetén p (t 0 ) a görbe bejárásának p(t 0 ) R 3 pontbeli sebessége (irány + nagyság) p (t 0 ) a görbe bejárásának p(t 0 ) R 3 pontbeli gyorsulása (irány + nagyság) Hogyan jelenítünk meg egy parametrikus görbét? a paramétertartományban több pontban kiértékeljük és ezeket összekötjük szakaszokkal Feladat: rajzold ki az ablak közepére a 100 sugarú kört 10 szakasszal közelítését!
Polinomiális görbék A görbénk álljon szakaszonként lineáris szegmensekből n szakaszból álló összefüggő görbe reprezentációjához n + 1 pontra van szükség Az összetett görbének legyen a paramétertartománya [t 0, t n ] Legyen továbbá adott t i < t i+1, i = 1, 2,.., n 1 paraméterérték Ekkor a t [t i, t i+1 ] paraméterértékhez tartozó pontja a törött vonalnak p(t) = lerp(p i, p i+1, t t i ) = t i+1 t p i + t t i p i+1 t i+1 t i t i+1 t i t i+1 t i Ha C 0 -nál magasabb fokú garantált (!) folytonosságot akarunk, akkor próbálkozhatunk polinomokkal A p 0,..., p n pontokra illeszthető egy n-edfokú polinom A jól ismert hatványbázisban ez p(t) = n i=0 a it i, t R alakú De mi lenne a geometriai értelmezése az a i R 3 együtthatóknak? Mit ábrázolnak? másik bázist keressünk inkább, ahol a reprezentációt képező elemeknek szemléletesebb jelentése van Harmadfokú Hermite interpoláció Harmadfokú Hermite interpoláció Két pont között, [0, 1]-re megfogalmazza keressük a A görbénk tárolásához bizonyos pontokban jegyezzük fel a görbe pozícióját és egy bejárásához tartozó sebesség, gyorsulás stb.... vektorát (azaz legyenek adottak x(t i ), x (t i ), x (t i ),...) pont és derivált adatok, i = 0, 1,...) Keressünk egy olyan bázist, amibe ezeket a fenti adatokat koordinátaként beírva az adott szinten a beírt adatot kapjuk vissza p(t) = H0 0 (t)p 0 + H0 1 (t)m 0 + H1 0 (t)p 1 + H1 1 (t)m p0 alakú parametrikus görbét amelyre p(0) = p 0 p(1) = p 1 p (0) = m 0 p (1) = m 1
Harmadfokú Hermite bázis Harmadfokú Hermite bázis Harmadfokú bázisunk polinomjai legyenek a következők: H 0 0 (t) = 2t3 3t 2 + 1 H 1 0 (t) = t3 2t 2 + t H 0 1 (t) = 2t3 + 3t 2 H 1 1 (t) = t3 t 2 Ha van n + 1 bejövő adatunk, akkor minden pár közé szerkesztve egy-egy görbét az összeillesztésből kapott n harmadfokú szegmensből álló spline C 1 lesz Harmadfokú Hermite bázis Folytonosság Csináljunk programot ami a következő adatokat interpolálja [0, 1]-en: p 0 = ( width 3, height ) 2 p 1 = ( 2width, height ) 3 2 m 0 = (50, 60) m 1 = (10, 90) Legyen az interpolálási intervallum módosítható! Amikor alacsonyabb fokszámú polinom-szegmenseket illesztünk egymáshoz fontos, hogy a csatlakozásokban szépen menjen át az egyik szegmens a másikba a globális paraméter mellett A szépen egy matematikai megfogalmazása: C 0 : a görbében/felületben nincsenek lyukak, nem szakad meg sehol C 1 : a derivált is folytonosan változik C 2 : a görbe/felület második deriváltjai is folytonosan változnak Ezek paraméterfüggők (nem csak a geometriától, hanem az épp adott bejárásától (=paraméterezéstől) is függ)!
Geometriai folytonosság Catmull-Rom spline Nem teljesen szabatos matematikai definíciókat következnek A geometriai folytonosságnál paraméterezéstől független folytonossági megkötéseket teszünk: G 0 : a görbében/felületben nincsenek lyukak, nem szakad meg sehol G 1 : a csatlakozásoknál ha a deriváltak nem is egyeznek meg, de α R úgy, hogy m i = αm i+1 G 2 : a görbe/felület görbülete folytonos a csatlakozásban is Ne legyen közvetlenül adott a derivált, hanem a pontokból számoljuk őket a következőképp: m i = p i+1 p i 1 t i+1 t i 1 Ezután a megadott p i és a fentiek szerint számított m i adatokra páronként illesszünk Hermite-görbéket Kochanek-Bartels spline Kochanek-Bartels spline A Catmull-Rom spline-hoz hasonlóan itt is számított adat lesz a tangens, de most három paraméter is adott hozzá: T : tension, T [ 1, 1] B: bias, B [ 1, 1] C: folytonosság (simaság), C [ 1, 1] A Catmull-Rom spline-t kapjuk, ha T = B = C = 0 A fentiek felhasználásával az i-edik szegmens két végpontjának derivált-értékei legyenek A fentiek felhasználásával az i-edik szegmens két végpontjának derivált-értékei legyenek (1 T )(1 + B)(1 + C) m i = (p i p i 1 ) 2 (1 T )(1 B)(1 C) + (p i+1 p i ) 2 (1 T )(1 + B)(1 C) m i+1 = (p i+1 p i ) 2 (1 T )(1 B)(1 + C) + (p i+2 p i+1 ) 2
Bézier-görbe kitérő- de Casteljau algoritmus Bézier-görbe Használjuk a Bernstein-bázist: B n i (t) := ( n i A b 0,..., b n R 3 kontrollpontok által meghatározott n-edfokú Bézier-görbe ekkor ) t i (1 t) n i b(t) = n Bi n (t)b i, i=0 ahol t [0, 1]. HF: n i=0 Bn i (t) = 1 teljesül, t [0, 1] A görbe nagyjából követi a vezérlőpontok poligonjának az alakját, de nem halad át minden! Ez egy approximáló séma További részletek: Geometriai Modellezés MSc, Analízis (Stone-Weierstrass approximációs tétel) Bézier-görbe Bézier-görbe - bázisfüggvények Egyetlen kontrollpont módosítása az egész görbére hat Bernstein-bázis néhány n-re: B 1 0 (t) = 1 t, B1 1 (t) = t lineáris interpoláció! B0 2(t) = (1 t)2, B1 2(t) = 2t(1 t), B2 2 (t) = t 2 n = 3: HF Lényegében összemossuk a kontrollpontjainkat egymással a fenti függvényekkel súlyozva őket, ezzel megmondva, hogy egy adott t [0, 1] paraméterértéknél melyik kontrollpont mennyire játszik fontos szerepet a görbe alakjának meghatározásában
Interpoláció vagy approximáció? Bézier-görbe első deriváltja Interpoláció: a görbének át kell haladnia a vezérlőpontokon A Bernstein-bázis tulajdonságainak köszönhetően a Bézier görbe deriváltjai egyszerű alakban kifejezhetőek b (t) = n n 1 i=0 b ib n 1 i (t), ahol b i := b i+1 b i A fenti deriváltgörbét hodográf görbének hívjuk Ez t = 0-ban: b (t) = n b 0 = n(b 1 b 0 ) t = 1-ben pedig: b (t) = n b n 1 = n(b n b n 1 ) Bézier-görbe első deriváltja Interpoláció vagy approximáció? Approximáció: a görbének csak közelítenie kell a vezérlőpontokat Könnyen belátható, hogy a k-adik deriváltra a következőt kapjuk: b (k) (t) = n! n k (n k)! i=0 k b i B n k i (t) ahol k b i := k 1 b i+1 k 1 b i, k = 2, 3,...
Sok vezérlőpont esete Sok vezérlőpont esete A vezérlőpontok számával együtt nő a fokszám egy idő után lehet meg kell elégednünk az approximációval, de az sem lesz jó A magas fokszámú polinomok erősen hullámozhatnak Runge-problémája: az f (x) = 1 1+25x 2 függvény (piros) közelítése során ötödfokú (kék) és kilencedfokú (zöld) polinomokkal B-spline görbék B-spline görbék Bizonyos szempontból optimális bázis szakaszonként polinomiális összetett görbékre (legkisebb tartó adott fokszámban stb., ld. numanal) Legyenek p i R 3 vezérlőpontok és t i R csomópontok, i = 0,..., m 1 Ekkor a fenti adatok által meghatározott n-edfokú b(t) : [t n, t m n 1 ] R 3 B-spline görbe b(t) = m n 2 i=0 p i N n i (t) A fenti képletből a B spline bázisfüggvények a következők: { Ni 0 1, t [ti, t (t) = i+1 ], i = 0,.., m 2 0 Ni n (t) = t t j N n 1 t j+n t j (t) + t j+n+1 t N n 1 j t j+n+1 t j+1 (t) j+1 i=0,.., m-n-2, n = 1, 2,...
Subdivision görbék Subdivision görbék Egy ötlet: az eddigiek során rögtön egy polinomot állítottunk elő a kontrollpontjainkból (lényegében: a kontrollpontok által meghatározott kontroll-poligonból) Megjelenítés során viszont úgyis szakaszokkal kell közelíteni! dolgozzunk magán a kontroll-poligonon! A subdivision, vagy rekurzív felosztással definiált sémák a kiinduló ponthalmazunkat (kontrolpontok halmazát) rekurzívan sűrítik, egyre finomabb lineáris közelítést is adva (legtöbbször) A kiinduló ponthalmaz által meghatározott görbének a rekurzív sürítést határgörbéjét ( végtelen sok finomítás utáni pontok halmazát) tekintjük Óriási kifejezőerő (például a Chaikin saroklevágási algoritmus egy másodfokú B-spline görbét ad, de Rahm görbéjének határértéke pedig egy minden pontjában folytonos de sehol sem differenciálható fraktálgörbét (!)) Subdivision görbék - Chaikin saroklevágási algoritmus Subdivision görbék - Chaikin saroklevágási algoritmus Legyen az aktuális vezérlőpont halmazunk {p i R 3 } n i=0 Az iterációs lépés során az új vezérlőpont halmazunk {q i, r i R 3 } n 1 i=0 lesz, ahol q i = 3 4 p i + 1 4 p i+1 r i = 1 4 p i + 3 4 p i+1
Ívhossz Kisérő triéder Legyen t [a, b], ekkor s [a, b]-re az ívhossz s(k) = Az ívhossz szerint k a r (t) dt Adott p(t) : [0, 1] R 3 parametrikus görbe, ekkor t(t) = [p (t)] 0 : tangens b(t) = [p (t) p (t)] 0 : binormális n(t) = b(t) t(t): főnormális Feladat: kisérő triéder kirajzolása! Egyenletes sebességű bejárás Görbület Feladat: Newton-Raphson iterációval segítségével helyezz el 5, egymástól a görbén mérve egyenlő távolságra lévő pontot! Emlékeztető: f (x) = 0 megoldását keressük úgy, hogy kiindulva egy x 0 D f pontból iteratívan minden lépésben x n+1 = x n f (xn) f (x n) becsléssel közeledünk a megoldáshoz Ugyanígy: milyen messze van a kattintás helye a görbétől (mi a legközelebbi pontja) és mi a legközelebbi ponthoz tartozó paraméterérték? Tegyük fel, hogy a görbénk ívhossz szerinti paraméterezéssel adott, azaz p (s) = 1 Ekkor p merőleges p -re ( p 2 = p, p = 1 deriválásából trivi) Ilyenkor t(s) = p (s) és n(s) = [p (s)] 0. Ekkor az egység érintővektor változásának normálisra vett előjeles merőleges vetülete azt mondja meg, hogy mennyire görbül a pálya az adott paraméterértéknél: κ(s) = t (s), n(s) A fenti κ a görbe s paraméterhez tartozó görbülete, illetve ha κ 0, akkor ρ(s) = 1/κ(s) a görbületi sugara
Görbület Görbület Amennyiben nem ívhossz szerint van paraméterezve a görbénk, a következő képlettel számítható a görbület: κ(t) = p (t) p (t) p(t) 3 Feladat: színezzük a görbét a görbülete alapján! Feladat: miközben bejárjuk a görbét, minden pontjához rajzoljuk be a görbületi körét! (Ennek középpontja: p(t) + ρ(t)n(t) Biz.: ld. diffgeo Síkban: előjeles görbület is értelmezhető, az a b = a x b y a y b x értelmezéssel, abszolút értéket elhagyva a számlálóban. Bilineáris felület Bilineáris felület Adott négy kontrollpont, p 1, p 2, p 3, p 4 R 3 Három lineáris interpolációval egy egyszerű felületület kapunk: ahol s, t [0, 1]. b(s, t) = (1 t)((1 s)p 1 + sp 3 ) + t((1 s)p 2 + sp 4 ) Lényegében: két szakaszt írtunk be a t szerinti lineáris interpoláció képletébe
Bézier felület A b ij R 3, i = 0,.., n, j = 0,.., m kontrollpoligon által meghatározott n m-edfokú Bézier-felület b(u, v) = alakú, ahol u, v [0, 1]. m j=0 i=0 n Bi n (u)bj m (v)b ij Bézier felület - deriváltak A görbéknél látottakat felhasználva az u paraméterirányban: m n u b(u, v) = u ( Bi n (u)b ij )Bj m (v) = n j=0 i=0 m n 1 1,0 b ij B n 1 i (u)bj m (v) j=0 i=0 Ahol 1,0 b i,j = b i+1,j b i,j Bézier felület - deriváltak Bézier felület - deriváltak Ugyanez v szerint m 1 v b(u, v) = m j=0 n i=0 0,1 b ij Bi n (u)b m 1 j (v) Egy adott felületi pontban a parciális deriváltak által kifeszített síkot érintősíknak nevezzük Ennek normálisa - és egyúttal a felületünk normálisa az adott paraméterértékekhez tartozó pontban - pedig [ u p v p] 0 Ahol 0,1 b i,j = b i,j+1 b i,j
Bézier felület - deriváltak Bézier háromszög A görbéknél látottakat felhasználva a deriváltak általánosan a következőképpen néznek ki: A paramétertartomány legyen háromszög alakú! m!n! u r,v sb(u, v) = ahol (n r)!(m s)! m s j=0 n r i=0 r,s b ij B n r i (u)b m s j (v) i,j b i,j = i 1,j b i+1,j i 1,j b i,j = i,j 1 b i,j+1 i,j 1 b i,j Bézier háromszög Spline felület Alacsonyabb fokszámú felületdarabokat, felületfoltokat (patch-cseket) illesztünk egymáshoz Csatlakozások folytonosságára figyelni kell Több erről: Geometriai Modellezés, Felület és Testmodellezés - MSc.
Metszés sugárral Például egérrel történő kijelölés eldöntésekor lehet szükség arra, hogy megkeressük a p(t) = p 0 + tv sugarunk metszetét a b(u, v) felületünkkel Tehát a következő egyenletrendszert kell megoldani: p(t) = b(u, v), ahol az ismeretlenek t, u, v (figyeljünk a megkötéseikre!) Többváltozós Newton és egyebek... SIGGRAPH Subdivision tutorial a téma iránt mélyebben érdeklődőknek: http://www.mrl.nyu.edu/ publications/subdiv-course2000/ Subdivision felületek - Doo-Sabin Subdivision felületek - Catmull-Clark 2001: Oscar Catmull-nak for significant advancements to the field of motion picture rendering as exemplified in Pixar s RenderMan
Fogalmak - séma mesh-típusa Mesh-típus A legtöbb subdivision séma valamilyen reguláris felosztási/finomítási sémán alapszik Amikor egy séma mesh-ének típusáról beszélünk erre az őssémára gondolunk A síkban regulárisan elhelyezett pontokat szabályos háromszögekkel, négyzetekkel, vagy szabályos hatszögekkel fedhetjük le Ennek megfelelően nevezünk egy sémát háromszög-, négyszög- vagy hatszög-alapúnak (gyakorlatban utóbbi ritka) Vigyázzunk: szép (teljes oldalakban illeszkedő), 6-reguláris háromszög vagy szép, 4-reguláris négyszöghálóval nem lehet bármit lefedni degenerált esetek nélkül! A fenti reguláris topológiákkal a végtelen síklap, vagy a végtelen hengerpalást, vagy pedig a tórusz topológiájának megfelelő felületek írhatóak lef Mesh-típus - Möbius Mesh-típus - Klein-kancsó
Fogalmak - face-split (primál) Fogalmak - vertex-split (duál) A mesh-típusának megfelelő lapok mindegyikét négyfelé osztjuk Az előző lépés mesh-ének csúcspontjait megőrizzük (de módosíthatjuk a pozíciójukat - ha változtatás nélkül vesszük át a pontokat, akkor interpoláló sémáról beszélünk) Új csúcspontokat szúrunk be minden élre (kettéosztva ezzel őket) Négyszög alapú sémáknál a lapból is származtatunk egy új csúcspontot Ilyenkor minden csúcspontból keletkezik egy új csúcs az összes, eredeti csúcsra illeszkedő lap mentén A régi lapból új lap származik közvetlenül Az élek mentén új lapok születnek (az élek végpontjaiból az él által szétválasztott két lapra születő új csúcspontokat összekötve) A régi csúcspontok helyett egy új lap születik, a csúcsból született új csúcspontokkal Fogalmak - face- és vertex-split Fogalmak - face- és vertex-split Reguláris négyszöghálón mindkét esetben 4-reguláris lesz az új háló is tartja a topológiát Figyeljünk: reguláris háromszöghálóknál vertex-split után hatszögeket kapunk! Reguláris négyszöghálón mindkét esetben 4-reguláris lesz az új háló is tartja a topológiát Figyeljünk: reguláris háromszöghálóknál vertex-split után hatszögeket kapunk!
Face-split 4-reguláris mesh-en Face-split 6-reguláris mesh-en Vertex-split 4-reguláris mesh-en Fogalmak - páros csúcsok (even vertices) Laposztó (face-split) sémáknál a durvább felbontású mesh csúcspontjai megfelelnek a finomabb mesh csúcspontjainak Ezek a páros csúcsok
Fogalmak - páratlan csúcsok (odd vertices) Doo-Sabin Az újonnan létrejött csúcsok, amelyek nem feleltethetőek meg a finomítás előtti szint egyetlen csúcspontjának sem Eredeti cikk: http://trac2.assembla.com/ DooSabinSurfaces/export/12/trunk/docs/Doo% 201978%20Subdivision%20algorithm.pdf Rövid leírás: http://www.cs.unc.edu/ dm/unc/ COMP258/LECTURES/Doo-Sabin.pdf Doo-Sabin Doo-Sabin
Doo-Sabin - új pontok számítása Doo-Sabin - új pontok számítása Doo-Sabin - lapokból származó lapok Doo-Sabin - Csúcsokból származó lapok
Doo-Sabin - Élekből származó lapok Loop séma Módosított pillangó Catmull-Clark
Szomszédsági viszonyok Szárnyas-él adatszerkezet Néha kellenek a szomszédok, pl. felület-felosztásoknál, degenerált primitívek kiszűrésekor, egyes felhasználói inputok kezelésekor stb. Ismertek a csúcsok számítható mi, minek a szomszédja! Egy csúcsban tetszőleges számú poligon találkozhat dinamikus adatszerkezet kéne Jobb megoldás: Szárnyas-él (winged-edge) adatszerkezet! Az alakzatokat határukkal leíró (B-rep) (boundary representation) reprezentáció egyik gyakran használt topológiatároló adatszerkezete manifold poliéderek esetén Tárolás során csúcsokat, éleket és lapokat különböztet meg Az élek szempontjából tároljuk a felületet Minden élhez fix számú adat tartozik Segítségével pl. gyorsan körbe lehet járni egy poligon éleit, közben megkapva minden szomszédot Szárnyas-él adatszerkezet Egyetlen él adatai Minden lapot egy élsorozat határol - minden laphoz tároljunk egy, az élsorozatához tartozó tetszőleges élre mutató pointert A csúcspontok élekhez illeszkednek (vagy belőle indul ki, vagy ő a célja) - tároljuk valamelyiket a csúcsokhoz! Egy él két csúcsot köt össze - tároljuk ezeket az élben Egy él legfeljebb két laphoz tartozhat - az egyik a baloldali, a másik a jobboldali lap lesz, ezekre mutató pointereket (vagy indexeket) tárolunk A fenti két lapon egyúttal egy-egy élsorozat (az adott lapot alkotó élsorozat) része is az adott él - mindkét élsorozatban tároljuk a rákövetkezőjét és megelőzőjét az adott élnek az adott lap bejárási irányának megfelelően (!)
Egyetlen él adatai Egyéb táblázatok 2*él csúcs lap balra jobbra start vég bal jobb előző köv. előző köv. a B A 0 1 c b d e Csúcsok táblája csúcs ID csúcsból induló él Lapok táblája lap ID lap egy éle Példa: tetraéder Pl.: Egy lap összes szomszéd lapjának felsorolása def allneighbours ( face, edges, v e r t i c e s, faces ) : startedge = faces [ face ] edge = startedge i f edges [ startedge ]. f a c e L e f t == face : while edges [ edge ]. succleft!= startedge : p r i n t edges [ edge ]. faceright edge = edges [ edge ]. succleft else : while edges [ edge ]. succright!= startedge : p r i n t edges [ edge ]. f a c e L e f t edge = edges [ edge ]. succright Shirley, Fundamentals of Computer Graphics
Pl.: Egy lap összes szomszéd lapjának felsorolása Pl.: Egy adott csúcsot tartalmazó összes lap felsorolása Azaz: induljunk el az adott lap reprezentáns éléből (amit tárolunk a laphoz) Ha ennek az élnek a baloldali lapja az adott lap: iteráljunk végig a baloldali éllistán és írjuk ki a jobboldali lapokat (a baloldali a lekérdezést kiváltó lap) Különben a jobboldali lap az adott lap, iteráljunk végig a jobboldali lap éllistáján Az iteráció érjen véget, amint visszaérünk az adott lap reprezentáns élébe def allfaces ( vertex, edges, v e r t i c e s, faces ) : startedge = v e r t i c e s [ v ertex ] edge = startedge done = False while not done : i f edges [ edge ]. v e r t S t a r t == vertex : p r i n t edges [ edge ]. f a c e L e f t edge = edges [ edge ]. predleft else : p r i n t edges [ edge ]. faceright edge = edges [ edge ]. predright Fél-él adatszerkezet Half-edge A winged-edge élét vegyük szét két fél-élre! lényegében az élek lapra vett vetületével dolgozunk! A fél-élhez csak egy lap tartozhat + meg kell jegyeznünk a testvér fél-élét (az adott él másik oldali lapra vett vetületét) A reprezentáció központi eleme a fél-él
Half-edge Fél-él adatszerkezet Szigorú értelemben véve egy fél-élhez pontosan egy csúcs, él és lap tartozik (de gyakorlatban ennél többet tárolni hasznos lehet) A következőt tároljuk egy fél-élben: az fél-él cél csúcspontja (vertex), a fél-él testvére (sym), a fél-él lapja (face) és a lapot körbefogó fél-élsorozatban a rákövetkezője (next) A lapokhoz egy tetszőleges alkotó fél-él pointerét jegyezzük fel A csúcspontokhoz egy befutó fél-élt HE sym sym = HE, HE next sym vertex = HE vertex stb. Pl.: Adott lap körbejárása Színtérgráf motiváció 1. def faceloop (HE ) : loop = HE do : p r i n t HE loop = HE. next while loop!= HE Ahol én vagyok ott van a karom is. (Jobb esetben...) Ha mozgatom a karom, elmozdulnak (világtérben) az ujjaim is Tudom úgy mozgatni az ujjaimat, hogy közben sem a karom, sem én nem mozdulok el
Színtérgráf motiváció 2. Ha mozog egy bicikli, mozognak vele a kerekei meg a kormánya is A kormányt lehet külön forgatni, és forgatja az első kereket A két kerék tud forogni a tengelye körül, anélkül hogy a biciklit forgatni kéne Színtérgráf Irányított, körmentes gráf (DAG) A színtér ( világ) összes elemét tartalmazza Az egyes elemek alá-/fölérendeltségi viszonyaik szerint kapcsolódnak egymáshoz Szülő vagy ős: ahonnan kiindul az él Gyerek: ahova mutat az él A szülő tulajdonságai öröklődnek a gyerekre, amiket a gyerek pontosíthat (pl. transzformációk), vagy felülírhat (pl. színek)
Csomópontok A gráf egy csomópontja (csúcsa, node-ja) lehet geometria, transzformáció, anyagjellemzők, fényforrás, kamera. Csomópontok tulajdonságai Csomópontok tulajdonságai Geometria A rendszer által támogatott tetszőleges modell leírás. Pl. Mesh. A gráfban levélként szerepel. Transzformáció Gyak. 4 4-es transzformációs mátrix. Az új transzformációs csomópont nem felülírja a megelőzőket, hanem azokkal együtt hat. Anyagjellemzők Színek, optikai tulajdonságok, textúrák stb. Nyitott kérdés: hogyan ábrázoljuk, ha egy modellünk több textúrát is használ? Fényforrás Kamera Poziciója, iránya, típusa, színe stb. Levele a gráfnak. Pozíciója, nézeti iránya, látószöge stb. Levele a gráfnak.
Színtérgráf a gyakorlatban Színtérgráf összefoglaló Minden komolyabb 3D alakalmazás használ valamilyen szintérgráfot. Példák: Maya, Java3D OpenSceneGraph OGRE Valamilyen színtérgráfot érdemes implementálni. Szétválasztja az elhelyezést, a formát és a megjelenést. Lehetővé teszi az egymáshoz képesti relatív elhelyezést. DE, szem előtt kell tartani, hogy milyen szintig érdemes elbonyolítani. CSG modell Constructive solid geometry: konstruktív tömör test geometria A modellünket = primitívek + műveletek Különbség Metszet Unió Primitívek: téglatestek, hasábok, hengerek, gúlák, kúpok, gömbök. Műveletek: boolean műveletek, unió, különbség, metszet. Captain Sprite, en.wikipedia Captain Sprite, en.wikipedia Captain Sprite, en.wikipedia
CSG fa CSG fa A műveletek eredményein újabb művelet hajtható vége. object = primitive object = object operation object Bináris fával jól leírható! Belső csúcsok: műveletek Levelek: primitívek Gyökér: végleges objektum Zottie, wikipedia CSG modellek megjelenítése CSG modellek metszése Inkrementális képszintézis: tesszelálni kell. Sugárkövetés: speciális sugár/model metszéspont számítás CSG-fa bejárása. Levél: triv., metszéspontok: p + t 1 v és p + t 2 v A sugár (p + t 1 v, p + t 2 v) szakaszon a primitív belsejében halad. Összes levélből: t 1... t n, elég ezeket vizsgálnunk. Szakasz-listákat fogunk nyílvántartani.
CSG modellek metszése Belső csúcsok: a gyerekektől származó szakasz-listákra is végrehajtjuk a műveletet Összeérő szakaszokat egyesítjük, különben hozzávesszük a listához. Kiszámítjuk a szakaszok metszeteit. \ Kivonjunk a szakaszokat egymásból. Gyökérben: a legkisebb pozitív t értékű pont lesz a szemhez legközelebbi metszés. Ha a metszések száma páros: kívül vagyunk az objektumon, ha páratlan, akkor a belsejében.
Tartalom Számítógépes Grafika Valasek Gábor valasek@inf.elte.hu Eötvös Loránd Tudományegyetem Informatikai Kar 2011/2012. őszi félév Animáció Áttekintés Animáció szintézis Kamera animáció Pozíció és orientáció Képlet animáció Kulcskocka animáció Pálya animáció Hierachikus rendszerek Előrehaladó kinematika Inverz kinematika Animáció Hagyományos animációs módszerek Színtereink ritkán statikusak, különösen interaktív alkalmazások esetén Animáció: képek egymás utáni sorozata Ha elég gyorsan követik egymást, akkor folytonos mozgás érzete alakul ki (ld. CFF korábban) Minden egyes képkockát külön megrajzolni Mindent tudunk pontosan irányítani Rendkívül munkaigényes (és drága) Cel animation Rétegek (layerek) használata, újrahasználható fóliákon a színtér egyes részei Kulcskereteket (keyframe-eket) rajzolják a fő rajzolók, az átmenetekért (inbetween) a fiatalabbak felelősek (a megadott utasításoknak megfelelően) De: ha minden mozog a háttérben ez is elképesztően munkaigényes (és drága: pl. The Wings of Honneamise)...
Hagyományos animációs módszerek Számítógéppel segített animáció További érdekességek: Principles of Traditional Animation Applied to 3D Computer, SIGGRAPH 87, pp. 35-44. Kulcskeret (keyframe) alapú animáció A köztes animációs fázisok elkészítésének automatizálása: csak a kulcskeret képkockákat kell elképszíteni és megadni a kívánt átmenetek paramétereit Rugalmas, kevésbé munkaigényes de még mindig komoly képzettséget igényel (újakat is) Procedurális animáció A mozgás algoritmikus leírása Például pattogó labda magassága az idő (t) függvényében: m(t) = sin(ωt + θ 0 ) e kt Számítógéppel segített animáció Mit animálhatunk? Fizikai alapú animáció A színterünk elemeit fizikai jellemzőkkel látjuk el (tömeg, erők, rugalmasság stb.) A fizikai törvényei alapján felírt egyenletek megoldásaként előáll az animáció Realisztikus (ha jól csináljuk), de nehéz irányítani Motion capture Műszerekkel rögzíteni amint valaki/valami elvégzi a kívánt mozgásokat majd ezt egy digitális modellre átültetni Lényegében bármit, ami befolyásolja a megjelenő képet a színtérről (modellek pozícója, orientációja, színe, reprezentációhoz kötődő tulajdonságai, BRDF stb.) Elsősorban a modell és kamera transzformációkkal foglalkozunk most csak A feladatunk ezeknek a paramétereknek időtől függővé tétele
Animáció szintézis Általános animációs program váza Legyen minden o objetumra a modellezési (világ) transzformáció M o R 4 4 Legyen a nézeti (kamera) transzformáció: V R 4 4 Megjegyzés: ha V a View mátrix, akkor csak a kamera pozicióját, orientációját tartalmazza; ha V a View és a Projection együtt, akkor tudjuk vele a látószöget is állítani Legyen mindkettő az idő függvénye! M o R R 4 4 V R R 4 4 while keep running : t = g e t t i m e ( ) f o r o i n o b j e c t s : M o = M o (t) V = V (t) render scene ( ) Animáció szintézis Valósidejű animációs program váza Valósidejű/interaktív: rögtön meg is jelenítjük a képkockákat a számításnak elég gyorsnak kell lennie a folytonosság látszatához a felhasználói eseményekre reagálni kell olyan részletgazdag lehet a színtér, amit még így meg lehet jeleníteni inkrementális képszintézist használunk def update ( ) : # FrameUpdate ( ) / UpdateScene ( ) t = g e t t i m e ( ) f o r o i n o b j e c t s : M o = M o (t) V = V (t) def render ( ) : # Render ( ) / DrawScene ( ) f o r o i n o b j e c t s : r e n d e r o b j e c t ( o )
Animáció szintézis Offline rendering Nem valós idejű/offline: Nem számít, hogy mennyi ideig tart kiszámítani egy képkockát Elkülönöl a szintézis és a visszajátszás Először elmentjük a képkockákat Aztán majd videóként lehet visszanézni a felhasználó nem tud belenyúlni az animációba olyan részletes színteret, és olyan bonyolult algoritmust használunk, amit ki tudunk várni Azért a költségvetés keretet szab: Final Fantasy: Spirits Within (2001), egy 200 fős csapat 4 éves munkája volt (kb. 120 emberév összesítve), aminek elkészítésére 960 munkaállomást használtak. A film 141964 frame-ből állt végül (15TB), egy frame átlagosan 90 percig renderelőtött! t = 1/FPS f o r ( t = t s t a r t ; t <t end ; t += t ) : f o r o i n o b j e c t s : M o = M o (t) V = V (t) r e n d e r s c e n e t o d i s k ( ) s t a r t t i m e = g e t t i m e ( ) f o r ( t = t s t a r t ; t <t end ; t += t ) : draw frame ( t ) while ( t t s t a r t + t > g e t t i m e () s t a r t t i m e ) : wait ( ) Valósidejű animáció rosszul Valósidejű animáció jól Hogyan lehet a legkönnyebben elrontani az animáció számítást? Azzal, ha nem vesszük figyelembe, hogy mennyi idő telt el két képkocka között. Pl.: A középpontja körül akarjuk forgatni az objektumot állandó szögsebességgel. model = rotation(phi, 0,1,0); phi += phi step; Az objektum olyan gyorsan fog forogni, amilyen gyakorisággal ez a kód részlet meghívódik. Gyorsabb gépen többször, lassabb gépen kevesebbszer - és semmi sem garantálja, hogy ugyanazon a gépen két hívás között egyáltalán ugyanannyi idő telne el! Hogyal lehet a legkönnyebben ezt megelőzni? Sose azt tároljuk, hogy mennyivel kell változtatni, hanem, hogy mi a változás sebessége. Minden számítás előtt kérjük le, hogy mennyi idő telt el az előző képkocka óta, és ezzel szorozzuk a sebességet. Pl.: phi += phi step; helyett phi += get time since last frame() * phi speed; Gyorsabb gépen kevesebb, lassabb gépen több idő telik el két képkocka között gyors gépen kisebbeket lépünk, lassabban nagyobbakat - és a lötyögés sem számít (hívások között eltelt idő változása)
Kamera animáció Pozíció és orientáció A kamera tulajdonságai: szempozició (eye), egy pont amire néz (center), felfelé irányt megadó vektor (up), a képernyő/ablak oldal aránya (aspect), nyílásszög (fovy). Ezek mind külön-külön változtathatók az animáció létrehozásához. Például a szempozíciót a múlt órán látott parametrikus görbékkel is megadhatjuk, ahol a paraméter az idő lesz! Pl. a-ból b-be 5 másodperc alatt a p(t) = (1 t 5 )a + t 5 b, ha t másodpercekben adott és t = 0-ban indulunk a-ból Pozícó: Hol van az objektum? Orientáció: Hogy áll, merrefele néz az objektum? Elsősorban ezt a kettőt szeretnénk változtatni. M o (t) megadja mindkettőt. Normális esetben A 11 A 12 A 13 p x M o (t) = A 21 A 22 A 23 p y A 31 A 32 A 33 p z, 0 0 0 1 p = (p x, p y, p z ) a pozíció. Az A mátrix tartalmazza az orientációt. Orientációs paraméterek Yaw, pitch, roll Tegyük p-t és A-t is időfüggővé! p tagjait leírhatjuk külün-külön függvénnyel. Pl.: Valami esik, elég p y -t változtatni. A tagjai összefüggenek, és csak az orentáció érdekel belőle minket (nem érdekel: méretezés, nyírás). Az orientáció megadható három tengely menti forgatással három független függvénnyel. Egy objektum függőleges- (yaw), kereszt- (pitch) és hossztengelye (roll) menti elfordulásait egyszerre adjuk meg. Már találkoztunk vele, 3 3-as mátrixszal megadható, három forgatás szorzata. Három tengely menti elfordulás szögével megadható megadja az orientációt is. Tetszőleges orientáció megadható vele, de animációnál vigyázzunk, mert...
How about sending me a fourth gimbal for Christmas? - Mike Collins, az Apollo 11 pilótája Gimbal lock Képlet animáció Kulcskocka (key frame) animáció Egy adott tulajdonság változását egy megfelelő függvénnyel írjuk le. Pl: Óra mutatói Nagymutató: yaw(t) = t/10 Kismutató: yaw(t) = t/120 Ha t-t mp-ben adjuk meg, a forgatásokat pedig fokban. Pl: Pattogó labda py (t) = sin(ωt + θ 0 ) e kt Egy bonyolult mozgást nehézkes lenne képlettel megadni. Inkább adjuk csak bizonyos időközönként, hogy akkor mit szeretnénk látni. Ezek a kulcskockák. Egy tulajdonságot két kulcskocka között interpolációval számolunk ki.
Kulcskocka (key frame) animáció Lineáris interpoláció (emlékeztető) Az interpolációval az objektum egyes paramétereire folytonos görbét illesztünk. Az animáció lejátszása/elmentése során a program minden képkockában a hozzá tartozó t értékkel kiértékeli az objektum paraméter-függvényeit. Ezekből számítja a transzformációs mátrixokat. A mátrixok felhasználásval előállítja a képet. Legyen a két kulcskockánk időpontja t 0 és t 1. Legyen az interpolálandó tulajdonság g. Lineáris interpolációval t [t 0, t 1 ]-re kapjuk ( g(t) = 1 t t ) 0 g(t 0 ) + t t 0 g(t 1 ) t 1 t 0 t 1 t 0 Lineáris és gömbi lineáris interpoláció Interpoláció két kulcskocka között K: Mi még a baj a lineáris interpolációval? V: Ritkán néz ki természetesen. Animáció során a sebesség konstans, előtte, utána nulla. Elgurított labda: folyamatosan lassul. Zuhanó zongora: folyamatosan gyorsul. Rakéta a Földről a Marsra: gyorul, halad, lassít. Ilyen interpolációra használhatunk: Gyök függvényt. Másodfokú függvényt.... Gyakorlatban: Bézier görbe
Polinom interpoláció Spline interpoláció n kulcspontra fel tudunk írni n 1-ed fokú polinomot. Interpolációs polinom: minden kulcskockában az előírt értéket veszi fel. Együtthatók számíthatók Lagrange interpolációval is akár (de: nagy fokszám - nagy kilengések adatpontok között itt is!). A lineáris interpoláció a Lagrange intelpoláció speciális esete n = 2-re. A polinom interpolációval kapott fv. magas fokszám esetén a szomszédos pontok között hullámzik, így elrontja az animációt. Spline interpoláció: használjunk több, egymáshoz kapcsolódó, alacsony fokszámú polinomot az interpolációhoz! Pálya animáció Orientáció megadása Egy objektum mozgását megadhatjuk a bejárandó pálya megadásával is. A pályát egy 3D görbével adjuk meg. A model ezen a görbén halad végig. Hogyan adjuk meg az objetumunk orentációját? Egy előre, és egy felfele irány egyértelműen meghatározza ezt. Megjegyzés: v.ö. kamera esetén center-eye ill. up vektorok Ha a pályagörbe differenciálható, akkor az megadja a sebességvektort minden időpillanatban. A sebességvektor mindig előre fele mutat.
Orientáció megadása Hierachikus rendszerek A felfele irány megadására két lehetőségünk is van. Ha van egy természetes felfele, akkor használjuk azt. (Mindennél, ami nem dől be a kanyarban.) Ha ez az irány is változik, akkor ez megegyezik a gyorsulás irányával, azaz a pályagörbe második deriváltjának irányával. Színtér gráfoknál már találkoztunk ilyenekkel. Egy gyerek objektum mozgását a szülőhöz viszonyítva adjuk meg. Gyerekeknek lehetnek újabb gyerekei stb. Hierachikus rendszert fát kapunk. Példa: Emberi test Kényszerek (constraints) Nem minden mozgást szeretnénk megengedni a szülőhöz képest. Ezeket a megszorításokat írhatjuk le kényszerekkel. Korlátozhatjuk a szabadságfokokat: pl. könyök csak egy tengely mentén tud forogni, de a csukló kettő Vagy a tartományokat: kevesen bírják, ha a fejük 90 -nél többet fordul.