Uitstekend spel Je speelt de nieuwste Call of Mario: Deathduty Battleyard op je pc. Je staart naar een prachtige 4K ultrabrede monitor en bewondert het prachtige landschap en de ingewikkelde details. Heb je je ooit afgevraagd hoe deze afbeeldingen daar zijn gekomen? Vraagt ​​u zich af wat uw pc doet om deze te doen?

Welkom bij onze 101 over het maken van 3D-games: een handleiding voor beginners over hoe je een basiskader voor goed spel kunt maken.

Elk jaar worden er over de hele wereld honderden nieuwe games uitgebracht - sommige zijn ontworpen voor mobiele telefoons, sommige voor consoles, sommige voor pc's. De formaten en genres die worden behandeld zijn even uitgebreid, maar er is één genre ontdekt door game-ontwikkelaars waarschijnlijk meer dan enig ander genre: 3D. De eerste bespreking van de eerste en een quickscan van de besprekingen Guinness World Records database genereert verschillende antwoorden. We hadden Knight Lore van Ultimate, dat in 1984 werd uitgebracht, als een waardige start kunnen kiezen, maar de afbeeldingen die in dit spel werden gemaakt, waren strikt 2D-gesproken - geen enkel deel van de gebruikte informatie is echt 3D.

Dus als we gaan begrijpen hoe de 3D-game van vandaag zijn afbeeldingen maakt, hebben we een ander startersvoorbeeld nodig: Winnende run Vanaf het begin iets in 3 dimensies doen, was de eerste in zijn soort, met behulp van technieken die misschien nog geen miljoen mijl verwijderd zijn van wat er nu gebeurt. Natuurlijk zal elk spel ouder dan 30 niet hetzelfde zijn als de Codemaster's F1 2018, maar het basisschema om ze allemaal te doen is niet veel anders.







In dit artikel zullen we het proces onderzoeken dat een 3D-game volgt om een ​​basisafbeelding te genereren voor een monitor of tv om weer te geven. We beginnen met de conclusie en vragen ons af: "Waar kijk ik naar?"

Van daaruit zullen we elke stap analyseren om de foto te krijgen die we zien. Onderweg bespreken we software en instructies zoals hoekpunten en pixels, texturen en overgangen, buffers en arcering. We zullen ook kijken waar de grafische kaart op al deze past en waarom deze nodig is. Met deze 101 kijk je in een nieuw licht naar je games en pc en waardeer je deze graphics met iets meer bewondering.




Afmetingen van het frame: pixels en kleuren

Laten we een 3D-game beginnen, dus we hebben iets om mee te beginnen en we zullen waarschijnlijk de 2007-versie van Crytek gebruiken zonder een andere reden dan de meest waardevolle game aller tijden. crysis. In onderstaande afbeelding zoeken we het camerabeeld van de monitor waarop de game te zien is.




Deze foto meestal kadermaar waar kijken we precies naar? Nou, met een macrolenscamera in plaats van een in-game screenshot, CSI: TECH NIEUWS en vraag iemand om het te verbeteren!




Helaas lopen de verblinding op het scherm en de achtergrondverlichting voor op het beelddetail, maar als we het wat meer verbeteren ...




We kunnen zien dat het frame op de monitor uit een raster van afzonderlijke gekleurde elementen bestaat, en als we heel goed kijken, bestaan ​​de blokken zelf uit 3 kleine stukjes. Een tot elke drie pixels (afkorting voor picture element) en de meeste monitoren schilderen ze met drie kleuren: rood, groen en blauw (ook bekend als RGB). Voor elk nieuw frame dat door de monitor wordt weergegeven, moet een lijst van duizenden, zo niet miljoenen RGB-waarden worden opgesteld en opgeslagen in een geheugenruimte die toegankelijk is voor de monitor. Dit soort geheugenblokken worden genoemd tamponsnatuurlijk naar de monitor framebuffer.

Dit is eigenlijk het laatste punt waarmee we begonnen, dus nu moeten we naar het begin gaan en het proces doorlopen om daar te komen. Naam gips het wordt vaak gebruikt om het te beschrijven, maar de waarheid is dat het een lange lijst is van onderling verbonden maar verschillende stadia die nogal van elkaar verschillen in termen van wat ze zijn. Zie het als chef-kok zijn en een maaltijd bereiden die een restaurant met Michelin-ster waardig is: het resultaat is een bord met heerlijk eten, maar er is nog veel te doen voordat je naar binnen gaat. enkele basisingrediënten.

