Nvidia GeForce RTX 2080 & RTX 2080 Ti review: nieuwe generatie gebenchmarkt

238 reacties
3 besproken producten
Inhoudsopgave
  1. 1. Inleiding
  2. 2. Drie modellen: 2070, 2080 en 2080 Ti
  3. 3. Founders Editions en custom kaarten
  4. 4. Turing-architectuur: nieuwe cores, snellere shaders
  5. 5. Snellere caches, sneller geheugen
  6. 6. Rasterization vs. raytracing
  7. 7. Wat is raytracing?
  8. 8. Real-time raytracing
  9. 9. Tensor-cores: slimme trucs met AI
  10. 10. Nvidia's marketing in de hoogste versnelling: RTX-Ops
  11. 11. RTX-technologie: welke games?
  12. 12. Andere nieuwe rendermogelijkheden
  13. 13. Ondersteuning voor video en monitoren
  14. 14. SLI in het nieuw en overklokken voor dummy's
  15. 15. Testprocedure
  16. 16. Benchmarks: 3DMark Firestrike / Timespy
  17. 17. Benchmarks: Unigine Superposition
  18. 18. Benchmarks: Assassin's Creed Origins (DX11)
  19. 19. Benchmarks: Battlefield 1 (DX12)
  20. 20. Benchmarks: F1 2018 (DX11)
  21. 21. Benchmarks: Far Cry 5 (DX11)
  22. 22. Benchmarks: Forza Motorsport 7 (DX12)
  23. 23. Benchmarks: Ghost Recon: Wildlands (DX11)
  24. 24. Benchmarks: GTA V (DX11)
  25. 25. Benchmarks: Rise of the Tomb Raider (DX12)
  26. 26. Benchmarks: The Witcher 3: Blood & Wine (DX11)
  27. 27. Benchmarks: Total War: Warhammer II (DX12)
  28. 28. Benchmarks: Wolfenstein II: The New Colossus (Vulkan)
  29. 29. HDR
  30. 30. Benchmarks: Hardware.Info GPU Prestatiescore 2018-2
  31. 31. Testresultaten: Stroomverbruik
  32. 32. Testresultaten: Geluidsproductie
  33. 33. Conclusie
  34. 3 besproken producten
  35. 238 reacties

Rasterization vs. raytracing

Hét buzzword bij de nieuwe kaarten is zoals in de inleiding al geschreven dat dit de eerste generatie gpu's is die, dankzij de speciale RT-cores, geschikt zou zijn voor real-time raytracing. Of, om het correcter te formuleren, het real-time berekenen van verschillende effecten op basis van raytracing technieken.

Wat is dat raytracing nu precies? Het is een al eind jaren 70 uitgedachte manier om zéér realistische 3D-beelden te renderen. 3D-animatiefilms zoals je die ziet in de bioscoop, zoals bijvoorbeeld de films van Pixar, worden vrijwel zonder uitzondering met behulp van deze techniek gemaakt. Voor 3D-games wordt een andere techniek gebruikt, genaamd rasterization. Dat is niet zonder reden: waar we bij games natuurlijk graag spreken over het aantal frames per seconde, praat je vanwege de complexiteit bij raytracing eerder over secondes, minuten en in sommige gevallen zelfs uren per frame. Laat één ding duidelijk zijn: van games volledig renderen via raytracing op een Pixar-achtige manier zijn we nog jaren verwijderd. Maar, met de nieuwe GeForce RTX kaarten is het wel voor het eerst mogelijk om uiteenlopende effecten in games, zoals bijvoorbeeld schaduwen of reflecties, realistischer dan ooit weer te geven met behulp van raytracing.

Voordat we op de volgende pagina bespreken wat er nu wel en niet mogelijk is met de GeForce RTX kaarten en wat de Nvidia RT-cores exact doen, leggen we je eerst uit wat nu precies het verschil is tussen de twee rendering methodes.

Rasterization

3D-games worden al sinds jaar en dag berekend volgens een methode die rasterization heet. Hierbij wordt het aantal benodigde berekeningen zo veel mogelijk geminimaliseerd. Dat was zeker in de begintijd van 3D-videokaarten een vereiste om überhaupt meerdere beelden per seconde te berekenen en weer te geven.

Iedere 3D-wereld wordt opgebouwd uit meerdere objecten, die op hun beurt in de regel weer zijn opgebouwd uit vele driehoeken, triangles in jargon. Die objecten zijn alles wat je in de game ziet: tegenspeler, de grond, muren, auto's, etc. Het opbouwen van al die 3D-objecten en deze plaatsen in de virtuele wereld wordt gedaan voor de engine van de game - en dit gebeurt overigens op de CPU, niet op de gpu.

