← Arkiv
Projekt20 min läsning3D / JavaScript

3D Lab: grunderna i 3D-rendering, från en labbuppgift 1998 till three.js

Hur blir en lista med koordinater en skuggad bild? 3D Lab är en labbuppgift i datorgrafik från 1998, översatt från C och IRIS GL till three.js. Här går jag igenom grunderna steg för steg – kamera, perspektiv, klippning, synlighet och Phongs ljusmodell – med matematiken, diagram och felen jag hittade i originalet.

Samma modell med 28 års mellanrum: hazard.byu i originalet på en SGI-maskin 1998 (till vänster, skärmbild från då) och i dagens version i webbläsaren, flat-skuggad med standardvärdena.

Samma modell med 28 års mellanrum: hazard.byu i originalet på en SGI-maskin 1998 (till vänster, skärmbild från då) och i dagens version i webbläsaren, flat-skuggad med standardvärdena.

3D LabMovie.BYU-modeller med kamera, klippning, culling och Phong-ljus i webbläsaren

En labbuppgift från 1998

Våren 1998 läste jag kursen Datorgrafik och visualisering C, 5 poäng, vid Umeå universitet. Laboration 2 var att skriva ett program som läser in 3D-modeller och ritar dem på skärmen – med egen kamera, egen projektion, egen klippning, egen synlighetstest och egen ljussättning. Det skrevs i C med IRIS GL på en SGI-maskin, och grafikbiblioteket fick bara rita det färdiga: linjer och fyllda polygoner i skärmkoordinater. Allt annat räknade vi själva.

Programmet, gfx.c, är daterat den 2 februari 1998. Skärmbilderna är från den 5 februari. Modellerna följde med kursen, i ett format som hette Movie.BYU.

Originalet från februari 1998: trehjulingen flat-skuggad i IRIS GL, med kamerans och ljusets parametrar i rött och knapparna till höger. Skuggorna är blå eftersom det omgivande ljuset var satt till (0,3, 0,6, 1,0).
Originalet från februari 1998: trehjulingen flat-skuggad i IRIS GL, med kamerans och ljusets parametrar i rött och knapparna till höger. Skuggorna är blå eftersom det omgivande ljuset var satt till (0,3, 0,6, 1,0).

I dag finns samma labb som 3D Lab på Burn Tokens Repeat, översatt till JavaScript och three.js av Claude Code. Det här inlägget går igenom vad labben faktiskt gör, steg för steg: formatet, kameran, projektionen, klippningen, vilka ytor som syns och hur ljuset räknas – med matematiken och ett räkneexempel på dagens standardvärden. Diagrammen ritade Claude Code som SVG.

Movie.BYU – ett nästan utdött format

Movie.BYU var ett grafiksystem från Brigham Young University i Utah, skrivet av Henry N. Christiansen, professor i byggteknik, och Michael B. Stephenson. Manualen A General Purpose Computer Graphics Display System är från september 1976, och 1979 beskrevs systemet i en artikel i ASCE:s tidskrift. Det kunde visa både linjeteckningar och skuggade bilder i färg, och användes mest för att titta på finita element-modeller – NASA Langley skrev 1984 om hur de byggt ut det för animering, och Cray Research gjorde reklam för det 1985.

Programmet underhålls inte längre, men geometriformatet lever kvar. VTK har en läsare och en skrivare för det, och Ansys EnSight kan fortfarande läsa det. Formatet är beskrivet hos Paul Bourke och John Burkardt.

En fil har fyra delar: en rubrikrad med antalet delar, hörn, polygoner och kanter; ett intervall per del; alla hörns x, y och z; och till sist polygonerna som listor av hörnindex. Index börjar på 1, och det sista hörnet i varje polygon skrivs med minustecken – så behövs inget separat antal hörn per polygon. Fälten kommer från FORTRAN, med fasta bredder (10I8 för heltal, 6E12.5 för flyttal), men de flesta läsare delar bara på blanksteg.

Diagram: cube.byu rad för rad – rubrikraden, delarnas intervall, hörnens koordinater två och två och polygonerna, där ett negativt index avslutar en polygon.
Diagram: cube.byu rad för rad – rubrikraden, delarnas intervall, hörnens koordinater två och två och polygonerna, där ett negativt index avslutar en polygon.