Bouwstenen nodig: modellen en texturen

De basisbouwstenen van elk 3D-spel zijn de visuele activa die de te creëren wereld zullen vullen. Films, tv-shows, theatrale producties en dergelijke hebben allemaal acteurs, kostuums, rekwisieten, achtergronden, lichten nodig - de lijst is behoorlijk groot. 3D-games zijn niet anders en alles wat je in een gemaakt raamwerk ziet, wordt ontworpen door artiesten en modelleurs. Om dit te helpen visualiseren, gaan we naar de oude school en kijken naar een model van Software's Quake II-identiteit:

Quake II, die 20 jaar geleden werd uitgebracht, was een technologische tour-krachtpatser, zoals elk 3D-spel van twintig jaar, hoewel het redelijk is om te zeggen dat de modellen er een beetje blokkerig uitzagen. Dit maakt het echter gemakkelijker om te zien waarom deze entiteit is gemaakt.

In de eerste afbeelding kunnen we zien dat de dikke vriend verbonden driehoeken vormt - die elk hoekpunten worden genoemd. hoek of de piek voor een van deze. Elk hoekpunt fungeert als een punt in de ruimte, dus het heeft minimaal 3 cijfers om het te beschrijven, d.w.z. x, y, z-coördinaten. Een 3D-game heeft echter meer nodig, en elk hoekpunt heeft een extra waarde, zoals de kleur van het hoekpunt, de richting waarin het is gericht (ja, de stippen kunnen nergens anders uitzien ... rol er gewoon mee!), Hoe helder, doorschijnend het is. al dan niet, etc.

Een bepaalde set waarden die hoekpunten altijd hebben, textuur kaarten. Dit is een afbeelding van de 'kleding' die het model zou moeten dragen, maar aangezien het een eenvoudige afbeelding is, moet de kaart een weergave bevatten voor elke mogelijke richting waarin we naar het model kunnen kijken. In ons Quake II-voorbeeld kunnen we zien dat dit een vrij eenvoudige benadering is: voorkant, achterkant en zijkanten (armen). Een modern 3D-spel zal in feite meerdere textuurkaarten voor modellen hebben, elk vol details; Sommige kaarten zien er niet uit als materialen of kenmerken, maar geven in plaats daarvan informatie over hoe licht van het oppervlak weerkaatst. Elk hoekpunt bevat een set coördinaten in de bijbehorende structuurkaart van het model, zodat het bij het hoekpunt kan worden 'samengevoegd' - dit betekent dat als het hoekpunt wordt verplaatst, de textuur mee beweegt.

Dus in een 3D-gerenderde wereld begint alles wat je ziet als hoekpunten en een verzameling structuurkaarten. Ze worden verzameld in geheugenbuffers die aan elkaar zijn gekoppeld - een hoek bumper bevat informatie over hoeken; een directory buffer het laat ons zien hoe de hoeken zijn verbonden om vormen te vormen; een lassen buffer bevat geheugenweefsels en delen die zijn gereserveerd voor later gebruik in het weergaveproces; een opdrachtbuffer Lijst met instructies over wat u met allemaal moet doen.

Dit creëert het benodigde frame dat zal worden gebruikt om het uiteindelijke raster van gekleurde pixels te maken. Er kunnen voor sommige games enorme hoeveelheden gegevens zijn omdat het erg traag zou zijn om de buffers voor elk nieuw frame opnieuw op te bouwen. De spellen slaan alle informatie op die nodig is om de volledige potentieel zichtbare wereld te creëren, deze op te slaan in buffers of om een ​​breed scala aan weergaven te bestrijken en deze vervolgens indien nodig bij te werken. Een racegame als F1 2018 zal bijvoorbeeld alles in een grote bumpercollectie hebben, terwijl een open-wereldgame als Bethesda's Skyrim gegevens in en uit de bumpers zal verplaatsen terwijl de camera over de wereld beweegt.

De scène bewerken: piekfase

Met alle visuele informatie bij de hand, begint een game met de verwerking voor visuele weergave. Om te beginnen begint de scène in een standaardpositie, alle in principe geplaatste modellen, lichten, enz. Dit is het 'nul'-vierkant - het is het startpunt van de grafieken en wordt meestal niet weergegeven, maar gewoon weergegeven om de zaken gaande te houden. Om te laten zien wat er gebeurt in de beginfase van het bouwproces, Website voor realtime weergave. Laten we het openen met een heel eenvoudig 'spel': een balk op de grond.