De gpu komt in het spel zodra de game-engine een camerastandpunt heeft bepaald. Vervolgens wordt er in de 3D-wereld een 2D-vlak geplaatst, wat in principe de positie van je monitor is binnen de scene (en je monitor is natuurlijk ook een tweedimensionaal plat vlak). In een door de gpu uitgevoerd proces dat transformation wordt genoemd, wordt op basis van het camerastandpunt één voor één voor elk van de 3D-objecten bepaald of en zo ja waar op het 2D-vlak en dus op jouw monitor ze zichtbaar zullen zijn. Hierbij wordt direct gewerkt met de pixels van je monitor: voor elk van de objecten, of feitelijk voor elk van de driehoeken waaruit de objecten zijn opgebouwd, wordt bepaald welke pixels die beslaan op het scherm. Dit omzetten naar pixels heet rasterization.


In de 3D-wereld wordt een camerastandpunt bepaald en een 2D-vlak geplaatst op de positie van je monitor.


In een proces genaamd "transformation" wordt voor alle objecten bepaald of én waar ze op het scherm zichtbaar zijn.


Middels het "rasterization" proces wordt bepaald welke pixels op het scherm alle objecten beslaan.

Door objecten dit proces van achteren naar voren te laten doorlopen, weet de gpu uiteindelijk voor iedere pixel op het scherm wélk object daar zichtbaar is en daardoor dus voor iedere pixel van het scherm op basis van welk object de uiteindelijk kleur van de pixel berekend kan worden (shading in jargon).

Culling, clipping en z-buffering

So far so good, maar ook dit proces kan in potentie extreem complex zijn, aangezien het aantal objecten in een 3D-wereld kan oplopen tot miljoenen stuks, die elk weer uit tientallen, duizenden en soms zelfs uit honderdduizenden driehoeken bestaan. Bedenk je maar eens hoeveel objecten er aanwezig zijn op een Fortnite-eiland tijdens een potje wild in het rond schieten. Als alle objecten en dus alle driehoeken verwerkt zouden worden, zou zelfs de snelste videokaart ter wereld vermoedelijk rekenkracht tekort komen. Gelukkig zijn er de nodige trucs...

Zo bepaalt de game-engine in samenwerking met de gpu al vrij snel welke objecten überhaupt niet in het blikveld van de camera vallen. Deze objecten worden dan in geheel niet meer meegenomen in het transformation en rasterization proces, iets wat men view frustum culling noemt. Voor objecten die maar deels in het zichtveld staan, worden de driehoeken die buiten het blikveld vallen ook uit het proces gehaald, wat viewport clipping heet. Daar blijft het niet bij: voor alle objecten die daadwerkelijk zichtbaar zijn, wordt bepaald welke driehoeken zich vanuit het camera standpunt aan de achterkant van het object bevinden. Die zie je toch niet en worden dan ook niet meegenomen in de rest van het proces - back-face culling in jargon. Door al in het begin van het proces de diepte (bezien vanuit het camerastandpunt) van alle driehoeken van alle objecten te berekenen, kun je elementen die zich achter andere elementen bevinden eveneens wegfilteren, en dat heet dan weer z-buffering in jargon.


Boven: geen culling, Midden: view frustum culling, Onder: viewport clipping (Bron: Microsoft)


Boven: back-face culling, Onder: z-buffering (Bron: Microsoft)

Uiteindelijk hoeft de gpu nu enkel en alleen met (onderdelen van) objecten aan de slag die daadwerkelijk zichtbaar zijn. Het bepalen van de uiteindelijke kleur gebeurt op verschillende manieren, waaronder texturing (het plakken van een afbeelding op de driehoeken) en uiteenlopende andere methodes.

Rasterization is een beproefde methode die goed en snel werkt en er voor zorgt dat we sinds de introductie van 3D-videokaarten eind vorige eeuw en programmeerbare gpu's begin deze eeuw op hoge snelheid mooie 3D-beelden op ons scherm getoverd krijgen. Maar... als game-developers steeds realistischer beelden wensen, wordt rasterization steeds meer een beperking. Dat zit hem vooral op het vlak van belichting, schaduwen en reflecties. Belichting is op zichzelf nog niet eens de grootste uitdaging: op basis van de positie en felheid van de lichtbronnen in de game, kan tijdens het inkleuren (shaden) van de objecten prima rekening worden gehouden met hoe licht of donker dat moet gebeuren. Shaduwen en reflecties zijn een heel ander verhaal.