Ordningen hörnen räknas upp i spelar roll: sett utifrån går de moturs. Det är det enda sättet filen berättar vad som är utsida, och både synlighetstestet och ljuset bygger på det.

WebGL ritar ytor bara som trianglar, så dagens version delar varje polygon i en solfjäder från första hörnet. Det fungerar för konvexa polygoner, och det är vad modellerna i labben har. Trådmodellen ritar ändå polygonernas egna kanter, så diagonalerna syns inte.

Diagram: en femhörning delas i tre trianglar som en solfjäder från första hörnet.
Diagram: en femhörning delas i tre trianglar som en solfjäder från första hörnet.

Från fil till pixel

Varje hörn går genom samma kedja av koordinatsystem. Modellens egna koordinater placeras i världen, världen uttrycks i kamerans koordinater (”öga”), projektionen delar med djupet, och resultatet skalas till normaliserade koordinater (NDC) och sedan till pixlar i ett fönster. I originalet fanns upp till fyra sådana fönster – vyportar – på skärmen samtidigt, var och en med egen kamera och eget ljus.

Diagram: kedjan av koordinatsystem från fil till pixel – objekt, värld, öga, projektion, NDC och skärm.
Diagram: kedjan av koordinatsystem från fil till pixel – objekt, värld, öga, projektion, NDC och skärm.

Kameran: F, A och U

Kameran beskrivs med tre vektorer: F (from), där ögat står, A (at), punkten man tittar på, och U (up), ungefär vad som är upp. Ur dem byggs en ortonormerad bas – tre vektorer med längd ett som är vinkelräta mot varandra:

c = (A − F) / |A − F|          blickriktningen
a = (c × U) / |c × U|          åt sidan
b = a × c                      upp i bilden

U behöver inte vara vinkelrät mot blickriktningen. Kryssprodukten tar bort det som är fel: a blir vinkelrät mot både c och U, och b blir vinkelrät mot de två andra. Bara om U pekar rakt längs c går det inte, eftersom c × U då blir nollvektorn.

Diagram: kamerans bas. c pekar från ögat F mot punkten A, a är vinkelrät mot c och upp-vektorn U, och b = a × c.
Diagram: kamerans bas. c pekar från ögat F mot punkten A, a är vinkelrät mot c och upp-vektorn U, och b = a × c.

Att byta till ögats koordinater är då tre skalärprodukter per hörn – projektionen av P − F på var och en av axlarna:

xe = (P − F) · a
ye = (P − F) · b
ze = (P − F) · c

Efter det står ögat i origo och tittar längs z-axeln. Allt som följer blir enklare av det.

Perspektiv

En punkt som är dubbelt så långt bort ska se hälften så stor ut. Lägg ett bildplan på avståndet d framför ögat och dra en linje från ögat till punkten. Var linjen skär planet följer av likformiga trianglar:

y′ / d = ye / ze    →    y′ = d · ye / ze
x′ = d · xe / ze
Diagram: perspektivprojektion med likformiga trianglar, y′ = d · y / z.
Diagram: perspektivprojektion med likformiga trianglar, y′ = d · y / z.

Originalet skalar resultatet direkt till vyporten. Med synvinkeln v, vyportens mitt (Xvc, Yvc) och dess bredd och höjd (Vw, Vh):

T  = 2 · tan(v / 2)
Xs = Xvc + (xe / ze) · Vw / T
Ys = Yvc + (ye / ze) · Vh / T

Det går att kontrollera med en punkt precis i kanten av synfältet. Där är xe / ze = tan(v / 2), och då blir Xs = Xvc + Vw / 2 – precis vyportens högra kant. Med v = 45° är T = 2 · tan 22,5° ≈ 0,828. En punkt med xe / ze = 0,25 hamnar 0,25 / 0,828 ≈ 0,30 vyportbredder till höger om mitten.

Dagens version har samma synvinkel som standard, 45°. Skillnaden är att three.js gör samma sak med en 4×4-matris och en division med w, och att den också behåller djupet till z-bufferten.

Klippning: Cohen–Sutherland

En linje som går utanför fönstret måste kortas av innan den ritas. Cohen–Sutherland ger varje ändpunkt en kod på fyra bitar, en per kant: 8 om punkten ligger ovanför, 4 under, 2 till höger och 1 till vänster. Punkter inne i fönstret får 0000.

