Marching Cubes med deferred rendering

55 Pages·2013·3.11 MB·Swedish

Kandidatarbete i Medieteknik, 30 hp
Vårtermin 2013
Marching Cubes med deferred rendering
En studie i implementeringen av Marching Cubes terräng i en
deferred rendering pipeline
Carl Engström
Felix Nawrin Oxing
Handledare: Peter Giger & Jonas Svegland
Examinator: Lena Trojer
Blekinge Tekniska Högskola, Sektionen för planering och
mediedesign
Sida 1
Abstrakt – Svenska
Spel idag kräver en enorm mängd arbetstimmar för att skapas, därför behövs alltid sätt att spara
tid och automatisera processer. Algoritmer för polygoniseringen av skalärfält, som Marching
Cubes, har under de senaste åren blivit ett allt vanligare tillvägagångssätt för att automatiskt
generera terräng.
Scenkomplexiteten och kraven för visuell kvalitet i dagens spel ökar ständigt. Därmed kommer
också kravet för prestandaeffektiva renderingsmetoder. Deferred rendering är en
renderingsmetod som kan hantera scener med stora mängder ljuskällor och hög scenkomplexitet
samtidigt.
För att undersöka integreringen mellan procedurellt skapad terräng och en deferred rendering
pipeline, skapades en applikation i DirectX 11 för att undersöka implementeringen och
potentiella optimeringar av denna integration.
Nyckelord: Marching Cubes, Deferred rendering, C++, DirectX 11, procedurell terräng
generering, ljussättning, material.
Sida 2
Abstract – English
Video games today demand an enormous amount of work hours to produce, hence there is
always a demand for automatizing processes. Algorithms for polygonizing scalar fields, such as
Marching Cubes, have during the last years become an increasingly common way to
automatically generate terrain.
Scene complexity and the demand for visual quality in today’s games is constantly increasing.
Hence there is a need for performance effective rendering techniques. Deferred rendering is a
rendering technique that can handle scenes with large amounts of lights and high scene
complexity simultaneously.
To investigate the integration between procedurally generated terrain and a deferred rendering
pipeline, a DirectX 11 application was made to investigate the implementation and potential
optimizations of this integration.
Keywords: Marching Cubes, Deferred rendering, C++, DirectX 11, procedural terrain
generation, lighting, materials.
Sida 3
Innehållsförteckning
Abstrakt - Svenska........................................................................................................................ 1
Svenska nyckelord.......................................................................................................................... 1
Abstract – English......................................................................................................................... 2
English keywords............................................................................................................................ 2
1. Inledning ..................................................................................................................................... 5
2. Problemområde ........................................................................................................................... 6
2.1 Frågeställning ............................................................................................................................ 6
2.2 Syfte .......................................................................................................................................... 6
2.3 Bakgrund ................................................................................................................................... 6
2.3.1 Procedurell content generering .…......................................................................................... 6
2.3.2 Marching Cubes ..................................................................................................................... 7
2.3.3 Material .................................................................................................................................. 7
2.4 Tidigare forskning ..................................................................................................................... 8
2.4.1 Deferred rendering ................................................................................................................. 8
2.4.2 Texturering av modeller ....................................................................................................... 12
2.4.3 Perlin och simplex noise ...................................................................................................... 12
2.4.4 Marching Cubes och tetrahedrons ........................................................................................ 15
3. Tillvägagångssätt ....................................................................................................................... 18
3.1 Rendering ................................................................................................................................ 18
3.2 Genereringen av miljön ........................................................................................................... 22
3.3 Placering av vegetation ........................................................................................................... 28
4. Resultat och diskussion........................................................................................................... 30
4.1 Texture arrays .......................................................................................................................... 31
4.2 Vegetationssystem ................................................................................................................... 32
Sida 4
4.3 Dag och natt cykel ................................................................................................................... 33
4.4 Skuggor ................................................................................................................................... 33
4.4.1 Framtida ändringar ............................................................................................................... 37
4.5 Marching Cubes ...................................................................................................................... 38
4.6 Simplex ................................................................................................................................... 38
5. Slutsats..................................................................................................................................... 41
6 . Ordlista ...................................................................................................................................... 42
7 . Källförteckning ......................................................................................................................... 49
7 .1 Referenser ............................................................................................................................... 49
7 .2 Bildreferenser .......................................................................................................................... 53
Sida 5
1. Inledning
Först och främst vill vi påpeka att engelsk och svensk terminologi kommer att blandas
generöst i denna uppsats. Om där finns något ord som ni inte förstår, hänvisar vi er till vår
ordlista.
Av egen erfarenhet har vi uppmärksammat att det kan finnas en brist på arbetskraft med rätt
kompetens för att skapa högkvalitativt grafiskt innehåll i mindre spelprojekt. Detta tvingar en att
göra uppoffringar i kvaliteten eller innehållet. En lösning till det här är att generera modeller,
texturer och terräng med hjälp av procedurella genereringsalgoritmer istället.
Interaktionen mellan procedurellt genererad terräng och en deferred rendering pipeline kommer
att undersökas, för att försöka utröna om det går att ta nytta av fördelarna som kommer med
deferred rendering, samt identifiera och hantera begränsningar med denna metod.
Målet är att skapa ett flexibelt system för terräng och världs generering i allmänt, som kräver
minimalt med underhåll och inmatning från utvecklaren, fast med möjligheten att fortfarande
kunna ändra och styra genereringsprocessen, om det krävs.
Det önskade resultatet av det här, är att det ska möjliggöra för utvecklare att enkelt sätta upp
detta system för att snabbt och dynamiskt kunna generera en värld ‒ i realtid eller i förväg, och
sedan kunna koncentrera sig på andra element av spelet istället. En annan möjlighet är att låta
programmet skapa en grundläggande värld, och sedan låta grafiker och level designers arbeta
vidare på den och finjustera för att bättre passa gameplay eller story.
Man avlastar därmed en del av arbetet för designers och grafiker, då de inte behöver spendera sin
tid med att manuellt placera ut alla statiska objekt av mindre vikt, som träd, stenar och buskar i
terrängen. Detta innebär att det går att spara in tid på utvecklingen av spelet, eller att utvecklarna
istället kan spendera den insparade tiden på att förbättra kvaliteten på andra delar av spelet.
Sida 6
2. Problemområde
Som nämndes kort under inledningen, är målet med det här projektet att kunna skapa en flexibel,
dynamisk världsgenerator tillsammans med en grafikmotor som kan driva denna värld i
interaktiva mängder av bilder per sekund, med högsta visuella kvaliteten möjlig.
2.1 Frågeställning
Hur kan man dynamiskt skapa virtuella miljöer med Marching Cubes och gestalta dessa med en
deferred rendering motor?
2.2 Syfte
Syftet med kandidatarbetet är att skapa bredare förståelse för hur man skapar en virtuell miljö
med hjälp av proceduella genererings algoritmer för att minska behovet av grafik och
mappingkompetens, och hur det effektivt går att ta nytta av en deferred rendering pipeline för att
skapa omväxlande miljöer i realtid.
2.3 Bakgrund
Användningen av algoritmer för att extrahera och proceduellt skapa digitala visuella
representationer av objekt från osorterad data har funnits länge (Lorensen, Cline. 1987; Amenta,
Bern, Kamvysselisy. 1998). De senaste åren har det speciellt ökat i popularitet och tillgänglighet,
genom framsteg i hårdvaruprestanda och shaders som hanterar denna formen av beräkningar väl,
som compute shaders och geometry shaders.
2.3.1 Procedurell content generering
Detta är ett samlingsnamn för processer som använder förgenererad data från till exempel en
tomografisk scan eller slumptalgenererings algoritmer tillsammans med algoritmer som sorterar
eller strukturerar den mottagna datan. Den strukturerade datan kan sedan användas för att
programmatiskt framställa en form av visuell representation, som en textur eller en mesh, som
sedan kan renderas på skärmen i ett format som lättare kan tolkas av människor.
Sida 7
En fördel med algoritmiskt skapat innehåll, specifikt inom spel, är att det går att skapa i realtid,
vilket möjliggör näst intill oändligt stora världar, då det går att skapa ny terräng vid behov.
Från en spel synvinkel kan detta innebära mer omspelningsvärde. Om rätt genererings algoritmer
används och världen struktureras korrekt, är det även möjligt att implementera miljö som är
förstörbar i realtid. Detta är något som brukar vara uppskattat i spel, då det kan öppna upp för
nya och intressanta aspekter och spelmekaniker.
Ett exempel på ett spel som har implementerat proceduell content generering är spelsuccén
Minecraft (Mojang AB. 2010-2013), där spelare både kan bygga och förstöra stora miljöer i
realtid, vilket ökar omspelningsvärdet. Dock värt att peka ut är att Minecraft inte har procedurellt
skapade modeller eller texturer, utan att det endast är spelvärldens miljöer som är det.
2.3.2 Marching Cubes
Detta är en algoritm som tolkar data i form av ett skalärfält och skapar en mesh för att
representerar datan i fältet. Algoritmen togs fram år 1984 av Lorensen och Cline för att
åskådliggöra data inhämtad från CT och MRI utrustning. Tidigare hade representationerna gett
en otydlig yta och det efterfrågades ett sätt att lösa problemet. Algoritmen publicerades på
SIGGRAPH konferensen 1987 (Lorensen, Cline. 1987) och patenterades samma år. Patentet gick
ut år 2005, och har sedan dess använts flitigt inom flera branscher. Fler exempel ges nedan, i
stycket Tidigare Forskning.
2.3.3 Material
Material är en vanlig teknik inom spelbranschen för att prestandamässigt billigt och flexibelt
lägga till mer detaljrikedom på modeller. Tekniken använder någon form av data; ofta texturer,
för att definiera ytdata på modeller, som till exempel färg, reflektans eller konturinformation för
att göra ytan mer detaljerad på ett prestandavänligt sätt. (För mer relevant information, se
ordlista: textur, normal mapping, bump mapping).
Sida 8
2.4 Tidigare forskning
Det kommer i det här stycket att redogöras varför metoderna som användes i projektet har tagits
fram, hur de fungerar och kan appliceras.
Där har skett mycket forskning kring procedurellt skapande och inom besläktade områden, som
procedurellt genererade texturer (Perlin, 1984; Perlin, 1985; Perlin, 2001), framförallt med fokus
på att komprimera data. Andra områden som har producerat relevant forskning är teknisk
medicin (Lorensen, Cline. 1987), för att hitta sätt att representera data från MRI scans och
astronomin (Goldsmith, Jacobson. 1996) för att återskapa visuella representationer av objekt i
rymden. Vanligtvis handlar det om att skapa en triangel mesh för att representera en grafisk
volym.
Många av de grundläggande teknikerna som fortfarande används inom spelindustrin idag ‒ och
som användes i detta projektet, kommer från University of Utah (University of Utah History,
2000), vars elever på 70- och 80-talet pionjerade bland annat texturmapping (Catmull, 1974),
bumpmapping (Blinn, 1978), phong ljussättning (Phong, 1973; Phong, 1975), goraud ljussättning
(Goraud, 1971) och blinn ljussättning (Blinn, 1976; Blinn, 1977).
2.4.1 Deferred rendering
För att förklara deferred rendering, bör man först gå tillbaka och redogöra varför tekniken
uppfanns.
Det traditionella viset att rita ut objekt och ljussätta dem är med forward rendering. Om man vill
beräkna ljussättning på modeller med forward rendering, måste man rita modellen en gång för
varje ljus som kolliderar med objektet.
I pseudokod:
Sida 9
for(each visible object)
{
for(each light)
{
draw object with light applied
}
}
Detta kan fungera väl om man har ett fåtal ljus eller små scener, till exempel inomhusmiljöer.
Dock blir det ett problem rent prestandamässigt om man vill ljussätta många objekt med många
ljus, då det helt enkelt krävs mycket beräkningskraft för att utföra detta tillräckligt snabbt. Detta
är, för att förtydliga, en simplifiering av en situation som består av en stor mängd variabler, och
vi tar inte med någon form av optimeringar eller förbättrade tekniker i beräkningen.
Deferred rendering handlar om att särskilja utritningen av scenen och appliceringen av ljus till
två olika pass. Först kommer geometry buffer (GBuffer) passet, där man ritar ut all geometri
(hela scenen). Utritningen av objekten sparas till olika render targets, som är en form av texturer.
Dessa texturer agerar buffrar (därav geometry buffer), för att temporärt lagra olika sorters
information; vanligtvis färgdata, djupdata och normaldata.
Sedan följer ljussättningspasset, som är annorlunda i jämförelse med ljussättning i forward
rendering, genom det faktum att man inte har direkt information om varje individuellt objekt i
scenen i deferred rendering. Därför återskapas varje objekts position med hjälp av djupdatan och
varje pixels skärmposition, eftersom operationerna inte sker direkt på geometrin, utan bara på
bilden av geometrin.
Man kan visualisera det som att programmet sparar undan en bild på scenen för senare
återskapning. Sedan när det är dags för ljusutritningen, hämtas dessa bilder på scenen för att
användas när grafikkortet gör ljusberäkningar.