Deze specifieke vorm bevat 8 hoekpunten, elk verklaard door een lijst met getallen, en ze vormen een patroon met 12 driehoeken ertussen. Zelfs een driehoek of een heel object primitief. Terwijl deze primitieven worden verplaatst, geroteerd en geschaald, doorlopen getallen een reeks wiskundige bewerkingen en worden ze dienovereenkomstig bijgewerkt.

Merk op dat de puntnummers van het model niet veranderen, alleen de waarden die aangeven waar de wereld is. Het opnemen van relevante wiskunde valt buiten het bestek van deze 101, maar het belangrijkste deel van dit proces is om alles te krijgen waar het eerst zou moeten zijn. Dan is het tijd voor een kleuring.

Laten we een ander model gebruiken met meer dan 10 keer het aantal hoeken dat de vorige balk had. Het meest basale type kleurweergave neemt de kleur van elk hoekpunt en berekent vervolgens hoe het oppervlak daartussen verandert; Het is bekend als interpolasyon.

Het hebben van meer hoeken in een model is niet alleen realistischer aanwezig, maar geeft ook betere resultaten met kleurinterpolatie.

In dit stadium van de weergavesequentie kan het effect van licht op de scène in detail worden onderzocht; Er kan bijvoorbeeld worden geïntroduceerd hoe de materialen van het model licht reflecteren. Bij dergelijke berekeningen moet rekening worden gehouden met de positie en richting van de camera die de wereld bekijkt, evenals met de positie en richting van de lichten.

Er zijn een aantal verschillende wiskundige technieken die hier kunnen worden gebruikt; sommige zijn eenvoudig, sommige zijn erg complex. In de afbeelding hierboven kunnen we zien dat het proces aan de rechterkant een mooier en realistischer resultaat geeft, maar het is niet verrassend dat het langer duurt om te werken.

Op dit punt is het vermeldenswaard dat we naar objecten kijken met weinig hoekpunten in vergelijking met de nieuwste 3D-game. Ga een stukje terug in dit artikel en kijk goed naar het beeld van Crysis: er zijn alleen al in die scène meer dan een miljoen driehoeken. We kunnen visueel begrijpen hoeveel driehoeken er in een modern spel worden geduwd. Unigine's Valley-vergelijking (downloaden).

Elk object in deze afbeelding is gemodelleerd door verbonden hoekpunten, zodat ze primitieven vormen die bestaan ​​uit driehoeken. Door vergelijking kunnen we een draadframe-modus uitvoeren waarmee het programma de randen van elke driehoek kan weergeven met een helderwitte lijn.

Bomen, planten, rotsen, grond, bergen - ze zijn allemaal gemaakt van driehoeken, elk berekend op basis van hun locatie, richting en kleur, rekening houdend met de positie van de lichtbron en de positie en richting van de camera. Alle wijzigingen die in de hoeken zijn aangebracht, moeten worden teruggevoerd naar het spel, zodat het weet waar alles zich bevindt om het volgende frame te maken; dit wordt gedaan door de vertexbuffer bij te werken.

Verrassend genoeg is dit niet het moeilijke deel van het bouwproces, en met de juiste hardware eindigt alles in slechts een duizendste van een seconde! Naar de volgende fase.

Een dimensie verliezen: rasteren

Zodra alle hoeken zijn doorgewerkt en onze 3D-scène klaar is waar alles zou moeten zijn, gaat de weergave naar een cruciaal stadium. Tot nu toe was de game echt driedimensionaal, maar niet het laatste frame - dat betekent dat er een aantal wijzigingen moeten worden aangebracht om de weergegeven wereld te transformeren van een 3D-ruimte met duizenden verbonden punten in een 2D-canvas van individuele gekleurde pixels. . Voor de meeste games omvat dit proces ten minste twee stappen: schermgebied projectie ve pixelatie.