Licht, schaduw en reflectie bij rasterization

Na de rasterization stap zijn er immers geen 3D-objecten meer: alles in een scène is 2D, waardoor er geen informatie is hoe objecten ten opzichte van elkaar gepositioneerd zijn. Shaduwen en reflecties berekenen kan hierdoor niet meer. De game-engine moet daar met allerhande trucs vooraf rekening mee houden, wat nog eens wordt bemoeilijkt door het feit dat schaduwen en reflecties ook kunnen worden veroorzaakt door (delen van) objecten die dankzij de hierboven beschreven culling-technieken helemaal niet meer mee worden genomen in de berekeningen. Zelfs als je alle vormen van culling en clipping zou uitschakelen - waardoor ook de rasterization methodiek onwerkbaar traag wordt - heb je alsnog het probleem dat er in de hele manier van werken volgens deze methode niets zit waar het effect van lichtbronnen wordt doorgerekend.

In 3D-games zijn schaduwen en reflecties zodoende allemaal een kwestie fake it till you make it. Met uiteenlopende technieken wordt zo goed en zo kwaad als het gaat de illusie gewekt van kloppende schaduwen en reflecties, maar als je goed kijkt zul je zien dat het zelfs in de mooiste games nooit écht klopt. Aan het begin van deze eeuw kwamen game-developers nog weg met bijvoorbeeld een extra texture-laag met een vooraf gedefinieerd (en berekend) belichtingseffect dat op een basis-texture werd geplakt en klaar was kees. Met lichtbronnen en overige objecten met een vaste positie is dat vrij simpel te doen. Zodra objecten bewegen (zoals spelers binnen de games) of erger nog, er bewegende lichtbronnen zijn, wordt het een stuk complexer.




Een traditionele vorm van "fake it till you make": een basis texture, een vooraf berekend belichtingseffect en de combinatie ervan die op een 3D-object geplakt wordt.

Beperkingen van cube mapping

Een truc die voor reflecties nog wel aardig werkt is cube mapping. Hierbij wordt een virtuele kubus rondom een reflecterend object geplaatst en wordt vanuit de binnenkant van het object als camera standpunt met elk van de zes vlakken van de kubus als pseudo-schermen de 3D-scene nog eens opnieuw gerenderd. Het resultaat wordt uiteindelijk als extra texture op het object geplakt. Op zich leuk en aardig, ware het niet dat op dergelijke manier gesimuleerde reflecties ook complex zijn om te berekenen (voor ieder reflecterend object bereken je de hele scene nog maximaal zes keer). Daarnaast zijn objecten in de regel niet vierkant zijn en dus kan de reflectie-texture niet geheel kloppend gepositioneerd worden; daar komt bij dat de reflectie maar vanuit één punt middenin het object wordt berekend en dus niet kloppend vanuit het oorspronkelijke camerastandpunt. Dan hebben we het nog niet gehad over het feit dat cube mapping helemaal onmogelijk wordt zodra er meerdere reflectieve objecten zijn en je dit ook nog eens wil combineren met andere belichtingseffecten.


Cube mapping is één van de methodes om reflecties mogelijk te maken in 3D-games, maar 100% is realistisch is het bij lange na niet. (Bron: Wikipedia)

Kortom, met rasterization en bijbehorende technieken kun je een heel eind komen, zoals de schitterende graphics van state-of-the-art games bewijzen. Maar wil je belichtingseffecten volledig correct hebben en daarmee beelden nog véél realistischer maken, dan zijn andere methodes nodig. Daar komt raytracing om de hoek kijken.


3 besproken producten

Vergelijk alle producten

Vergelijk   Product Prijs
Nvidia GeForce RTX 2070 8GB

Nvidia GeForce RTX 2070 8GB

  • TU106
  • 2304 cores
  • 1410 MHz
  • 8192 MB
  • 256 bit
  • DirectX 12 fl 12_1
  • PCI-Express 3.0 x16
Niet verkrijgbaar
Nvidia GeForce RTX 2080 8GB

Nvidia GeForce RTX 2080 8GB

  • TU104
  • 2944 cores
  • 1515 MHz
  • 8192 MB
  • 256 bit
  • DirectX 12 fl 12_1
  • PCI-Express 3.0 x16
Niet verkrijgbaar
Nvidia GeForce RTX 2080 Ti 11GB

Nvidia GeForce RTX 2080 Ti 11GB

  • TU102
  • 4352 cores
  • 1350 MHz
  • 11264 MB
  • 352 bit
  • DirectX 12 fl 12_1
  • PCI-Express 3.0 x16
Niet verkrijgbaar
0
*