Diagram: Cohen–Sutherland. Planet delas i nio områden med fyrbitarskoder, och linjen klipps mot fönstrets kanter.
Diagram: Cohen–Sutherland. Planet delas i nio områden med fyrbitarskoder, och linjen klipps mot fönstrets kanter.

Sedan avgör koderna nästan allt:

  • Båda koderna 0000: linjen ligger helt inne. Rita den.
  • Koderna har en gemensam bit (c0 & c1 ≠ 0): båda punkterna ligger på samma utsida. Släng linjen.
  • Annars: ta en punkt som ligger ute, flytta den till skärningen med en av kanterna den ligger utanför, räkna om dess kod och börja om.

Skärningen räknas ur linjens ekvation. Mot vänsterkanten x = xmin och mot överkanten y = ymax:

y = y0 + (y1 − y0) · (xmin − x0) / (x1 − x0)
x = x0 + (x1 − x0) · (ymax − y0) / (y1 − y0)

Varje varv tar bort minst en bit, så det tar högst fyra varv. I originalet klipps trådmodellens kanter så här. De fyllda polygonerna lämnades åt IRIS GL. I dag gör GPU:n klippningen, mot alla sex sidorna av synfältet.

Vilka ytor syns?

Normalen

Normalen är en vektor vinkelrät mot ytan. Den ges av kryssprodukten av två kanter som utgår från samma hörn:

e1 = v1 − v0
e2 = v2 − v0
N  = e1 × e2
   = (e1y·e2z − e1z·e2y,
      e1z·e2x − e1x·e2z,
      e1x·e2y − e1y·e2x)

Eftersom hörnen går moturs sett utifrån pekar N utåt. Originalet räknade (v1 − v2) × (v3 − v2), samma sak med mitthörnet som utgångspunkt. Om de tre första hörnen ligger på en linje blir N nollvektorn, och då försökte det med hörn 2, 3 och 4 i stället.

Diagram: ytnormalen som kryssprodukten av två kanter, med hörnen i moturs ordning.
Diagram: ytnormalen som kryssprodukten av två kanter, med hörnen i moturs ordning.

Backface culling

I ett slutet föremål är ungefär hälften av ytorna vända bort från ögat. De kan hoppas över. Testet är en skalärprodukt mellan normalen och vektorn från polygonens mittpunkt M till ögat E:

N · (E − M) > 0    →    framsida, rita
N · (E − M) ≤ 0    →    baksida, hoppa över

I ögats koordinater står ögat i origo, så originalet räknade N · (0 − M), med M som medelvärdet av de tre eller fyra första hörnen. Dagens trådmodell gör samma test i världskoordinater, med kamerans position som E.

Diagram: backface culling. Sidor vars normal pekar mot ögat ritas, de andra hoppas över.
Diagram: backface culling. Sidor vars normal pekar mot ögat ritas, de andra hoppas över.

Så här såg det ut 1998, med och utan culling:

Och i dag:

Culling räcker bara för ett enda konvext föremål. Hos hazard-modellen skymmer framsidor andra framsidor, och då måste ordningen också stämma.

Målaralgoritmen och z-bufferten

Originalet sorterade polygonerna efter det största djupet bland deras hörn och ritade dem bakifrån och fram, som en målare som målar förgrunden sist. Det är enkelt och fungerar för det mesta. Men två polygoner som skär varandra, eller tre som överlappar i en ring, har ingen ordning som stämmer.

Diagram: målaralgoritmen ritar polygonerna bakifrån och fram. Z-buffern behöver ingen sortering.
Diagram: målaralgoritmen ritar polygonerna bakifrån och fram. Z-buffern behöver ingen sortering.

Dagens version använder z-bufferten i stället: för varje pixel sparas djupet hos det som redan ritats, och en ny pixel ritas bara om den ligger närmare. Ingen sortering behövs, och skärande polygoner blir rätt.

Ljuset: Phongs modell

Bui Tuong Phong beskrev 1975 en ljusmodell som fortfarande är grunden i realtidsgrafik. Den delar ljuset i tre delar: ett omgivande ljus som lyser upp allt lika mycket, ett diffust ljus som beror på hur ytan är vänd mot ljuskällan, och en glans som beror på var betraktaren står.