Door opnieuw de webweergave-tool te gebruiken, kunnen we het dwingen om te laten zien hoe het volume van de wereld in eerste instantie wordt getransformeerd in een plat beeld. De locatie van de camera die naar de 3D-scène kijkt, is uiterst links; lijnen die verder gaan dan dit punt, afgeknot (als een soort piramide) en alles wat afgeknot is, kan mogelijk in het laatste frame verschijnen. Een kleine weg naar Frustum Visie, - dit is eigenlijk wat de monitor laat zien, en er wordt een hele stapel wiskunde gebruikt om alles in de afgeknotte kegel vanuit het perspectief van de camera in het gezichtsveld te projecteren.

Hoewel de afbeeldingen in de viewport 2D lijken, zijn de gegevens erin nog steeds 3D, en deze informatie wordt vervolgens gebruikt om te bepalen welke primitieven zichtbaar zijn of elkaar overlappen. Het kan verrassend moeilijk zijn om dit te doen, omdat een primitief een schaduw kan werpen die zichtbaar is in het spel, zelfs als deze niet primitief kan zijn. Het wordt de afschaffing van primitieven genoemd ruimen en het kan een significant verschil maken in hoe snel het hele frame wordt weergegeven. Nadat dit alles is gedaan - het sorteren van zichtbare en onzichtbare primitieven, driehoeken buiten mijn afgeknotte kegel, enz. - De laatste fase van 3D wordt gesloten en het frame wordt volledig 2D door middel van rastering.

De afbeelding hierboven toont een heel eenvoudig voorbeeld van een raamwerk met een primitief. Het raster van pixels van het frame wordt vergeleken met de randen van de onderstaande vorm, en waar ze elkaar overlappen, wordt een pixel gemarkeerd voor weergave. Het resultaat in het getoonde voorbeeld lijkt niet erg op de originele driehoek, maar we gebruiken niet genoeg pixels. Dit resulteerde in het volgende probleem: overlappen, hoewel er veel manieren zijn om ermee om te gaan. Daarom oplossing Het heeft een enorme impact op hoe een game (het totale aantal pixels dat in het frame wordt gebruikt) eruitziet: de pixels geven niet alleen de vorm van de primitieven beter weer, maar verminderen ook het effect van de ongewenste alias.

Wanneer dit deel van de renderreeks voltooid is, hangt het af van de grote: de uiteindelijke kleur van alle pixels in het frame.

Breng de lichten: pixelfase

Nu komen we bij de moeilijkste van alle stappen in de weergaveketen. Jaren geleden was het niet meer dan dat kleding in het model (ook bekend als texturen) om objecten in de wereld werd gewikkeld met behulp van informatie in pixels (aanvankelijk vanuit de hoeken). Het probleem hier is dat, hoewel de texturen en het frame 2D zijn, de wereld waaraan ze zijn gehecht, wordt gebogen, verplaatst en opnieuw vormgegeven in het bovenste stadium. Er wordt echter meer wiskunde gebruikt om dit uit te leggen, hoewel de resultaten enkele vreemde problemen kunnen veroorzaken.

In deze afbeelding is een eenvoudige dambordtextuurkaart aangebracht op een plat oppervlak dat zich in de verte uitstrekt. Het resultaat is een schokkende puinhoop waarbij de bijnaam zijn lelijke kop teruggroeit. De oplossing omvat kleinere versies van textuurkaarten ( Bij elkaar passen), herhaald gebruik van gegevens uit deze weefsels ( filtratie), en zelfs Meer wiskunde, alles bij elkaar opgeteld. Het effect hiervan is vrij duidelijk:

Vroeger was dit een heel moeilijke taak voor elk spel, maar dat is het nu niet meer omdat het liberale gebruik van andere visuele effecten, zoals reflecties en schaduwen, betekent dat de weergave van texturen een relatief klein deel van de pixel wordt. verwerkingsfase. Het spelen van games op hogere resoluties zorgt voor een hogere werkdruk in de rasterisatie- en pixelfasen van het renderproces, maar relatief weinig impact tijdens de piekfase. Hoewel de eerste kleuring door de lichten in het piekstadium gebeurt, kunnen hier ook helderdere lichteffecten worden gebruikt.

In de afbeelding hierboven kunnen we de kleurveranderingen tussen de driehoeken niet meer gemakkelijk zien, waardoor we de indruk krijgen dat dit een glad, naadloos object is. In dit specifieke voorbeeld bestaat de bol eigenlijk uit hetzelfde aantal driehoeken dat we zien. groene wereldbol ervoor De routine voor het kleuren van pixels geeft echter de indruk dat het veel meer driehoeken heeft.

