A free, open-source framework for cinematic, interactive 3D websites with AI-generated assets (Nano Banana 2 + Meshy 7.1 on fal). 20 example sites.
import { Engine, THREE, normalize, prepModel, damp, clamp, smooth, lerp, studioEnvironment } from '../../src/core/engine.js';
import { Assets, BASE } from '../../src/core/assets.js';
import { Pointer } from '../../src/core/input.js';
import { smoothScroll, gsap, reveal } from '../../src/core/scroll.js';
import { preloader, cursor, magnetic, worldNav } from '../../src/core/ui.js';
import { PlanarReflection } from '../../src/core/reflector.js';
import { VolumetricSpotEffect } from '../../src/core/volumetric.js';
import { DepthOfFieldEffect, EffectPass } from 'postprocessing';
import { buildDeck, BANDS, L } from './deck.js';
import { buildRoom, WALL_Z, FLOOR_Y } from './room.js';
import { Deck, TRACKS } from './audio.js';
const Q = new URLSearchParams(location.search);
const $ = s => document.querySelector(s);
const $$ = s => [...document.querySelectorAll(s)];
const portrait = () => innerWidth / innerHeight < 0.85;
const coarse = matchMedia('(pointer: coarse)').matches;
if (Q.has('noui')) document.documentElement.classList.add('noui');
const fontsReady = Promise.race([
Promise.all([
document.fonts.load('800 88px "Syne"'), document.fonts.load('700 40px "Syne"'),
document.fonts.load('400 20px "Space Mono"'), document.fonts.load('700 20px "Space Mono"'),
document.fonts.load('400 300px "M PLUS Rounded 1c"', '低周波'),
]).catch(() => {}),
new Promise(r => setTimeout(r, 3000)),
]);
// ─── Engine & post ────────────────────────────────────────────────────────────
const canvas = $('#gl');
let vol;
const engine = new Engine({
canvas, fov: 34, near: 0.01, far: 30, dpr: 1.5, background: 0x07040a,
post: {
ao: Q.has('noao') ? false : { aoRadius: 0.12, intensity: 2.4, distanceFalloff: 0.22 },
bloom: { intensity: 0.85, luminanceThreshold: 0.78, luminanceSmoothing: 0.3, radius: 0.8 },
pre: cam => Q.has('novol') ? ((vol = { add() {} }), []) : [(vol = new VolumetricSpotEffect(cam, { density: 0.055, noise: 0.9, noiseScale: 3.4, maxDist: 7, floorY: FLOOR_Y, wind: new THREE.Vector3(0.03, 0.07, 0.01) }))],
tone: Q.get('tone') ?? 'aces',
vignette: { offset: 0.22, darkness: 0.82 },
noise: 0.07,
ca: 0.0013,
},
});
const { scene, camera, renderer } = engine;
const dof = new DepthOfFieldEffect(camera, { focusDistance: 0.55, focusRange: 0.18, bokehScale: 3, resolutionScale: 0.5 });
if (!Q.has('nodof')) {
const comp = engine.post.composer, i = comp.passes.indexOf(engine.post.ao);
comp.addPass(new EffectPass(camera, dof), i >= 0 ? i + 1 : 1);
}
scene.fog = new THREE.FogExp2(0x07040b, 0.08);
scene.environment = studioEnvironment(renderer, {
top: 0x1b1024, bottom: 0x040305, panels: [
{ pos: [0, 7, 1.5], size: [3, 2.2], intensity: 6, color: 0xffc27e },
{ pos: [0, 2.4, -7], size: [1.6, 4.5], intensity: 3.2, color: 0xa78bfa },
{ pos: [-7, 2, 3], size: [1.4, 4], intensity: 1.1, color: 0xff9a4d },
{ pos: [7, 3, 2], size: [1.2, 5], intensity: 1.4, color: 0x8e76ff },
{ pos: [0, 1, 8], size: [6, 1.2], intensity: 0.5, color: 0xffd9b0 },
],
});
scene.environmentIntensity = 0.24;
const hemi = new THREE.HemisphereLight(0x2c1b3e, 0x0a0508, 0.2);
scene.add(hemi);
// ─── Lights ───────────────────────────────────────────────────────────────────
const KEY_ON = 7.5;
const key = new THREE.SpotLight(0xffcf9e, 0, 3.6, 0.27, 0.7, 2);
key.castShadow = true;
key.shadow.mapSize.set(2048, 2048);
key.shadow.camera.near = 0.3; key.shadow.camera.far = 2.4;
key.shadow.bias = -0.00012; key.shadow.normalBias = 0.006; key.shadow.radius = 4;
scene.add(key, key.target);
vol.add(key, { scale: 0.28, range: 0.4, softness: 0.55 });
const counterSpots = [-1.5, 0, 1.5].map((x, i) => {
const s = new THREE.SpotLight(0xffbf80, 0, 3, 0.5, 0.7, 2);
s.position.set(x, 1.0, 1.12); s.target.position.set(x, 0, 1.12);
scene.add(s, s.target);
if (i !== 1) vol.add(s, { scale: 0.18, range: 0.6, softness: 0.6 });
return s;
});
const wallWash = new THREE.SpotLight(0xd6b8ff, 0, 4, 0.9, 0.9, 1.6);
wallWash.position.set(0, 2.35, 0.6); wallWash.target.position.set(0, 0.6, WALL_Z - 0.2);
scene.add(wallWash, wallWash.target);
const rim = new THREE.DirectionalLight(0xb9a3ff, 0);
rim.position.set(-1.2, 1.6, -2.4);
scene.add(rim, rim.target);
const streak = new THREE.SpotLight(0xd9ccff, 0, 3, 0.2, 0.8, 1.5);
scene.add(streak, streak.target);
const fill = new THREE.PointLight(0x8c6cff, 0, 5, 1.4);
fill.position.set(-0.8, 1.2, 1.6);
scene.add(fill);
const touch = new THREE.PointLight(0xcdb8ff, 0, 0.35, 2);
scene.add(touch);
const LIGHTS = { key: KEY_ON, counter: 1.5, wash: 1.1, rim: 0.55, fill: 0.5, streak: Q.has('nostreak') ? 0 : 0.9 };
// ─── Loading ──────────────────────────────────────────────────────────────────
const assets = new Assets();
const pointer = new Pointer({ lambda: 5 });
const loaderEl = $('.loader');
{
const g = loaderEl.querySelector('.ld-grooves');
for (let i = 0; i < 26; i++) {
const c = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
c.setAttribute('cx', 100); c.setAttribute('cy', 100); c.setAttribute('r', 94 - i * 2.35); c.style.opacity = 0;
g.appendChild(c);
}
}
const grooveEls = [...loaderEl.querySelectorAll('.ld-grooves circle')];
const loader = preloader({
assets, el: loaderEl, minTime: 1600,
onValue: v => {
loaderEl.querySelector('.loader-pct').textContent = String(Math.round(v * 100)).padStart(3, '0');
grooveEls.forEach((c, i) => { c.style.opacity = v * 26 > i ? 1 : 0.08; });
},
});
const texLoad = name => assets.texture(`img/lowfreq/${name}.webp`);
const COVER_NAMES = ['aubergine', 'tidal', 'counter', 'rain', 'valves', 'geometry'];
const loads = {
tt: assets.gltf('models/lowfreq/turntable.glb'),
sp: assets.gltf('models/lowfreq/speaker.glb'),
covers: Promise.all(COVER_NAMES.map(texLoad)),
};
// ─── State ────────────────────────────────────────────────────────────────────
const OMEGA = 2 * Math.PI * (100 / 3) / 60; // 33⅓ rpm in rad/s
const IDLE = 0.26;
const S = { playing: false, needle: false, track: 0, speed: 1, spin: 0, recAngle: 0, held: false, scratched: false, intro: 0, motor: false };
const arm = { yaw: 0, lift: 0.03 };
const audio = new Deck();
const woofer = { value: 0 };
let deck3, room, RC = new THREE.Vector3(), recR = 0.152, speakers = [];
const SPEC = new Float32Array(72);
const env = { bass: 0, mid: 0, high: 0, rms: 0, kick: 0 };
let fakeMix = 1;
// ─── Build the world ─────────────────────────────────────────────────────────
async function build() {
const [ttG, spG, covers] = await Promise.all([loads.tt, loads.sp, loads.covers]);
await fontsReady;
for (const c of covers) { c.anisotropy = renderer.capabilities.getMaxAnisotropy(); }
room = buildRoom(renderer, scene, { covers });
// Turntable
const tt = ttG.scene;
normalize(tt, 0.41);
prepModel(tt, renderer, { env: 0.9, onMat: m => { m.color.setRGB(0.62, 0.56, 0.54); } });
tt.position.x += 0.02;
scene.add(tt);
deck3 = buildDeck(renderer, tt, { tracks: TRACKS });
tt.updateMatrixWorld(true);
deck3.center(RC);
recR = deck3.radiusWorld();
arm.yaw = deck3.restYaw;
// Speakers (woofer cones pump with the kick)
const spk = spG.scene;
normalize(spk, 0.43, { axis: 'y' });
prepModel(spk, renderer, { env: 0.9, onMat: m => {
m.onBeforeCompile = sh => {
sh.uniforms.uWoof = woofer;
sh.vertexShader = sh.vertexShader.replace('#include <common>', '#include <common>\nuniform float uWoof;')
.replace('#include <begin_vertex>', `#include <begin_vertex>
{ float r = length(position.xy - vec2(0.0, -0.285)); float w = 1.0 - smoothstep(0.16, 0.37, r); w *= smoothstep(0.35, 0.5, position.z);
transformed.z += uWoof * w * 0.055; }`);
};
} });
for (const [x, ry] of [[-0.87, 0.28], [0.88, -0.28]]) {
const g = new THREE.Group(); g.add(x < 0 ? spk : spk.clone());
g.position.set(x, 0.006, -0.1); g.rotation.y = ry;
scene.add(g); speakers.push(g);
const pad = new THREE.Mesh(new THREE.CylinderGeometry(0.02, 0.02, 0.006, 16), new THREE.MeshStandardMaterial({ color: 0x111, roughness: 0.6 }));
for (const [px, pz] of [[-0.08, -0.1], [0.08, -0.1], [-0.08, 0.1], [0.08, 0.1]]) { const p = pad.clone(); p.position.set(px, -0.003, pz); g.add(p); }
}
// Key light hangs in the deck pendant, aimed at the record.
key.position.copy(room.keyPendant.position).add(new THREE.Vector3(0, -0.02, 0));
key.target.position.copy(RC).add(new THREE.Vector3(0.03, 0, -0.035));
rim.target.position.copy(RC);
// a low lavender practical behind the deck: its reflection draws the radial streak across the vinyl
streak.position.copy(RC).add(new THREE.Vector3(-0.55, 0.3, -1.05));
streak.target.position.copy(RC);
// Glossy back counter reflects the deck, the valves and the halo.
const refl = new PlanarReflection(renderer, { resolution: 0.5 });
const topMat = room.counterTopMat.clone();
room.reflectFloor.material = topMat;
refl.hidden.push(room.reflectFloor);
refl.patch(topMat, { strength: 1.1, distort: 0.006, lodScale: 5.5, lodBias: 0.25, f0: 0.05 });
engine.onResize((w, h, dpr) => refl.setSize(w, h, dpr));
reflection = refl;
// Band markers: a lavender wash over the grooves of the band a cue will land on
bandMarkers = BANDS.map(b => {
const m = new THREE.Mesh(new THREE.RingGeometry(b.inner, b.outer, 192, 1).rotateX(-Math.PI / 2),
new THREE.MeshBasicMaterial({ color: new THREE.Color(0xa78bfa).multiplyScalar(0.55), transparent: true, opacity: 0, blending: THREE.AdditiveBlending, depthWrite: false, toneMapped: false }));
m.position.set(L.cx, L.top + 0.0035, L.cz);
deck3.mesh.add(m);
return m;
});
makeDust();
makeTrail();
defineShots();
}
let bandMarkers = [], reflection;
// ─── Dust in the beam ─────────────────────────────────────────────────────────
let dust;
function makeDust(N = 1400) {
const pos = new Float32Array(N * 3), seed = new Float32Array(N);
for (let i = 0; i < N; i++) {
const a = Math.random() * Math.PI * 2, r = Math.sqrt(Math.random()) * 0.5;
pos[i * 3] = RC.x + Math.cos(a) * r; pos[i * 3 + 1] = 0.03 + Math.random() * 1.0; pos[i * 3 + 2] = RC.z + Math.sin(a) * r;
seed[i] = Math.random();
}
const geo = new THREE.BufferGeometry();
geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
geo.setAttribute('seed', new THREE.BufferAttribute(seed, 1));
const mat = new THREE.ShaderMaterial({
transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
uniforms: { uTime: { value: 0 }, uLPos: { value: new THREE.Vector3() }, uLDir: { value: new THREE.Vector3(0, -1, 0) }, uCos: { value: 0.93 },
uPow: { value: 0 }, uKick: { value: 0 }, uEnergy: { value: 0 }, uDpr: { value: 1 }, uAxis: { value: new THREE.Vector3() } },
vertexShader: /* glsl */`
attribute float seed; uniform float uTime, uCos, uPow, uKick, uEnergy, uDpr; uniform vec3 uLPos, uLDir, uAxis; varying float vA;
void main(){
vec3 p = position;
float t = uTime * (0.03 + seed * 0.05) * (1.0 + uEnergy * 2.5);
p += vec3(sin(t * 3.1 + seed * 40.), sin(t * 2.3 + seed * 13.) * 0.5 + t * 0.06, cos(t * 2.7 + seed * 27.)) * 0.12;
p.y = mod(p.y - 0.03, 1.0) + 0.03;
vec2 rad = p.xz - uAxis.xz;
p.xz += normalize(rad + 1e-4) * uKick * 0.018 * seed;
p.y += uKick * 0.012 * (seed - 0.3);
vec3 d = p - uLPos; float dist = length(d);
float cone = smoothstep(uCos, uCos + 0.04, dot(d / dist, uLDir));
float tw = 0.55 + 0.45 * sin(uTime * (1.5 + seed * 5.0) + seed * 60.0);
vA = cone * uPow * tw * (0.35 + 0.65 * fract(seed * 91.7)) * (1.0 + uKick * 1.5);
vec4 mv = modelViewMatrix * vec4(p, 1.);
gl_Position = projectionMatrix * mv;
gl_PointSize = (0.6 + seed * 1.3) * uDpr * (0.5 / -mv.z);
}`,
fragmentShader: /* glsl */`varying float vA; void main(){ float d = length(gl_PointCoord - .5); float a = smoothstep(.5, .0, d); gl_FragColor = vec4(vec3(1.0, .82, .6) * a * vA * 1.6, 1.); }`,
});
const pts = new THREE.Points(geo, mat);
pts.frustumCulled = false;
scene.add(pts);
engine.onResize((w, h, dpr) => { mat.uniforms.uDpr.value = dpr; });
dust = mat;
}
// ─── Scratch comet: glowing points that follow the hand across the vinyl ─────
let trail;
function makeTrail(N = 900) {
const pos = new Float32Array(N * 3), born = new Float32Array(N).fill(-99), heat = new Float32Array(N);
const geo = new THREE.BufferGeometry();
geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
geo.setAttribute('born', new THREE.BufferAttribute(born, 1));
geo.setAttribute('heat', new THREE.BufferAttribute(heat, 1));
const mat = new THREE.ShaderMaterial({
transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, toneMapped: false,
uniforms: { uTime: { value: 0 }, uDpr: { value: 1 }, uA: { value: new THREE.Color(0xa78bfa) }, uB: { value: new THREE.Color(0xffb45c) } },
vertexShader: /* glsl */`
attribute float born, heat; uniform float uTime, uDpr; varying float vA, vH;
void main(){
float age = uTime - born;
vA = exp(-age * 0.95) * step(0.0, age);
vH = heat;
vec4 mv = modelViewMatrix * vec4(position + vec3(0.0, age * 0.012, 0.0), 1.0);
gl_Position = projectionMatrix * mv;
gl_PointSize = uDpr * (9.0 + 26.0 * vA) * (0.35 / -mv.z) * (0.75 + heat * 0.5);
}`,
fragmentShader: /* glsl */`
uniform vec3 uA, uB; varying float vA, vH;
void main(){ float d = length(gl_PointCoord - 0.5); float core = smoothstep(0.5, 0.0, d); float hot = smoothstep(0.18, 0.0, d);
vec3 c = mix(uA, uB, clamp(vH, 0.0, 1.0));
gl_FragColor = vec4((c * core * core * 3.2 + vec3(1.0, 0.95, 0.9) * hot * 2.2) * vA, 1.0); }`,
});
const pts = new THREE.Points(geo, mat);
pts.frustumCulled = false; pts.renderOrder = 7;
scene.add(pts);
engine.onResize((w, h, dpr) => { mat.uniforms.uDpr.value = dpr; });
let head = 0; const last = new THREE.Vector3(); let has = false;
const emit = (p, t, h) => { pos.set([p.x, p.y, p.z], head * 3); born[head] = t; heat[head] = h; head = (head + 1) % N; };
trail = {
update(dt, t, hand, speed) {
mat.uniforms.uTime.value = t;
if (!hand) { has = false; return; }
const p = _p4.copy(hand); p.y = RC.y + 0.006;
if (!has) { last.copy(p); has = true; emit(p, t, speed / 2.5); }
const d = last.distanceTo(p), steps = Math.min(24, Math.floor(d / 0.0016));
for (let k = 1; k <= steps; k++) emit(_p3.lerpVectors(last, p, k / steps), t - (1 - k / steps) * dt, Math.min(1.2, speed / 2.5));
if (steps) last.copy(p);
geo.attributes.position.needsUpdate = geo.attributes.born.needsUpdate = geo.attributes.heat.needsUpdate = true;
},
};
}
// ─── Camera shots ─────────────────────────────────────────────────────────────
const K = {};
const INTRO = { pos: new THREE.Vector3(0.35, 1.25, 2.9), look: new THREE.Vector3(0, 0.25, -0.2), fov: 40 };
function defineShots() {
const v = (x, y, z) => new THREE.Vector3(x, y, z);
const r = (x, y, z) => RC.clone().add(v(x, y, z));
const woof = speakers[1].localToWorld(v(0, 0.12, 0.1));
K.hero = { pos: r(0.43, 0.17, 0.5), look: r(-0.2, 0.01, -0.06), fov: 33, focus: r(0.02, 0, 0.05), range: 0.16, bokeh: 3.4, par: 1,
m: { pos: r(0.03, 0.5, 0.52), look: r(0.0, -0.2, 0.12), fov: 46 } };
K.press = { pos: r(0.22, 0.8, 0.14), look: r(0.22, 0, 0.0), fov: 33, focus: r(0, 0, 0), range: 0.32, bokeh: 1.4, par: 0.35, key: 0.55,
m: { pos: r(0.0, 0.7, 0.4), look: r(0.0, 0, 0.13), fov: 44 } };
K.bar = { pos: v(2.25, 1.1, 3.7), look: v(0.72, 0.22, 0.1), fov: 38, focus: v(0.0, 0.2, 0.0), range: 2.2, bokeh: 1.4, par: 1, streak: 0.15,
m: { pos: v(0.4, 0.9, 3.9), look: v(0.0, 0.2, -0.2), fov: 52 } };
K.cat = { pos: v(-1.45, 0.92, 0.78), look: v(-1.7, 0.86, WALL_Z), fov: 38, focus: v(-1.7, 0.92, WALL_Z), range: 0.9, bokeh: 1.3, drift: v(1.1, 0.0, 0), par: 0.5,
m: { pos: v(-1.2, 0.92, 0.72), look: v(-1.35, 0.86, WALL_Z), fov: 52 } };
K.club = { pos: v(0.46, 0.2, 0.62), look: v(0.9, 0.16, -0.12), fov: 35, focus: woof, range: 0.28, bokeh: 3, par: 1,
m: { pos: v(0.62, 0.3, 0.95), look: v(0.8, 0.14, -0.1), fov: 46 } };
K.end = { pos: r(-0.36, 0.045, 0.19), look: r(0.09, 0.012, -0.03), fov: 30, focus: r(-0.03, 0.0, 0.03), range: 0.3, bokeh: 2.6, par: 0.6,
m: { pos: r(-0.28, 0.12, 0.34), look: r(0.03, 0.0, -0.02), fov: 42 } };
}
const SECTIONS = $$('[data-cam]');
let ranges = [];
function measure() {
const vh = innerHeight, max = document.documentElement.scrollHeight - vh;
ranges = SECTIONS.map(el => {
let a = el.offsetTop - vh * 0.25, b = el.offsetTop + el.offsetHeight - vh * 0.75;
if (b < a) a = b = (a + b) / 2;
return { a: clamp(a, 0, max), b: clamp(b, 0, max) };
});
ranges[0].a = 0; ranges[ranges.length - 1].b = max;
}
addEventListener('resize', measure);
new ResizeObserver(measure).observe(document.body);
const shot = { pos: new THREE.Vector3(), look: new THREE.Vector3(), fov: 34, focus: new THREE.Vector3(), range: 0.2, bokeh: 3, par: 1, key: 1, streak: 1 };
const _a = new THREE.Vector3(), _b = new THREE.Vector3(), _c = new THREE.Vector3(), _d = new THREE.Vector3();
let secIdx = 0, secBlend = 0;
function kf(k, idx, y, pm, oPos, oLook) {
const P = pm && k.m ? k.m : k;
oPos.copy(P.pos); oLook.copy(P.look);
if (k.drift) {
const R = ranges[idx], u = clamp((y - R.a) / Math.max(1, R.b - R.a)) - 0.5;
oPos.addScaledVector(k.drift, u * (pm ? 0.5 : 1)); oLook.addScaledVector(k.drift, u * (pm ? 0.5 : 1));
}
return P;
}
function shotAt(y, out) {
let i = 0;
while (i < ranges.length - 1 && y > ranges[i].b) i++;
// inside a hold range -> that shot; between ranges -> eased blend from the previous one
let ia, ib, e;
if (y >= ranges[i].a || i === 0) { ia = ib = i; e = 0; }
else { ia = i - 1; ib = i; e = smooth(0, 1, (y - ranges[ia].b) / Math.max(1, ranges[ib].a - ranges[ia].b)); }
const A = K[SECTIONS[ia].dataset.cam], B = K[SECTIONS[ib].dataset.cam];
const pm = portrait();
const PA = kf(A, ia, y, pm, _a, _c), PB = kf(B, ib, y, pm, _b, _d);
out.pos.lerpVectors(_a, _b, e);
out.look.lerpVectors(_c, _d, e);
out.pos.y += Math.sin(e * Math.PI) * 0.08;
out.fov = lerp(PA.fov, PB.fov, e);
out.focus.lerpVectors(A.focus, B.focus, e);
out.range = lerp(A.range, B.range, e);
out.bokeh = lerp(A.bokeh, B.bokeh, e);
out.par = lerp(A.par, B.par, e);
out.key = lerp(A.key ?? 1, B.key ?? 1, e);
out.streak = lerp(A.streak ?? 1, B.streak ?? 1, e);
secIdx = e < 0.5 ? ia : ib; secBlend = ia === ib ? 0 : e;
return out;
}
// ─── Playback control ─────────────────────────────────────────────────────────
const toastEl = $('.toast');
let toastT;
function toast(msg, ms = 2600) { toastEl.textContent = msg; toastEl.classList.add('on'); clearTimeout(toastT); toastT = setTimeout(() => toastEl.classList.remove('on'), ms); }
let armTl = null, cueToken = 0;
const trackReady = i => new Promise(res => { const k = () => (audio.fwd[i] ? res() : setTimeout(k, 60)); k(); });
function soundOn() {
audio.unlock();
const b = $('.sound');
if (!audio.muted) { b.setAttribute('aria-pressed', 'true'); b.querySelector('.sound-label').textContent = 'Sound on'; }
}
async function play(i = S.track, { quick = false } = {}) {
soundOn();
const token = ++cueToken;
S.playing = true; S.track = i;
updateUI();
if (!audio.fwd[i]) { $$('.tracks li')[i]?.classList.add('wait'); toast(`Pressing ${TRACKS[i].id} — one moment`); await trackReady(i); $$('.tracks li')[i]?.classList.remove('wait'); }
if (token !== cueToken) return;
if (S.needle) { S.needle = false; audio.needleLift(); }
armTl?.kill();
armTl = gsap.timeline()
.to(arm, { lift: 0.09, duration: quick ? 0.18 : 0.32, ease: 'power2.out' })
.to(arm, { yaw: deck3.bandYaw[i], duration: quick ? 0.55 : 1.15, ease: 'power2.inOut' })
.to(arm, { lift: 0, duration: quick ? 0.25 : 0.55, ease: 'power2.in', onComplete: () => {
if (token !== cueToken) return;
audio.cue(i); S.needle = true; audio.needleDrop(); dropPulse = 1;
} });
}
function pause() {
const token = ++cueToken;
S.playing = false;
updateUI();
// brake with the needle still down (the platter winds down), then lift and park
armTl?.kill();
armTl = gsap.timeline({ delay: S.needle ? 1.25 : 0 })
.add(() => { if (token !== cueToken) return; if (S.needle) audio.needleLift(); S.needle = false; })
.to(arm, { lift: 0.09, duration: 0.3, ease: 'power2.out' })
.to(arm, { yaw: deck3.restYaw, duration: 1.1, ease: 'power2.inOut' })
.to(arm, { lift: 0.03, duration: 0.4, ease: 'power2.in' });
}
let dropPulse = 0;
function updateUI() {
document.body.classList.toggle('is-playing', S.playing);
$$('.tracks li').forEach((li, k) => li.classList.toggle('on', S.playing && k === S.track));
const t = TRACKS[S.track];
$('.np-t').textContent = `${t.id} · ${t.title}`;
$('.play-main .pl').textContent = S.playing ? 'Lift the needle' : 'Drop the needle';
$('.pp').setAttribute('aria-label', S.playing ? 'Pause' : 'Play');
$('.bpm-read').textContent = `${Math.round(t.bpm * S.speed)} bpm`;
document.documentElement.style.setProperty('--spin-state', S.playing ? 'running' : 'paused');
}
const togglePlay = () => (S.playing ? pause() : play(S.track));
$('.play-main').addEventListener('click', togglePlay);
$('.pp').addEventListener('click', togglePlay);
$('.sound').addEventListener('click', () => {
const b = $('.sound');
if (!audio.ctx) { audio.unlock(); audio.setMuted(false); }
else audio.setMuted(!audio.muted);
const on = !audio.muted;
b.setAttribute('aria-pressed', String(on));
b.querySelector('.sound-label').textContent = on ? 'Sound on' : 'Sound off';
if (on && !S.playing) toast('Sound is on — drop the needle or put your hand on the record');
});
$$('.rpm button').forEach(b => b.addEventListener('click', () => {
$$('.rpm button').forEach(x => x.classList.toggle('on', x === b));
S.speed = +b.dataset.rpm;
$('.rpm-read').textContent = S.speed > 1 ? '45 rpm' : '33⅓ rpm';
updateUI();
}));
$$('.tracks li').forEach((li, k) => {
li.addEventListener('click', () => play(k));
li.addEventListener('pointerenter', () => { hoverTrack = k; });
li.addEventListener('pointerleave', () => { if (hoverTrack === k) hoverTrack = -1; });
});
let hoverTrack = -1;
// ─── Scratching ───────────────────────────────────────────────────────────────
const scratchEl = $('.scratch');
const hintEl = $('.hint'), chipEl = $('.hint-chip');
const ray = new THREE.Raycaster();
const plane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0);
const ndc = new THREE.Vector2(), hitP = new THREE.Vector3();
function hitRecord(cx, cy) {
ndc.set(cx / innerWidth * 2 - 1, -(cy / innerHeight) * 2 + 1);
ray.setFromCamera(ndc, camera);
plane.constant = -RC.y;
if (!ray.ray.intersectPlane(plane, hitP)) return null;
const dx = hitP.x - RC.x, dz = hitP.z - RC.z;
return { r: Math.hypot(dx, dz), phi: Math.atan2(-dz, dx), p: hitP };
}
const grab = { phi: 0, acc: 0, rec0: 0, target: 0, hover: false, world: new THREE.Vector3() };
scratchEl.addEventListener('pointerdown', e => {
const h = hitRecord(e.clientX, e.clientY);
if (!h || h.r > recR * 1.06) return;
e.preventDefault();
scratchEl.setPointerCapture(e.pointerId);
S.held = true;
grab.phi = h.phi; grab.acc = 0; grab.rec0 = S.recAngle; grab.target = S.recAngle; grab.world.copy(h.p);
if (!S.playing) play(S.track, { quick: true });
else soundOn();
if (!S.scratched) { S.scratched = true; hintEl.classList.remove('on'); chipEl.classList.remove('on'); }
document.body.classList.add('is-scratching');
});
scratchEl.addEventListener('pointermove', e => {
const h = hitRecord(e.clientX, e.clientY);
grab.hover = !!h && h.r < recR * 1.04;
if (h) { touch.position.set(h.p.x, RC.y + 0.035, h.p.z); grab.world.copy(h.p); }
if (!S.held || !h) return;
if (h.r < recR * 0.12) { grab.phi = h.phi; return; } // dead zone at the spindle
let d = h.phi - grab.phi;
d = Math.atan2(Math.sin(d), Math.cos(d));
grab.phi = h.phi; grab.acc += d;
grab.target = grab.rec0 + grab.acc;
});
const release = () => { if (!S.held) return; S.held = false; document.body.classList.remove('is-scratching'); cur?.set(grab.hover ? 'drag' : '', grab.hover ? 'Scratch' : ''); };
scratchEl.addEventListener('pointerup', release);
scratchEl.addEventListener('pointercancel', release);
scratchEl.addEventListener('pointerleave', () => { grab.hover = false; });
addEventListener('pointerup', release);
// ─── Projection helpers ───────────────────────────────────────────────────────
const proj = (p, out = new THREE.Vector3()) => { out.copy(p).project(camera); out.x = (out.x + 1) / 2 * innerWidth; out.y = (1 - out.y) / 2 * innerHeight; return out; };
const _p0 = new THREE.Vector3(), _p1 = new THREE.Vector3(), _p2 = new THREE.Vector3(), _p3 = new THREE.Vector3(), _p4 = new THREE.Vector3();
const leader = $('.leader'), leaderPath = leader.querySelector('path'), leaderDot = leader.querySelector('circle');
// ─── Fake spectrum for the silent state ──────────────────────────────────────
function fakeSpectrum(out, t) {
const beat = t * 118 / 60, ph = beat % 1;
const kick = Math.exp(-ph * 6.5), hat = Math.exp(-((beat + 0.5) % 1) * 9), bar = Math.floor(beat / 4);
const chord = 0.5 + 0.5 * Math.sin(t * 0.8 + bar);
for (let i = 0; i < out.length; i++) {
const f = i / (out.length - 1);
out[i] = 0.06 + 0.05 * (0.5 + 0.5 * Math.sin(t * 2.1 + i * 0.9) * Math.sin(t * 1.3 + i * 0.37))
+ kick * 0.62 * Math.exp(-f * 7) + hat * 0.32 * smooth(0.62, 0.95, f)
+ chord * 0.22 * Math.exp(-((f - 0.38) ** 2) / 0.015) + 0.1 * Math.exp(-((f - 0.2) ** 2) / 0.004) * (0.5 + 0.5 * Math.sin(t * 3 + 1));
}
return { bass: kick * 0.75, mid: 0.2 + chord * 0.2, high: hat * 0.5, rms: 0.12 + kick * 0.12 };
}
// ─── Frame ────────────────────────────────────────────────────────────────────
const camPos = new THREE.Vector3(), camLook = new THREE.Vector3(), tmp = new THREE.Vector3();
let tubeWarm = 0, neonOn = 0, lightsOn = 0, heroFade = 1, lastRec = 0;
const vuState = { v: 0 };
const heroEl = $('.hero');
function tick(dt, t) {
pointer.update(dt);
// Camera: scroll shot, intro blend, hand-held drift, parallax
shotAt(window.__lenis?.animatedScroll ?? scrollY, shot);
const ie = S.intro;
camPos.lerpVectors(INTRO.pos, shot.pos, ie); camLook.lerpVectors(INTRO.look, shot.look, ie);
const par = shot.par * (coarse ? 0.3 : 1);
tmp.subVectors(camLook, camPos).normalize();
const right = _p4.crossVectors(tmp, camera.up).normalize();
const dist = camPos.distanceTo(camLook);
camPos.addScaledVector(right, (pointer.sx * 0.028 + Math.sin(t * 0.29) * 0.004) * par * dist);
camPos.y += (pointer.sy * 0.018 + Math.sin(t * 0.41) * 0.003) * par * dist;
camera.position.copy(camPos);
camera.lookAt(camLook);
const fov = lerp(INTRO.fov, shot.fov, ie);
if (Math.abs(camera.fov - fov) > 0.01) { camera.fov = fov; camera.updateProjectionMatrix(); }
dof.cocMaterial.focusDistance = camera.position.distanceTo(shot.focus);
dof.cocMaterial.focusRange = shot.range;
dof.bokehScale = shot.bokeh;
// Platter: motor, hand, speed
const target = (S.playing ? OMEGA * S.speed : OMEGA * IDLE) * (S.motor ? 1 : 0);
if (S.held) {
const prev = S.recAngle;
S.recAngle = damp(S.recAngle, grab.target, 38, dt);
const raw = -(S.recAngle - prev) / Math.max(dt, 1e-4);
S.spin = damp(S.spin, raw, 28, dt);
} else {
const up = target > S.spin;
S.spin = damp(S.spin, target, up ? (S.playing ? 3.2 : 2) : (S.playing ? 2.4 : 1.25), dt);
S.recAngle -= S.spin * dt;
}
if (deck3) {
deck3.record.rotation.y = S.recAngle;
trail?.update(dt, t, S.held ? grab.world : null, Math.abs(S.spin) / OMEGA);
if (S.held && cur) cur.set('drag', `${S.spin < -0.05 ? '◀' : '▶'} ${Math.abs(S.spin / OMEGA).toFixed(1)}×`);
const wob = S.needle ? Math.sin(S.recAngle) * 0.0035 : 0;
deck3.setArm(arm.yaw + wob, arm.lift);
}
const rate = S.spin / OMEGA;
audio.update(rate, S.needle);
// Spectrum: real when the needle is in the groove, a believable fake otherwise
let live = false;
if (audio.ready && S.needle) live = audio.spectrum(SPEC);
fakeMix = damp(fakeMix, live ? 0 : 1, 3, dt);
let lv = audio.levels;
if (fakeMix > 0.01) {
const FK = fakeSpectrum(fakeSpec, t);
const k = fakeMix * (S.playing ? 1 : 0.8);
for (let i = 0; i < SPEC.length; i++) SPEC[i] = lerp(live ? SPEC[i] : 0, fakeSpec[i] * 0.85, k);
lv = { bass: lerp(live ? audio.levels.bass : 0, FK.bass, k), mid: lerp(live ? audio.levels.mid : 0, FK.mid, k), high: lerp(live ? audio.levels.high : 0, FK.high, k), rms: lerp(live ? audio.levels.rms * 3 : 0, FK.rms, k) };
} else lv = { ...audio.levels, rms: audio.levels.rms * 3 };
env.bass = lv.bass > env.bass ? lerp(env.bass, lv.bass, 0.6) : damp(env.bass, lv.bass, 9, dt);
env.mid = damp(env.mid, lv.mid, 6, dt); env.high = damp(env.high, lv.high, 10, dt);
env.rms = damp(env.rms, lv.rms, 5, dt);
const kickNow = Math.max(0, lv.bass - 0.35) / 0.65;
env.kick = Math.max(kickNow, env.kick * Math.exp(-dt * 7));
if (deck3) {
const ring = deck3.ring, N = ring.N;
for (let i = 0; i < N; i++) {
// lows face the camera side (front), highs run round to the back
const a = i / N * Math.PI * 2;
const dA = Math.abs(Math.atan2(Math.sin(a + Math.PI / 2), Math.cos(a + Math.PI / 2))) / Math.PI;
const b = Math.min(SPEC.length - 1, Math.floor(dA * (SPEC.length - 1)));
const v = SPEC[b] * (0.75 + 0.25 * Math.sin(a * 3 + t * 0.6));
ring.amp[i] = v > ring.amp[i] ? lerp(ring.amp[i], v, 0.6) : damp(ring.amp[i], v, 7, dt);
}
ring.tex.needsUpdate = true;
dropPulse = damp(dropPulse, 0, 2.5, dt);
ring.mat.uniforms.uI.value = (0.42 + env.rms * 0.45 + dropPulse * 1.2 + (S.held ? 0.25 : 0)) * lightsOn;
ring.circ.material.opacity = (0.35 + env.bass * 0.5 + dropPulse) * lightsOn;
// cue marker + leader
const show = hoverTrack >= 0 ? hoverTrack : (S.playing && secIdx === 1 ? S.track : -1);
bandMarkers.forEach((m, k) => { m.material.opacity = damp(m.material.opacity, k === show && secIdx === 1 ? (hoverTrack === k ? 0.55 : 0.28) : 0, 7, dt); });
const leaderOn = show >= 0 && secIdx === 1 && secBlend < 0.05 && !portrait();
leader.classList.toggle('on', leaderOn);
if (leaderOn) {
const li = $$('.tracks li')[show].getBoundingClientRect();
const b = BANDS[show], mid = (b.outer + b.inner) / 2;
const w = proj(deck3.toWorld(L.cx + mid * 0.94, L.top, L.cz + mid * 0.34, _p3), _p3);
const x0 = li.left - 8, y0 = li.top + li.height / 2;
leaderPath.setAttribute('d', `M${x0},${y0} L${x0 - 36},${y0} L${w.x.toFixed(1)},${w.y.toFixed(1)}`);
leaderDot.setAttribute('cx', w.x.toFixed(1)); leaderDot.setAttribute('cy', w.y.toFixed(1));
}
}
// Room reacts
woofer.value = env.bass * 0.8 + env.kick * 0.6 + (S.held ? Math.min(1, Math.abs(rate - 1)) * 0.15 * Math.sin(t * 60) : 0);
const breathe = 1 + env.rms * 0.35 + env.kick * 0.08;
key.intensity = LIGHTS.key * lerp(1, shot.key, S.intro) * lightsOn * (1 + Math.sin(t * 37) * Math.sin(t * 13.7) * 0.012) * (0.97 + env.kick * 0.05);
counterSpots.forEach(s => { s.intensity = LIGHTS.counter * lightsOn; });
wallWash.intensity = LIGHTS.wash * lightsOn * breathe;
rim.intensity = LIGHTS.rim * lightsOn;
streak.intensity = LIGHTS.streak * lightsOn * (0.9 + env.mid * 0.3) * shot.streak;
fill.intensity = LIGHTS.fill * lightsOn * (0.4 + env.mid * 1.0 + env.kick * 0.4);
hemi.intensity = 0.2 * (0.8 + env.rms * 0.4) * (0.3 + lightsOn * 0.7);
touch.intensity = damp(touch.intensity, (grab.hover || S.held) && !coarse ? (S.held ? 0.03 : 0.018) : 0, 8, dt);
if (room) {
const n = room.neon;
const buzz = neonOn * (0.94 + 0.06 * Math.sin(t * 120) * Math.sin(t * 7.3) + env.kick * 0.12);
n.mat.color.copy(n.base).multiplyScalar(buzz);
n.halo.opacity = neonOn * (0.8 + env.bass * 0.4);
n.light.intensity = 1.3 * buzz * (0.8 + env.mid * 0.6);
for (const tb of room.tubes) {
const f = tubeWarm * (0.9 + 0.1 * Math.sin(t * (3 + tb.phase) + tb.phase) + env.rms * 0.35);
tb.fil.color.copy(tb.base).multiplyScalar(f);
tb.glow.opacity = 0.4 * f;
}
room.ampLight.intensity = 0.28 * tubeWarm * (1 + env.rms * 0.6);
room.shelfGlow.value = lightsOn * (0.8 + env.rms * 0.5 + env.kick * 0.12);
room.ledMat.color.copy(room.ledBase).multiplyScalar(lightsOn * (0.9 + env.kick * 0.25));
vuState.v = damp(vuState.v, clamp(env.rms * 1.4 + env.kick * 0.25), 7, dt);
room.vuNeedle.rotation.z = lerp(0.85, -0.75, vuState.v);
}
if (dust) {
const u = dust.uniforms;
u.uTime.value = t; u.uLPos.value.copy(key.position);
u.uLDir.value.copy(key.target.position).sub(key.position).normalize();
u.uCos.value = Math.cos(key.angle * 0.98);
u.uPow.value = lightsOn; u.uKick.value = env.kick; u.uEnergy.value = env.rms; u.uAxis.value.copy(RC);
}
// Projected UI: scratch zone and hint ring follow the record on screen
if (deck3) {
const c = proj(RC, _p0);
const ex = proj(_p1.copy(RC).add(tmp.set(recR, 0, 0)), _p1);
const ez = proj(_p2.copy(RC).add(tmp.set(0, 0, recR)), _p2);
const ex2 = proj(_p3.copy(RC).add(tmp.set(-recR, 0, 0)), _p3);
const rx = Math.max(Math.hypot(ex.x - c.x, ex.y - c.y), Math.hypot(ex2.x - c.x, ex2.y - c.y));
const ry = Math.abs(ez.y - c.y);
const zoneOn = ie > 0.72 && (secIdx === 0 || secIdx === 1 || secIdx === SECTIONS.length - 1) && rx > 70 && c.z < 1 && secBlend < 0.08;
scratchEl.classList.toggle('on', zoneOn || S.held);
if (zoneOn || S.held) {
const w = rx * 2.1, h = Math.max(ry, rx * 0.25) * 2.1;
scratchEl.style.transform = `translate3d(${(c.x - w / 2).toFixed(1)}px, ${(c.y - h / 2).toFixed(1)}px, 0)`;
scratchEl.style.width = `${w.toFixed(0)}px`; scratchEl.style.height = `${h.toFixed(0)}px`;
}
const hintOn = zoneOn && secIdx === 0 && !S.scratched && S.intro > 0.75;
hintEl.classList.toggle('on', hintOn);
chipEl.classList.toggle('on', hintOn);
if (hintOn) {
const sx = rx * 1.12 / 92, sy = Math.max(ry, 1) * 1.12 / 92;
hintEl.style.transform = `translate3d(${c.x.toFixed(1)}px, ${c.y.toFixed(1)}px, 0) scale(${sx.toFixed(3)}, ${sy.toFixed(3)})`;
const cw = chipEl.offsetWidth || 180;
const pm = portrait();
const cx = pm ? c.x - cw / 2 : clamp(c.x + rx * 0.35, 10, innerWidth - cw - 10), cy = pm ? c.y + ry * 0.2 : Math.min(innerHeight - 120, c.y + ry * 1.2 + 26);
chipEl.style.transform = `translate3d(${cx.toFixed(0)}px, ${cy.toFixed(0)}px, 0)`;
}
}
heroFade = damp(heroFade, secIdx === 0 ? 1 : 0, 6, dt);
heroEl.style.opacity = heroFade.toFixed(3);
}
const fakeSpec = new Float32Array(SPEC.length);
// ─── Catalogue sleeves ────────────────────────────────────────────────────────
$$('.sleeve').forEach(el => {
el.querySelector('.sl-cover').style.backgroundImage = `url(${BASE}img/lowfreq/${el.dataset.img}.webp)`;
const art = el.querySelector('.sl-art');
el.addEventListener('pointermove', e => {
const r = art.getBoundingClientRect();
const x = (e.clientX - r.left) / r.width - 0.5, y = (e.clientY - r.top) / r.height - 0.5;
gsap.to(art, { rotateY: x * 22, rotateX: -y * 16, z: 30, duration: 0.6, ease: 'power3.out' });
art.style.setProperty('--glare', (0.45 + x * 0.6).toFixed(2));
});
el.addEventListener('pointerleave', () => gsap.to(art, { rotateY: 0, rotateX: 0, z: 0, duration: 1.1, ease: 'elastic.out(1, 0.5)' }));
});
// ─── Boot ─────────────────────────────────────────────────────────────────────
worldNav('lowfreq', { theme: 'dark', corner: 'bl' });
const cur = cursor({ color: '#eadcff', blend: 'normal', size: 30 });
magnetic();
smoothScroll({ lerp: 0.08 });
$$('.title .line').forEach(l => { const s = document.createElement('span'); while (l.firstChild) s.appendChild(l.firstChild); l.appendChild(s); });
const T0 = performance.now();
await build();
const T1 = performance.now();
measure();
updateUI();
engine.onTick(tick);
engine.onTick(() => { if (!Q.has('norefl')) reflection.update(scene, camera); });
// compile everything with the lights on so nothing hitches later
lightsOn = 1; tubeWarm = 1; neonOn = 1; S.intro = 1;
tick(0.016, 0);
// compile against an HDR target: the scene is always drawn into the composer's buffers, and programs are keyed on output colour space
renderer.setRenderTarget(engine.post.composer.inputBuffer);
try { await renderer.compileAsync(scene, camera); } catch { renderer.compile(scene, camera); }
renderer.setRenderTarget(null);
const T2 = performance.now();
if (Q.has('debug')) console.warn('timing', { assetsAndBuild: Math.round(T1 - T0), compile: Math.round(T2 - T1), sinceNav: Math.round(T2) });
lightsOn = 0; tubeWarm = 0; neonOn = 0; S.intro = 0;
engine.start();
// let the first frames (post-processing programs, shadow maps) compile behind the loader
await new Promise(r => { let n = 0; const f = () => (++n > 3 ? r() : requestAnimationFrame(f)); requestAnimationFrame(f); });
if (Q.has('debug')) console.warn('timing', { firstFrames: Math.round(performance.now() - T2) });
await loader.finish();
reveal('.sec h2', { type: 'lines', stagger: 0.08 });
reveal('.lede', { type: 'lines', stagger: 0.05, y: '100%' });
for (const [sel, trig] of [['.tracks li', '.tracks'], ['.bar-grid article', '.bar-grid'], ['.stats > div', '.stats'], ['.sleeve', '.sleeves'], ['.tier', '.tiers'], ['.foot-cols > p', '.foot-cols']]) {
gsap.from(sel, { opacity: 0, y: 36, duration: 1.1, ease: 'power3.out', stagger: 0.08, scrollTrigger: { trigger: trig, start: 'top 88%', once: true } });
}
addEventListener('keydown', e => {
if (e.code !== 'Space' || e.target.closest('input, textarea, button, a')) return;
e.preventDefault(); togglePlay();
});
// Intro: valves warm, neon stutters on, the pendant fades up, camera settles on the record, platter spins up.
const intro = gsap.timeline();
intro.to(S, { intro: 1, duration: Q.has('fast') ? 0.01 : 3.4, ease: 'power3.inOut' }, 0)
.to({ v: 0 }, { v: 1, duration: 2.6, ease: 'power1.in', onUpdate() { tubeWarm = this.targets()[0].v; } }, 0)
.to({ v: 0 }, { v: 1, duration: 1.5, ease: 'power2.out', onUpdate() { lightsOn = this.targets()[0].v; } }, 0.3)
.add(() => { S.motor = true; }, 0.9)
.add(() => {
const seq = [0.8, 0, 1, 0.2, 0, 1];
seq.forEach((v, k) => setTimeout(() => { neonOn = v; }, k * 90));
}, 0.7);
gsap.from('.title .line > span', { yPercent: 105, duration: 1.6, ease: 'expo.out', stagger: 0.12, delay: 1.7 });
gsap.from('.hero .eyebrow, .hero .sub, .hero-cta, .nav, .player, .hero-meta, .vert', { opacity: 0, y: 16, duration: 1.3, ease: 'power3.out', stagger: 0.07, delay: 2.1 });
// Press the whole side in the background (offline rendering, no gesture needed).
setTimeout(() => {
audio.prerender(() => deck3.grooves.userData.fill(audio.env)).catch(e => console.warn('audio render failed', e));
}, 600);
window.__lf = { S, arm, audio, play, pause, deck: () => deck3, K, camera, shot };
if (Q.has('debug')) Object.assign(window, { THREE, scene });