Diagram: vektorerna i Phongs modell – normalen N, ljuset L, reflektionen R och betraktaren V, med vinklarna θ och α.
Diagram: vektorerna i Phongs modell – normalen N, ljuset L, reflektionen R och betraktaren V, med vinklarna θ och α.

Med alla vektorer normerade till längd ett:

cos θ = N · L            vinkeln mellan normalen och ljuset
R     = 2 (N · L) N − L  ljuset speglat i normalen
cos α = R · V            vinkeln mellan speglingen och ögat

Speglingen går att härleda. Dela upp L i en del längs normalen, (N · L) N, och en del längs ytan, L − (N · L) N. Spegling behåller delen längs normalen och vänder den längs ytan: R = (N · L) N − (L − (N · L) N) = 2 (N · L) N − L.

I originalet var ljuset per färgkanal:

I = Ia·Ka + Il · (Kd · cos θ + Ks · cosⁿ α)

Ia och Il är ljusets styrka (omgivande och direkt), Ka, Kd och Ks hur mycket materialet tar emot av varje sort, och n hur blank ytan är. Alla är vektorer med ett värde per kanal, rött, grönt och blått. Därför har skuggorna i trehjulingen överst en blå ton: det omgivande ljuset var satt till (0,3, 0,6, 1,0).

Exponenten n bestämmer glansfläckens storlek. Cosinus är 1 rakt i speglingen och faller mot 0 vid 90°. Upphöjt till en hög exponent faller det mycket snabbare:

Diagram: cos θ jämfört med cos⁸, cos³² och cos¹²⁸ – ju högre exponent, desto mindre och skarpare glansfläck.
Diagram: cos θ jämfört med cos⁸, cos³² och cos¹²⁸ – ju högre exponent, desto mindre och skarpare glansfläck.

Med n = 32, standard i dag, är glansen 0,61 av sitt största värde vid α = 10° och 0,14 vid 20°.

Ljusets riktning

Originalet tog ljusets riktning som en vektor (standard (1, 1, 5)) i ögats koordinater, så ljuset följde med kameran. Dagens version anger det som två vinklar, azimut runt den lodräta axeln och elevation över horisonten, och ljuset står still i världen när man vrider på modellen:

L = (cos el · cos az,  sin el,  cos el · sin az)

Vektorn har alltid längd ett, eftersom cos² el · (cos² az + sin² az) + sin² el = 1.

Diagram: ljusets riktning ur azimut och elevation.
Diagram: ljusets riktning ur azimut och elevation.

Räkneexempel med dagens standardvärden

Standardvärdena i 3D Lab är färgen #b3b3b3, ka = 0,25, kd = 0,75, ks = 0,5, n = 32, ia = 0,51, il = 0,8, ils = 0,5 (glansljusets styrka), az = 45° och el = 60°. Ta en yta som pekar rakt upp, N = (0, 1, 0).

L     = (cos 60° · cos 45°, sin 60°, cos 60° · sin 45°)
      = (0,354, 0,866, 0,354)
N · L = 0,866

omgivande = ka · ia      = 0,25 · 0,51         = 0,128
diffust   = kd · il · N·L = 0,75 · 0,8 · 0,866 = 0,520

Färgen måste först göras linjär. #b3 är 179 / 255 = 0,702 i sRGB, men sRGB är en kurva som sparar fler steg i det mörka. Ljus adderas i linjära värden:

linjär = ((0,702 + 0,055) / 1,055)^2,4 = 0,451

färg   = 0,451 · (0,128 + 0,520) = 0,292      (linjärt)
sRGB   = 1,055 · 0,292^(1/2,4) − 0,055 = 0,576  →  147 av 255

Utan glans blir ytan alltså #939393. Glansen läggs till i ljusets färg, vit:

R     = 2 · 0,866 · (0, 1, 0) − L = (−0,354, 0,866, −0,354)
glans = ils · ks · (R · V)^32 = 0,25 · cos³² α

α = 0°   →  0,250  →  194 av 255
α = 10°  →  0,153  →  178
α = 20°  →  0,034  →  155
α = 30°  →  0,003  →  148