In veel games moet de pixelfase meerdere keren worden uitgevoerd. Een spiegel of meeroppervlak dat de aarde reflecteert, zoals gezien vanuit de camera, moet bijvoorbeeld machinaal zijn bewerkt om de aarde te laten beginnen. Naam van elke overgang slagen voor en één frame kan gemakkelijk 4 of meer overgangen bevatten om het uiteindelijke beeld te produceren.

Soms moet de heuveletappe ook opnieuw worden getekend om de wereld vanuit een ander perspectief opnieuw te tekenen en die weergave te gebruiken als onderdeel van de scène die door de gamer wordt getoond. Voor deze gestelde doelen - buffers die fungeren als de laatste opslagplaats van het frame, maar die in een andere doorgang als textuur kunnen worden gebruikt.

Lees verder om de potentiële complexiteit van de pixelfase beter te begrijpen Frame-analyse door Adrian Courrèges en in dit spel zul je versteld staan ​​van de ongelooflijke stappen die nodig zijn om een ​​enkel frame te maken.

Al dit werk aan het frame moet worden opgeslagen in een buffer als een voltooid resultaat of als een tijdelijke opslag, en in het algemeen heeft een game minstens twee buffers onderweg voor de uiteindelijke weergave: de ene zal "werk zijn" en de andere wacht tot de monitor toegang heeft tot het scherm of in de weergavefase. Er moet altijd een framebuffer zijn om te maken, dus als ze allemaal vol zijn, moet er actie worden ondernomen om dingen te verplaatsen en een nieuwe buffer te starten. Het laatste onderdeel bij het ondertekenen van een frame is een eenvoudig commando (bijv. beschikbaar) en de buffers van het laatste frame worden echter gewijzigd, de monitor ontvangt het laatst gerenderde frame en het volgende frame kan worden gestart.

In deze afbeelding, van Ubisoft Assassin's Creed Odysseywe kijken naar de inhoud van een voltooide framebuffer. Zie het als een spreadsheet met rijen en kolommen die alleen cijfers bevatten. Deze waarden worden als elektrisch signaal naar de monitor of tv gestuurd en de kleur van de schermpixels wordt gewijzigd in de vereiste waarden. CSI: TECH NIEUWS Omdat we het niet met onze ogen kunnen doen, zien we een vlak, continu beeld, maar ons brein diepte - zo 3D. Het is een raamwerk van goedheid van games, maar er gebeurt zoveel achter de schermen (sorry woordspeling), het is de moeite waard om te bekijken hoe programmeurs dit allemaal aanpakken.

Beheer van het proces: API's en instructies

Begrijpen hoe een spel al deze oefeningen zal uitvoeren en beheren (wiskunde, hoeken, texturen, lichten, bumpers, noem maar op…) is een gigantische taak. Gelukkig is er hulp in de vorm van wat te zeggen interface voor applicatieprogrammering of kortweg API.

Build API's verminderen de algehele complexiteit door bibliotheken met structuren, regels en code te bieden waarmee programmeurs vereenvoudigde instructies kunnen gebruiken, onafhankelijk van de betrokken hardware. Kies een 3D-game die in de afgelopen 3 jaar voor pc is uitgebracht en deze wordt gemaakt met behulp van een van de drie bekende API's: Direct3D, OpenGL of Vulkan. Er zijn andere, vooral in de mobiele scene, maar we houden het bij die voor dit artikel.

Hoewel er verschillen zijn in termen van instructies en bewerkingen (bijv. Een codeblok voor het manipuleren van pixels in DirectX, pixel-arcering; Vulkaan part shader), mag het uiteindelijke resultaat van het gemaakte frame niet anders of meer verschillen.

Er zal een verschil zijn waar alle hardware die wordt gebruikt om de rendering uit te voeren, naar beneden komt. Dit komt omdat de instructies die worden gegeven met behulp van de API om de hardware uit te voeren, moeten worden vertaald - dit wordt afgehandeld door de stuurprogramma's van het apparaat en hardwarefabrikanten moeten veel middelen en tijd besteden om ervoor te zorgen dat de stuurprogramma's de conversie zo snel en nauwkeurig mogelijk uitvoeren. mogelijk.

