Building a Footballer's Website as One Continuous 3D Shot
A Cycles-rendered scroll film, a three.js scene matched to it frame by frame, and what phones taught me
George Vorster plays on the wing for Burgess Hill Town and coaches children at Skills School in Surrey. He needed a website that a parent looking for a coach could find, that a club could check, and that felt like football rather than a CV. I built it as one continuous shot. You scroll, and the camera runs a ball down the left wing of a floodlit pitch, inside past four training mannequins and into the far corner of the net, with his story told alongside it. It's live at george-vorster-production.up.railway.app.
This is how it's made, and what it took to make it smooth on a phone.
Two pictures of the same pitch
I wanted it to look like night-time match photography. Real-time WebGL gets close, but grass under floodlights gives it away: the bounce light, the soft shadows from four towers, the way the blades catch the lamps. A path-traced video gets that right, but it's heavy and you can't touch it. So the site is both.
- The film. The run is path-traced in Blender's Cycles as 360 frames that scrub as you scroll. It's what you see first: the first picture arrives in about two seconds. On devices that can't run the live scene, it plays all the way through.
- The live scene. A three.js version built from the same Blender models, lit with light that Cycles baked, so the shadows, the bounce off the grass and the floods' colour are the path tracer's rather than a shader's guess. It's about 11 MB, and once it has downloaded it takes over from the film.
The whole ground is built from code. One Python script, build_scene.py, makes the turf, the grass blades, the goal and net, the mannequins, the cones, four floodlight towers of twelve area lights each, the stand, the hoardings and the fence. The scanned materials (the ball, the grass, the soil, the night sky) are CC0 from Poly Haven and ambientCG. Anything with no CC0 version I modelled from real dimensions: a 7.32 m by 2.44 m goal, a net of 3 mm cord on a 120 mm mesh, 1.75 m mannequins on spring stakes. I kept one rule throughout: nothing ships without a licence I can verify, and every asset is listed with its licence in the repo.
One source of truth for the camera
If the film and the live scene disagree by a frame, the handover jumps. So the camera, the ball and the net's give are defined once, in JavaScript, in run.js. A small script samples that into choreography.json, Blender reads it to keyframe the render, and the page's section timing and the minimap read the same path. Change a shot and everything follows.
The film renders on an AMD GPU through HIP at 128 samples, with OpenImageDenoise, AgX colour and real motion blur on the shot. It's packaged as WebP at 1080p, 720p and 480p. The player picks a tier from the screen size and connection, loads the first screen first, and streams the rest coarse to fine. Between frames it dissolves, except during the shot, where it cuts: those frames carry motion blur, and a dissolve would show two balls.
Making them match
Most of the work was getting the live scene to look like the film. I checked them side by side at fixed moments, with Puppeteer putting the live camera on a film frame and screenshotting it next to the Cycles render. Some of what that took:
- Light baked per tower, and the white balance measured from Blender's view transform instead of judged by eye. For a while the orange mannequins came out beige, because AgX treats strong colours differently from a simple tone curve. Running the same transform in the browser fixed it.
- Real grass blades near the lens, scattered in tufts the way the render scatters them, and Cycles-rendered tiles of blades further out. The near grass has parallax, and the far grass costs almost nothing.
- A net that bellies when the ball hits it, baked from a Blender shape key into a morph target, then wobbles out after the ball drops.
- A lens: depth of field, bloom, moving film grain and a vignette, matched to the film's.
- Compression: KTX2 textures and Draco meshes, so the first screen stays under 15 MB.
The camera was inside a mannequin
Frame 235 of the film was black. The camera path went straight through one of the mannequins, so for a frame the lens was inside it. That's easy to miss when you scrub past it at speed, and very obvious once you've seen it.
The fix lives in run.js: after the shot is computed, push the eye sideways past each mannequin. My first two attempts pushed it straight away from the mannequin, then along the path's normal. Both cleared it, but both jolted the camera, and I could measure the jolt as a spike in acceleration between frames. The version that shipped finds each mannequin's closest approach once, notes which way the path is heading there and which side it passes on, and moves the eye sideways along a bell curve about 2.5 m either side, fading the push once the camera is already clear. The camera now never comes within a metre of a mannequin. Only 99 frames moved by more than a centimetre, so only those had to be re-rendered.
The handover
The film is cropped differently on every screen (on a phone it crops around the ball), and the live scene has its own projection. When the live scene first took over, the shot visibly zoomed. Now the film player reports exactly which part of its frame is on screen, the live camera starts with that frustum, and it eases to its own over the next couple of seconds. On portrait phones the film is skipped entirely: the crop difference is largest there, and people who started scrolling straight away saw it stutter.
What phones taught me
On a desktop it ran smoothly from the start. On a phone, the first shots lagged, at ground level with the ball and through the keepy-uppies, until the "run so far" section, and then it was smooth. Profiling in phone emulation showed why: the early shots cost 6 to 7 ms a frame against about 4.5 ms in the higher shots. The grass blades were about 2.5 ms of that and depth of field about 1.9 ms. What helped:
- Phones start at a pixel ratio of 1.25 instead of 1.5, about 25% faster.
- They check their frame rate about every half second, and step down a quality ladder (resolution, then grass density, then depth of field) while you're still on the first screen.
- The depth-of-field blur takes 16 samples on phones instead of 32, and skips pixels that are already in focus.
- A real bug: depth of field needs a separate depth render, done with an override material. The override ignored the instancing, so every grass blade was drawn again, all piled up at the origin, for nothing. Leaving them out of that pass saved the cost.
One honest caveat: those numbers come from emulation on a desktop GPU. Real phones are the final test.
Keepy-uppies
On the first screen you can tap the ball and keep it up. It bounces and settles the way a football does on grass, and phones give a faint 8 ms knock when you strike it. The score springs up on every touch, glows every tenth, shows your best, and calls out a new one when you beat it. When it first appeared it pushed the hero text down a line, so the hint and the score now share one fixed space and swap with a fade.
Getting the facts right
A site about a real person has to be accurate. The football data sites had George's date of birth wrong, so it now comes from George's side, and his age is worked out from that date so it can't go stale. I checked every claim against the clubs' own pages and took out anything I couldn't source, including calling him the club's top scorer. Every word on the page lives in one content.js file, so George can change copy without touching the 3D code, and the README lists where each fact comes from.
Being findable
The page is drawn by JavaScript, which is fine for Google but not for every crawler or link preview. At build time a small Vite plugin reads the same content.js and writes the title, description and canonical link, Open Graph and Twitter cards with a share image, JSON-LD describing George as a Person on a ProfilePage, the page's words as plain HTML in <noscript>, and a robots.txt and sitemap.xml. Because it all comes from one file, the search snippet can't disagree with the page. It's the same idea as the prerendered metadata on this site.
Stack
Blender 5.3 and Cycles for the scene, renders and bakes, driven by Python scripts. three.js and Vite for the site. KTX2 and Draco for compression. Puppeteer for the side-by-side checks against the renders. Hosted on Railway, deploying on every push. Take a look at the site, or read the case study.
Tags: Joshua Fields, creative technologist, three.js, WebGL, Blender, Cycles, scroll animation, web performance, website design, London
Back to Writing | Joshua Fields Home | George Vorster Case Study | George Vorster's Website | Websites | GitHub | LinkedIn
Joshua Fields — full portfolio