Mitt i glansfläcken blir ytan #c2c2c2. Trettio grader bort syns den knappt.

Flat skuggning

Flat skuggning var labbens huvuduppgift: varje polygon får en enda färg, räknad med polygonens egen normal. Kanterna mellan ytorna syns, och modellen ser ut som den är byggd – av plana bitar. Det gör också flat skuggning till ett bra test av allt som kommer före: en polygon med fel hörnordning får en normal som pekar inåt och försvinner med culling, eller blir mörk utan den, och det syns direkt.

Så räknas färgen för en polygon

Dagens kod, funktionen bakeFlatColors, går igenom polygonerna i filen – inte trianglarna. För en polygon med hörnen v0, v1 … vk−1 räknas fyra vektorer:

C = (v0 + v1 + … + vk−1) / k          mittpunkten
N = norm((v1 − v0) × (v2 − v0))       normalen
V = norm(kameran − C)                 riktningen mot ögat
L = (cos el · cos az,  sin el,  cos el · sin az)

norm delar en vektor med sin längd. Hörnen räknas först om med modellens rotation, så N och C följer med när man vrider modellen, medan L står still i världen.

Sedan kommer Phongs ljusmodell. De två cosinusvärdena får inte bli negativa, för en yta som vänder sig bort från ljuset ska inte bli mörkare än det omgivande ljuset gör den:

d = max(N · L, 0)                     diffust
R = 2 d N − L                         L speglat i N
s = max(R · V, 0)ⁿ                    glans

färg = min( obj · (ka·ia + kd·il·d) + ljus · ils·ks·s , 1 )

Formeln gäller för varje kanal för sig, rött, grönt och blått. obj är materialets färg och ljus ljusets, båda linjära. Lägg märke till att glansen tar ljusets färg och inte materialets: en vit lampa ger en vit glansfläck också på en röd yta. min(…, 1) klämmer kanalen, så att en stark glans blir vit i stället för att slå runt.

Färgen skrivs sedan till alla trianglar som polygonen delades i. Varje triangel vet vilken polygon den kommer från (triToPoly), så en femhörning blir tre trianglar med exakt samma färg, och skarvarna mellan dem syns inte. För att det ska gå har den flat-skuggade modellen en egen kopia av geometrin där trianglarna inte delar hörn. Om två polygoner delade ett hörn skulle hörnet bara kunna ha en färg, och GPU:n skulle blanda färgerna över ytan.

Diagram: flat skuggning. Färgen räknas en gång i polygonens mittpunkt C, med normalen N, ljuset L och riktningen V mot kameran, och samma färg hamnar i alla polygonens trianglar. Grannpolygonen har en annan normal och får en annan färg.
Diagram: flat skuggning. Färgen räknas en gång i polygonens mittpunkt C, med normalen N, ljuset L och riktningen V mot kameran, och samma färg hamnar i alla polygonens trianglar. Grannpolygonen har en annan normal och får en annan färg.

Varför en färg räcker

Det är inte bara en förenkling. I en plan polygon är N densamma överallt. Ljuset är riktat, som från en avlägsen sol, så L är också densamma överallt. Då är det omgivande och det diffusa ljuset – ka·ia + kd·il·(N · L) – exakt lika i varje punkt på ytan, och en färg per polygon är det rätta svaret.

Det enda som ändras över ytan är V, och därmed glansen. Flat skuggning räknar glansen i mittpunkten och använder den för hela polygonen. På en stor yta kan en glansfläck därför tändas och släckas med en gång när man vrider modellen, i stället för att glida över ytan.

Där färgen hoppar

Mellan två polygoner byter N riktning, och då hoppar färgen. Ta en kub som inte är vriden, med dagens standardvärden:

ytan      N            N · L    linjärt   sRGB
topp      (0, 1, 0)    0,866    0,292     147  #939393
höger     (1, 0, 0)    0,354    0,153     109  #6d6d6d
fram      (0, 0, 1)    0,354    0,153     109  #6d6d6d
vänster   (−1, 0, 0)   0        0,058      68  #444444
botten    (0, −1, 0)   0        0,058      68  #444444

Toppen är räkneexemplet ovan. Höger- och framsidan blir lika ljusa, eftersom azimuten 45° lägger ljuset precis mitt emellan dem. Vänstersidan och botten får bara det omgivande ljuset, 0,128 · 0,451 = 0,058. Glansen är inte med i tabellen, eftersom den beror på var kameran står.