Laten we een eerdere bètaversie van Croteam's spel uit 2014 gebruiken Talos-principe Om dit te illustreren, omdat het de 3 API's ondersteunt die we hebben genoemd. Om de verschillen te maximaliseren die de combinatie van driver en interface soms kan produceren, hebben we de standaard ingebouwde benchmark uitgevoerd met een resolutie van 1080p bij maximale visuele instellingen. De gebruikte computer draaide op standaarduren en had een Intel Core i7-9700K, Nvidia Titan X (Pascal) en 32 GB DDR4 RAM.

  • DirectX 9 = gemiddeld 188,4 fps
  • DirectX 11 = gemiddeld 202,3 fps
  • OpenGL = gemiddeld 87,9 fps
  • Vulkan = gemiddeld 189,4 fps

Een volledige analyse van de gevolgtrekkingen achter deze cijfers valt niet binnen het bestek van dit artikel, en het betekent zeker niet dat de ene API 'beter' is dan de andere (dit is een bètaversie, onthoud), dus 'programmeren voor verschillende API's biedt verschillende uitdagingen en is momenteel wijst erop dat er altijd een verandering in de prestaties zal zijn. Over het algemeen zullen game-ontwikkelaars de API kiezen waarmee ze het meest werken en op basis daarvan hun code optimaliseren. Soms het woord motor Het wordt gebruikt om de renderingcode te beschrijven, maar technisch gezien is een engine het complete pakket dat alle aspecten van een game afhandelt, niet alleen de graphics.

Het is niet eenvoudig om vanaf het begin een compleet programma te maken om 3D-games te maken, dus veel games hebben tegenwoordig een licentie voor volledige systemen van andere ontwikkelaars (bijv. Onwerkelijke motor); U kunt een idee krijgen van de schaal door de open source-engine voor te bekijken. id Software aardbeving en blader door het gl_draw.c-bestand - dit enkele item bevat instructies over de verschillende builds die in het spel zijn uitgevoerd en vertegenwoordigt slechts een klein deel van de hele engine. De aardbeving is meer dan 20 jaar oud en het hele spel (inclusief alle elementen, geluiden, muziek, etc.) het is 55 MB groot; in tegenstelling tot Ubisoft Far Cry 5 bedrag enkel en alleen shaders die door het spel worden gebruikt op een bestand van 62 MB.

Tijd is alles: de juiste hardware gebruiken

Alles wat we tot nu toe hebben beschreven, kan worden berekend en verwerkt door de CPU van elk computersysteem; moderne x86-64-processors ondersteunen gemakkelijk alle benodigde wiskunde, en er zijn speciale onderdelen voor deze dingen. Het uitvoeren van deze taak om een ​​raamwerk te bouwen vereist echter veel repetitieve berekeningen en vereist een aanzienlijke hoeveelheid parallelle verwerking. CPU's zijn hier niet voor ontworpen omdat ze per definitie te generiek zijn. Speciale fiches voor dit soort werk worden natuurlijk genoemd GPU'lar (grafische verwerkingseenheden) en wiskunde zoals DirectX, OpenGL en Vulkan zijn gebouwd om de benodigde wiskunde op een zeer snelle en grotendeels parallelle manier uit te voeren.

Een manier om dit aan te tonen is om een ​​benchmark te gebruiken waarmee we een frame kunnen maken met behulp van een CPU en vervolgens aangepaste hardware kunnen gebruiken. We zullen V-beam ADVANCED door Chaos Group gebruiken; Deze tool doet eigenlijk ray tracing in plaats van de rendering die we in dit artikel bekijken, maar de meeste aantal storingen vereisen vergelijkbare hardware-aspecten.

Om het verschil te begrijpen tussen wat een CPU kan en wat de juiste, speciaal ontworpen hardware kan bereiken, hebben we de V-ray GPU-vergelijking in 3 modi uitgevoerd: alleen CPU, alleen GPU en vervolgens CPU + GPU. De resultaten zijn heel verschillend:

  • Alleen CPU-test = 53 wiskunde
  • Alleen GPU-test = 251 wiskunde
  • CPU + GPU testi = 299 mpath

Omdat een verschil van 5x in output niet triviaal is, kunnen we de meeteenheden in deze vergelijking negeren. Maar dit is niet echt een game-achtige test, dus laten we iets anders proberen en naar een oude school gaan. 3DMark03 van Futuremark. Door de eenvoudige Wings of Fury-test toe te passen, kunnen we dwingen om alle hoekshaders uit te voeren (d.w.z. alle routines voor het verplaatsen en maken van kleurendriehoeken) met behulp van de CPU.

