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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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:

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.

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.

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örrx*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

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.

Det här tar three.js hand om, av det labben räknade för hand:
- Kameran och perspektivet.
PerspectiveCamerabygger projektionen ur synvinkeln, 45°, ochOrbitControlsflyttar 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ärTHREE.FrontSidefrån början, så baksidorna ritas inte. - Synligheten. Z-bufferten är påslagen från början. Ingen sortering.
- Normalen. Med
flatShading: trueräknas ytans normal fram i varje pixel ur skärmkoordinaterna, så inga normaler behöver räknas i förväg. - Ljuset.
MeshPhongMaterialmedAmbientLightochDirectionalLightger 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.