Varje bildruta

Färgerna räknas om i varje bildruta, före renderingen. Det är en beräkning per polygon på processorn – drygt 2 000 för den största modellen, hazard – och det räcker gott. Därför följer skuggningen med direkt när man drar i modellen, ändrar ljuset eller flyttar kameran.

1998

I originalet gick det till på samma sätt, men i ögats koordinater. Normalen var (v1 − v2) × (v3 − v2), mittpunkten medelvärdet av de tre eller fyra första hörnen, och eftersom ögat stod i origo var V = −C. Ljusets riktning angavs också i ögats koordinater, så ljuset följde med kameran. Get_Shade räknade tre värden mellan 0 och 1, de skalades till 0–255, och IRIS GL fyllde polygonen med den färgen. Polygonerna behövde aldrig delas i trianglar.

Felen jag hittade i koden från 1998

När Claude Code läste originalet inför det här inlägget hittade den tre fel i ljusfunktionen Get_Shade, och en svaghet i hur färgen avrundas:

  • R · V räknas fel. Raden är rx*vx + rx*vx + rx*vx – x-komponenten tre gånger, i stället för rx*vx + ry*vy + rz*vz. Glansen beror alltså bara på speglingens x-led.
  • Bara rött ljus. Det direkta ljuset multipliceras med il[1], den röda komponenten, i alla tre kanalerna. Il:s gröna och blå värden gör ingenting.
  • Speglingen räknas med onormerade vektorer. Cos θ delas korrekt med längderna, men R = 2 (N · L) N − L räknas med N och L som de är. Normalen är en kryssprodukt av kanter, och dess längd växer med ytans storlek.
  • Färger på 1 eller mer skrivs inte. En kanal skalas till 0–255 bara om värdet är under 1. Annars behåller den förra polygonens värde.

Det syns inte så mycket i skärmbilderna – det mesta av ljuset är diffust, och det räknades rätt. Dagens flat-läge räknar samma modell men utan felen: med normerade vektorer, alla tre komponenterna, max(0, …) på båda cosinusvärdena och färgen klämd till 1.

Samma labb i three.js

Dagens 3D Lab med panelen öppen: modell, renderingsläge, material, ljus och kamera. Modellen är enterprise.byu.
Dagens 3D Lab med panelen öppen: modell, renderingsläge, material, ljus och kamera. Modellen är enterprise.byu.

Claude Code översatte labben till en enda sida med three.js. Det här skiljer sig från originalet:

  • Kameran. I stället för att mata in F, A och U drar man i modellen. Ett drag blir en rotation runt en axel vinkelrät mot draget, med vinkeln proportionell mot dragets längd. Höger knapp flyttar och hjulet zoomar.
  • Modellen normaliseras. Varje modell flyttas så att mitten av dess omslutande sfär hamnar i origo och skalas till radien 1. Då passar alla modeller i bilden från början.
  • Z-buffert i stället för sortering. GPU:n avgör per pixel vad som ligger närmast.
  • Trianglar. Polygonerna delas i solfjädrar, men trådmodellen ritar bara de ursprungliga kanterna.
  • Ljuset står still i världen och anges med azimut och elevation.
  • Linjära färger. Ljuset räknas på linjära värden och görs om till sRGB på vägen ut. Originalet räknade direkt på värdena.

Nio modeller följer med: cube, sphere, enterprise, half, hazard, pyramide, seashell, seashell2 och tricycle. Fem av dem kommer från kursen: cube, enterprise, half, hazard och pyramide. Sphere och de två snäckorna är genererade i efterhand med små skript, och trehjulingen är en enklare ersättare – den mer detaljerade i skärmbilden från 1998 finns inte kvar. Man kan också släppa en egen .byu-fil på sidan.

Samma sak med three.js egna funktioner

Dagens 3D Lab räknar fortfarande en del själv – färgen för varje polygon och cullingen av trådmodellen – för att visa matematiken. Låter man three.js göra allt det kan blir samma sak drygt 50 rader. Det enda som saknas är formatet: three.js har ingen läsare för Movie.BYU, så den får man skriva själv.