Het resultaat zou niet echt als een verrassing moeten komen, maar het is nog steeds veel duidelijker dan wat we zagen in de V-ray-test:

  • CPU peak shaders = gemiddeld 77 fps
  • GPU-hoekshaders = gemiddeld 1580 fps

Terwijl de CPU alle vertexberekeningen aan het uitvoeren was, duurde het gemiddeld 13 milliseconden om elk frame weer te geven en weer te geven; Door die wiskunde naar de GPU te pushen, wordt deze tijd teruggebracht tot 0,6 milliseconden. Met andere woorden, het was 20 keer sneller.

Als we de meest complexe test ter vergelijking proberen, moeder natuur, is het verschil nog groter. Met CPU-gerenderde peak-shaders was het gemiddelde resultaat 3,1 fps! Breng de GPU mee en de gemiddelde framesnelheid stijgt naar 1388 fps: zo'n 450 keer sneller. Merk op dat 3DMark03 nu 16 jaar oud is en de test alleen hoeken in de CPU behandelt - de rasterisatie en pixelfase worden nog steeds gedaan via de GPU. Wat als het modern was en alles in software werd gedaan?

Laten we proberen Unigine Valley opnieuw benchmarking-tool - relatief nieuw, waardoor de graphics erg lijken op die in games zoals Ubisoft's Far Cry 5; Naast de standaard DirectX 11 GPU-bus biedt het ook een volledige softwaregebaseerde renderer. Resultaten vereisen niet veel analyse, maar het uitvoeren van de versie van de laagste kwaliteit van de DirectX 11-test op de GPU leverde gemiddeld 196 frames per seconde op. Software versie? Afgezien van een paar crashes, trekt de krachtige testcomputer gemiddeld 0,1 frames per seconde - bijna tweeduizend keer langzamer.

De reden voor een dergelijk verschil ligt in de vorm van wiskunde en gegevens die 3D-rendering gebruikt. In een CPU, drijvende-komma-eenheden (FPU's) doen de berekeningen binnen elke kern; Het i7-9700K-model van de test-pc heeft 8 cores met elk twee FPU's. Hoewel de eenheden in Titan X verschillen qua ontwerp, kunnen beide dezelfde basisberekeningen uitvoeren in hetzelfde gegevensformaat. Deze specifieke GPU heeft meer dan 3500 eenheden om een ​​vergelijkbare berekening te maken, en hoewel de klok nergens in de buurt van dezelfde locatie wordt weergegeven als de CPU (1,5 GHz versus 4,7 GHz), overtreft de GPU de centrale processor met het aantal transparante eenheden.

Hoewel de Titan X geen generieke grafische kaart is, presteert zelfs een budgetmodel beter dan elke CPU, dus alle 3D-games en API's zijn ontworpen voor speciale, speciale hardware. Voel je vrij om V-ray, 3DMark of een andere Unigine-benchmark te downloaden en je eigen systeem te testen - plaats de resultaten op het forum zodat je kunt zien hoe goed GPU's zijn voor het weergeven van grafische afbeeldingen in games.

Enkele laatste woorden op onze 101 pagina

Dit was een korte studie van hoe een vierkant wordt weergegeven in een 3D-game, van punten in de ruimte tot een kleurenpixel op een monitor.

Op het meest basale niveau is het hele proces niets meer dan werken met getallen, omdat alle computers het toch doen. Dit artikel laat echter veel over om op de basis te focussen (we zullen waarschijnlijk verder gaan met meer diepgaande duiken in hoe computergraphics later worden gemaakt). We hebben geen enkele van de echte gebruikte wiskunde opgenomen, zoals Euclidische lineaire algebra, trigonometrie en differentiaalrekening uitgevoerd door de wortel- en pixel-shaders; We hebben uitgelegd hoe texturen worden verwerkt door middel van statistische bemonstering en we hebben geweldige visuele effecten terzijde geschoven, zoals omgevingsocclusie op het scherm, ruisonderdrukking van ray trace, weergave met een hoog dynamisch bereik of tijdelijke anti-aliasing.

Maar als je de volgende Call of Mario: Deathduty Battleyard afvuurt, zie je niet alleen de graphics met een nieuw gevoel van verwondering, maar je zult ook kriebelen om meer te leren.