import * as THREE from "three";
import { OrbitControls } from
  "three/addons/controls/OrbitControls.js";

// Movie.BYU: header, part ranges, x y z per vertex,
// then 1-based indices; a negative index ends a polygon.
function parseBYU(text) {
  const t = text.trim().split(/\s+/).map(Number);
  const [parts, nv, , nc] = t;
  let i = 4 + 2 * parts;
  const pos = t.slice(i, (i += 3 * nv));
  const idx = [];
  let poly = [];
  for (const v of t.slice(i, i + nc)) {
    poly.push(Math.abs(v) - 1);
    if (v > 0) continue;
    for (let k = 1; k < poly.length - 1; k++)
      idx.push(poly[0], poly[k], poly[k + 1]);
    poly = [];
  }
  const g = new THREE.BufferGeometry();
  g.setAttribute("position",
    new THREE.Float32BufferAttribute(pos, 3));
  g.setIndex(idx);
  return g;
}

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(
  45, innerWidth / innerHeight, 0.01, 100);
camera.position.set(0, 0, 3);

const renderer = new THREE.WebGLRenderer();
renderer.setSize(innerWidth, innerHeight);
document.body.append(renderer.domElement);
new OrbitControls(camera, renderer.domElement);

scene.add(new THREE.AmbientLight(0xffffff, 0.5));
const sun = new THREE.DirectionalLight(0xffffff, 2);
sun.position.set(1, 2, 1);
scene.add(sun);

const res = await fetch("hazard.byu");
const geo = parseBYU(await res.text());
geo.center();
geo.computeBoundingSphere();
const s = 1 / geo.boundingSphere.radius;
geo.scale(s, s, s);

scene.add(new THREE.Mesh(geo,
  new THREE.MeshPhongMaterial({
    color: 0xb3b3b3, flatShading: true })));

renderer.setAnimationLoop(() =>
  renderer.render(scene, camera));

Koden förutsätter att three och three/addons/ pekar ut three.js, till exempel med en import map, och att hazard.byu ligger bredvid sidan.

Resultatet av koden ovan: hazard.byu flat-skuggad med three.js egna funktioner, vriden med musen.
Resultatet av koden ovan: hazard.byu flat-skuggad med three.js egna funktioner, vriden med musen.

Det här tar three.js hand om, av det labben räknade för hand:

  • Kameran och perspektivet. PerspectiveCamera bygger projektionen ur synvinkeln, 45°, och OrbitControls flyttar kameran med musen. Inget F, A, U eller T = 2 · tan(v / 2).
  • Klippningen. GPU:n klipper mot synfältets sex sidor. Ingen Cohen–Sutherland.
  • Backface culling. Materialets side är THREE.FrontSide från början, så baksidorna ritas inte.
  • Synligheten. Z-bufferten är påslagen från början. Ingen sortering.
  • Normalen. Med flatShading: true räknas ytans normal fram i varje pixel ur skärmkoordinaterna, så inga normaler behöver räknas i förväg.
  • Ljuset. MeshPhongMaterial med AmbientLight och DirectionalLight ger omgivande ljus, diffust ljus och glans – glansen på Blinns sätt, med halvvektorn.
  • Färgerna. three.js räknar på linjära värden och gör om till sRGB på vägen ut.
  • Storleken. center() och den omslutande sfären ersätter normaliseringen.

Vill man ha en trådmodell utan triangulernas diagonaler räcker new THREE.EdgesGeometry(geo): den behåller bara kanter där ytorna möts i en vinkel.

Resultatet är nästan detsamma som flat-läget i 3D Lab, men inte helt. Normalen är densamma över hela polygonen, och med riktat ljus blir det omgivande och det diffusa ljuset därför samma – precis som i avsnittet om varför en färg räcker. Men ljuset räknas i varje pixel, så glansen kan glida över en stor yta i stället för att gälla hela polygonen. Och en polygon som inte är helt plan kan få olika ton i sina trianglar, där 3D Lab ger hela polygonen en färg.

Prova själv

3D Lab finns på burntokensrepeat.com/3d/lab. Välj en modell, växla mellan trådmodell och flat, slå av culling och se baksidorna komma fram, eller dra upp n och se glansfläcken krympa. Länkarna till källorna om Movie.BYU står bredvid inlägget.