Skip to content
VibeCodeBench
Back to the app

The code

Jelly Orange Slice by Claude Fable 5.2

Exactly as the AI wrote it. Shown as text, so nothing runs on this page.

index.html

works · auto-checked (Checked by an automated pass. Not hand-played yet.)34.6 KB · 621 lines · loads cdn.jsdelivr.net/npm/[email protected]/build/three.module.js
Download
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover">
<title>Jelly Orange Slice</title>
<style>
  html,body{margin:0;height:100%;overflow:hidden;background:#b9e2d8;font-family:system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;color:#2b3a36;-webkit-user-select:none;user-select:none;-webkit-tap-highlight-color:transparent}
  canvas{position:fixed;inset:0;width:100%;height:100%;display:block;touch-action:none;cursor:grab}
  #top{position:fixed;left:0;right:0;top:0;padding:calc(12px + env(safe-area-inset-top)) 16px 0;text-align:center;pointer-events:none}
  #top h1{margin:0;font-size:20px;letter-spacing:.02em;font-weight:700;color:#d2560a}
  #hint{margin:4px 0 0;font-size:14px;opacity:.75;transition:opacity .6s}
  #cap{position:fixed;left:50%;top:calc(74px + env(safe-area-inset-top));transform:translateX(-50%);background:rgba(255,255,255,.88);color:#b84a05;font-weight:700;font-size:17px;padding:9px 18px;border-radius:999px;box-shadow:0 4px 18px rgba(40,90,80,.18);pointer-events:none;opacity:0;transition:opacity .3s;white-space:nowrap;max-width:92vw;overflow:hidden;text-overflow:ellipsis}
  #cur{position:fixed;left:0;top:0;width:38px;height:38px;margin:-19px 0 0 -19px;border-radius:50%;border:3px solid #fff;background:rgba(255,255,255,.35);box-shadow:0 2px 10px rgba(0,0,0,.25);pointer-events:none;display:none}
  #ui{position:fixed;left:50%;bottom:0;transform:translateX(-50%);width:min(560px,100%);box-sizing:border-box;padding:12px 14px calc(14px + env(safe-area-inset-bottom));display:flex;flex-direction:column;gap:10px}
  #panel{background:rgba(255,255,255,.82);border-radius:22px;padding:12px 14px;box-shadow:0 8px 30px rgba(40,90,80,.2);display:flex;flex-direction:column;gap:10px}
  #firmRow{display:flex;align-items:center;gap:12px;font-size:16px;font-weight:600}
  #firmRow b{min-width:66px;text-align:right;color:#d2560a}
  input[type=range]{-webkit-appearance:none;appearance:none;flex:1;height:44px;background:transparent;margin:0;touch-action:none}
  input[type=range]::-webkit-slider-runnable-track{height:12px;border-radius:8px;background:linear-gradient(90deg,#ffd89a,#ff8a1f)}
  input[type=range]::-moz-range-track{height:12px;border-radius:8px;background:linear-gradient(90deg,#ffd89a,#ff8a1f)}
  input[type=range]::-webkit-slider-thumb{-webkit-appearance:none;width:34px;height:34px;margin-top:-11px;border-radius:50%;background:#fff;border:4px solid #ff7a0f;box-shadow:0 2px 8px rgba(0,0,0,.25)}
  input[type=range]::-moz-range-thumb{width:28px;height:28px;border-radius:50%;background:#fff;border:4px solid #ff7a0f;box-shadow:0 2px 8px rgba(0,0,0,.25)}
  #btns{display:flex;gap:10px}
  button{flex:1;min-height:58px;border:0;border-radius:18px;font:700 19px/1 inherit;font-family:inherit;cursor:pointer;touch-action:manipulation}
  #squeeze{flex:1.6;color:#fff;background:linear-gradient(180deg,#ffa02e,#f26a05);box-shadow:0 5px 0 #c24e00}
  #squeeze:active{transform:translateY(3px);box-shadow:0 2px 0 #c24e00}
  #squeeze:disabled{opacity:.6}
  #reset{color:#33524b;background:#fff;box-shadow:0 5px 0 #b5cfc8}
  #reset:active{transform:translateY(3px);box-shadow:0 2px 0 #b5cfc8}
  #err{position:fixed;inset:0;display:flex;align-items:center;justify-content:center;font-size:18px;padding:24px;text-align:center;pointer-events:none}
</style>
</head>
<body>
<canvas id="c"></canvas>
<div id="top"><h1>Jelly Orange Slice</h1><p id="hint">Poke it &middot; drag to stretch &middot; let go</p></div>
<div id="cap"></div>
<div id="cur"></div>
<div id="ui"><div id="panel">
  <div id="firmRow"><span>Firmness</span><input id="firm" type="range" min="0" max="100" value="45" aria-label="Firmness"><b id="firmVal">Medium</b></div>
  <div id="btns"><button id="squeeze" type="button">Squeeze</button><button id="reset" type="button">Reset</button></div>
</div></div>
<div id="err">Loading the jelly&hellip;</div>
<script type="module">
import * as THREE from 'https://cdn.jsdelivr.net/npm/[email protected]/build/three.module.js';

const $ = id => document.getElementById(id);
const canvas = $('c');
const clamp = (v, a, b) => Math.min(b, Math.max(a, v));
const lerp = (a, b, t) => a + (b - a) * t;
const smooth = t => { t = clamp(t, 0, 1); return t * t * (3 - 2 * t); };

let renderer;
try { renderer = new THREE.WebGLRenderer({ canvas, antialias: true, powerPreference: 'high-performance' }); }
catch (e) { $('err').textContent = 'Sorry, 3D graphics (WebGL) are not available here.'; throw e; }
$('err').style.display = 'none';
renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));

/* ---------- shape constants (half-wheel slice standing on its cut edge) ---------- */
const R = 1, RC = 0.09, HT = R + RC, HZ = 0.21, BW = 0.085, BZ = 0.09;
function sd2(x, y) {
  const Rr = R - RC; y -= RC; let d;
  if (y < 0) { const ax = Math.abs(x); d = ax > Rr ? Math.hypot(ax - Rr, y) : -y; }
  else d = Math.max(Math.hypot(x, y) - Rr, -y);
  return d - RC;
}

/* ---------- render mesh ---------- */
const M = 120, NF = 11, NB = 6, NR = 3, C0Y = 0.42;
const ox = new Float32Array(M), oy = new Float32Array(M), onx = new Float32Array(M), ony = new Float32Array(M);
for (let m = 0; m < M; m++) {
  const a = -Math.PI / 2 + 2 * Math.PI * m / M, cx = Math.cos(a), cy = Math.sin(a);
  let lo = 0, hi = 2.5;
  for (let it = 0; it < 40; it++) { const mid = (lo + hi) / 2; if (sd2(cx * mid, C0Y + cy * mid) < 0) lo = mid; else hi = mid; }
  const px = cx * lo, py = C0Y + cy * lo, e = 1e-3;
  let gx = sd2(px + e, py) - sd2(px - e, py), gy = sd2(px, py + e) - sd2(px, py - e);
  const gl = Math.hypot(gx, gy) || 1;
  ox[m] = px; oy[m] = py; onx[m] = gx / gl; ony[m] = gy / gl;
}
const rings = [];
for (let k = 1; k <= NF; k++) rings.push([BW, k / NF, HZ]);
for (let k = 1; k <= NB; k++) { const ph = k / NB * Math.PI / 2; rings.push([BW * (1 - Math.sin(ph)), 1, HZ - BZ * (1 - Math.cos(ph))]); }
for (let k = 1; k <= NR; k++) rings.push([0, 1, (HZ - BZ) * (1 - 2 * k / NR)]);
for (let k = 1; k <= NB; k++) { const ph = (1 - k / NB) * Math.PI / 2; rings.push([BW * (1 - Math.sin(ph)), 1, -HZ + BZ * (1 - Math.cos(ph))]); }
for (let k = NF - 1; k >= 1; k--) rings.push([BW, k / NF, -HZ]);
const RN = rings.length;
const vertsArr = [0, C0Y, HZ];
for (let r = 0; r < RN; r++) {
  const [e, s, z] = rings[r];
  for (let m = 0; m < M; m++) {
    const px = ox[m] - onx[m] * e, py = oy[m] - ony[m] * e;
    vertsArr.push(px * s, Math.max(0, C0Y + (py - C0Y) * s), z);
  }
}
vertsArr.push(0, C0Y, -HZ);
const NV = vertsArr.length / 3;
const idxArr = [];
const ri = (r, m) => 1 + r * M + ((m % M) + M) % M;
for (let m = 0; m < M; m++) idxArr.push(0, ri(0, m), ri(0, m + 1));
for (let r = 0; r < RN - 1; r++) for (let m = 0; m < M; m++) {
  const a0 = ri(r, m), a1 = ri(r, m + 1), b0 = ri(r + 1, m), b1 = ri(r + 1, m + 1);
  idxArr.push(a0, b0, b1, a0, b1, a1);
}
for (let m = 0; m < M; m++) idxArr.push(ri(RN - 1, m), NV - 1, ri(RN - 1, m + 1));

const geo = new THREE.BufferGeometry();
const restArr = new Float32Array(vertsArr);
const posAttr = new THREE.BufferAttribute(new Float32Array(vertsArr), 3);
posAttr.setUsage(THREE.DynamicDrawUsage);
geo.setAttribute('position', posAttr);
geo.setAttribute('rest', new THREE.BufferAttribute(restArr, 3));
geo.setIndex(idxArr);
geo.computeVertexNormals();
geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(0, 0.5, 0), 6);

/* ---------- soft-body lattice (XPBD particles + distance constraints) ---------- */
const NX = 14, NY = 7, NZ = 3, GX = NX + 1, GY = NY + 1, GZ = NZ + 1;
const X0 = -R, Y0 = 0, Z0 = -HZ, DX = 2 * R / NX, DY = HT / NY, DZ = 2 * HZ / NZ;
const cellOn = new Uint8Array(NX * NY * NZ);
const ci = (v, o, d, n) => clamp(Math.floor((v - o) / d), 0, n - 1);
for (let v = 0; v < NV; v++) {
  const i = ci(restArr[v * 3], X0, DX, NX), j = ci(restArr[v * 3 + 1], Y0, DY, NY), k = ci(restArr[v * 3 + 2], Z0, DZ, NZ);
  cellOn[i + NX * (j + NY * k)] = 1;
}
for (let i = 0; i < NX; i++) for (let j = 0; j < NY; j++) {
  if (sd2(X0 + (i + 0.5) * DX, Y0 + (j + 0.5) * DY) < 0) for (let k = 0; k < NZ; k++) cellOn[i + NX * (j + NY * k)] = 1;
}
const nodeId = new Int32Array(GX * GY * GZ).fill(-1);
const nid = (i, j, k) => i + GX * (j + GY * k);
let NP = 0; const restList = [], botList = [];
for (let k = 0; k < NZ; k++) for (let j = 0; j < NY; j++) for (let i = 0; i < NX; i++) {
  if (!cellOn[i + NX * (j + NY * k)]) continue;
  for (let n = 0; n < 8; n++) {
    const a = i + (n & 1), b = j + ((n >> 1) & 1), c = k + ((n >> 2) & 1), id = nid(a, b, c);
    if (nodeId[id] < 0) { nodeId[id] = NP++; restList.push(X0 + a * DX, Y0 + b * DY, Z0 + c * DZ); botList.push(b === 0 ? 1 : 0); }
  }
}
const rest = new Float32Array(restList), pos = new Float32Array(restList), prev = new Float32Array(restList), vel = new Float32Array(NP * 3);
const bottom = new Uint8Array(botList);
const cAl = [], cBl = [], cLl = []; const seen = new Set();
for (let k = 0; k < NZ; k++) for (let j = 0; j < NY; j++) for (let i = 0; i < NX; i++) {
  if (!cellOn[i + NX * (j + NY * k)]) continue;
  const c = [];
  for (let n = 0; n < 8; n++) c.push(nodeId[nid(i + (n & 1), j + ((n >> 1) & 1), k + ((n >> 2) & 1))]);
  for (let a = 0; a < 8; a++) for (let b = a + 1; b < 8; b++) {
    const p = Math.min(c[a], c[b]), q = Math.max(c[a], c[b]), key = p * NP + q;
    if (seen.has(key)) continue; seen.add(key);
    cAl.push(p); cBl.push(q);
    cLl.push(Math.hypot(rest[p * 3] - rest[q * 3], rest[p * 3 + 1] - rest[q * 3 + 1], rest[p * 3 + 2] - rest[q * 3 + 2]));
  }
}
const NC = cAl.length, cA = new Int32Array(cAl), cB = new Int32Array(cBl), cL = new Float32Array(cLl);

// embed render vertices in the lattice (trilinear)
const emIdx = new Int32Array(NV * 8), emW = new Float32Array(NV * 8);
for (let v = 0; v < NV; v++) {
  const x = restArr[v * 3], y = restArr[v * 3 + 1], z = restArr[v * 3 + 2];
  const i = ci(x, X0, DX, NX), j = ci(y, Y0, DY, NY), k = ci(z, Z0, DZ, NZ);
  const tx = (x - X0) / DX - i, ty = (y - Y0) / DY - j, tz = (z - Z0) / DZ - k;
  for (let n = 0; n < 8; n++) {
    const dx = n & 1, dy = (n >> 1) & 1, dz = (n >> 2) & 1;
    let id = nodeId[nid(i + dx, j + dy, k + dz)], w = (dx ? tx : 1 - tx) * (dy ? ty : 1 - ty) * (dz ? tz : 1 - tz);
    if (id < 0) { id = 0; w = 0; }
    emIdx[v * 8 + n] = id * 3; emW[v * 8 + n] = w;
  }
}
function evalPoint(x, y, z, out) {
  const i = ci(x, X0, DX, NX), j = ci(y, Y0, DY, NY), k = ci(z, Z0, DZ, NZ);
  const tx = (x - X0) / DX - i, ty = (y - Y0) / DY - j, tz = (z - Z0) / DZ - k;
  let sx = 0, sy = 0, sz = 0, sw = 0;
  for (let n = 0; n < 8; n++) {
    const dx = n & 1, dy = (n >> 1) & 1, dz = (n >> 2) & 1, id = nodeId[nid(i + dx, j + dy, k + dz)];
    if (id < 0) continue;
    const w = (dx ? tx : 1 - tx) * (dy ? ty : 1 - ty) * (dz ? tz : 1 - tz);
    sx += pos[id * 3] * w; sy += pos[id * 3 + 1] * w; sz += pos[id * 3 + 2] * w; sw += w;
  }
  if (Math.abs(sw) < 1e-4) return out.set(x, y, z);
  return out.set(sx / sw, Math.max(0.004, sy / sw), sz / sw);
}
function updateMesh() {
  const p = posAttr.array;
  for (let v = 0; v < NV; v++) {
    let x = 0, y = 0, z = 0; const o = v * 8;
    for (let n = 0; n < 8; n++) { const id = emIdx[o + n], w = emW[o + n]; x += pos[id] * w; y += pos[id + 1] * w; z += pos[id + 2] * w; }
    p[v * 3] = x; p[v * 3 + 1] = y < 0 ? 0 : y; p[v * 3 + 2] = z;
  }
  posAttr.needsUpdate = true;
  geo.computeVertexNormals();
}

/* ---------- simulation ---------- */
const G = 4, SUB = 12, FRAME = 1 / 60;
let firmness = 0.45, stiff = 1800, damp = 1.5, simT = 0, pressOn = false, pressY = 9, subCount = 0;
const grab = { on: false, idx: [], w: [], off: [], H: new THREE.Vector3(), P: new THREE.Vector3(), T: new THREE.Vector3(), dir: new THREE.Vector3(), t0: 0 };
function setFirmness(f) { firmness = clamp(f, 0, 1); stiff = 700 * Math.pow(13, firmness); damp = 0.9 + 1.5 * firmness; }
function startGrab(H, dir, impulse) {
  grab.idx.length = 0; grab.w.length = 0; grab.off.length = 0;
  for (let i = 0; i < NP; i++) {
    const dx = pos[i * 3] - H.x, dy = pos[i * 3 + 1] - H.y, dz = pos[i * 3 + 2] - H.z, d2 = dx * dx + dy * dy + dz * dz;
    if (d2 < 0.25) {
      const w = Math.exp(-d2 / 0.045);
      if (w > 0.03) { grab.idx.push(i); grab.w.push(w); grab.off.push(dx, dy, dz); }
      if (impulse && !bottom[i]) { const w2 = Math.exp(-d2 / 0.16) * impulse; vel[i * 3] += dir.x * w2; vel[i * 3 + 1] += dir.y * w2; vel[i * 3 + 2] += dir.z * w2; }
    }
  }
  grab.on = grab.idx.length > 0; grab.H.copy(H); grab.P.copy(H); grab.T.copy(H); grab.dir.copy(dir); grab.t0 = simT;
}
const tv = new THREE.Vector3();
function setGrabTarget(P) {
  tv.copy(P).sub(grab.H); const l = tv.length(); if (l > 1.15) tv.multiplyScalar(1.15 / l);
  grab.P.copy(grab.H).add(tv);
}
function releaseGrab() { grab.on = false; }
function substep(h) {
  const at = 1 / (stiff * h * h), tf = 1 / (1 + 1 / (0.02 * stiff * h * h)), bf = 1 / (1 + 1 / (8 * stiff * h * h)), dm = Math.exp(-damp * h), gh = G * h;
  for (let i = 0, n = NP * 3; i < n; i += 3) {
    vel[i + 1] -= gh;
    vel[i] *= dm; vel[i + 1] *= dm; vel[i + 2] *= dm;
    prev[i] = pos[i]; prev[i + 1] = pos[i + 1]; prev[i + 2] = pos[i + 2];
    pos[i] += vel[i] * h; pos[i + 1] += vel[i + 1] * h; pos[i + 2] += vel[i + 2] * h;
  }
  if (grab.on) {
    const T = grab.T;
    for (let n = 0; n < grab.idx.length; n++) {
      const i = grab.idx[n] * 3, w = grab.w[n] * 0.45;
      pos[i] += (T.x + grab.off[n * 3] - pos[i]) * w;
      pos[i + 1] += (T.y + grab.off[n * 3 + 1] - pos[i + 1]) * w;
      pos[i + 2] += (T.z + grab.off[n * 3 + 2] - pos[i + 2]) * w;
    }
  }
  const rev = (subCount++) & 1;
  for (let cc = 0; cc < NC; cc++) {
    const c = rev ? NC - 1 - cc : cc, a = cA[c] * 3, b = cB[c] * 3;
    const dx = pos[b] - pos[a], dy = pos[b + 1] - pos[a + 1], dz = pos[b + 2] - pos[a + 2];
    const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
    if (d < 1e-7) continue;
    const s = (d - cL[c]) / (d * (2 + at));
    pos[a] += dx * s; pos[a + 1] += dy * s; pos[a + 2] += dz * s;
    pos[b] -= dx * s; pos[b + 1] -= dy * s; pos[b + 2] -= dz * s;
  }
  const ih = 1 / h;
  for (let p = 0; p < NP; p++) {
    const i = p * 3, f = bottom[p] ? bf : tf;
    pos[i] += (rest[i] - pos[i]) * f; pos[i + 1] += (rest[i + 1] - pos[i + 1]) * f; pos[i + 2] += (rest[i + 2] - pos[i + 2]) * f;
    if (pos[i + 1] < 0) pos[i + 1] = 0;
    if (pressOn && pos[i + 1] > pressY) pos[i + 1] = pressY;
    pos[i] = clamp(pos[i], -2.4, 2.4); pos[i + 2] = clamp(pos[i + 2], -2.4, 2.4); if (pos[i + 1] > 3) pos[i + 1] = 3;
    let vx = (pos[i] - prev[i]) * ih, vy = (pos[i + 1] - prev[i + 1]) * ih, vz = (pos[i + 2] - prev[i + 2]) * ih;
    const sp = vx * vx + vy * vy + vz * vz;
    if (sp > 144) { const k = 12 / Math.sqrt(sp); vx *= k; vy *= k; vz *= k; }
    vel[i] = vx; vel[i + 1] = vy; vel[i + 2] = vz;
  }
}
function viscosity(s) { // damps high-frequency buzz, keeps the slow wobble
  for (let c = 0; c < NC; c++) {
    const a = cA[c] * 3, b = cB[c] * 3;
    const dx = (vel[b] - vel[a]) * s, dy = (vel[b + 1] - vel[a + 1]) * s, dz = (vel[b + 2] - vel[a + 2]) * s;
    vel[a] += dx; vel[a + 1] += dy; vel[a + 2] += dz; vel[b] -= dx; vel[b + 1] -= dy; vel[b + 2] -= dz;
  }
}
function resetBody() { pos.set(rest); prev.set(rest); vel.fill(0); }
function simFrame() {
  if (grab.on) { const dep = 0.1 * Math.min(1, (simT - grab.t0) / 0.07); grab.T.copy(grab.P).addScaledVector(grab.dir, dep); }
  for (let s = 0; s < SUB; s++) substep(FRAME / SUB);
  viscosity(0.025);
  simT += FRAME;
  if (!isFinite(pos[0] + pos[NP * 3 - 1] + vel[1])) resetBody();
}

/* ---------- scene ---------- */
const scene = new THREE.Scene();
const BG = '#b9e2d8';
scene.background = new THREE.Color(BG);
const camera = new THREE.PerspectiveCamera(30, 1, 0.5, 120);
const cam = { az: 0.38, el: 0.36, dist: 6.2, ty: 0.42 };
const L1 = new THREE.Vector3(-0.22, 0.78, -0.72).normalize(), L2 = new THREE.Vector3(0.46, 0.65, 0.60).normalize();

scene.add(new THREE.HemisphereLight(0xffffff, 0xd8cfc0, 0.5));
const dl2 = new THREE.DirectionalLight(0xffffff, 1.35); dl2.position.copy(L2).multiplyScalar(6); scene.add(dl2);
const dl1 = new THREE.DirectionalLight(0xfff1dc, 0.75); dl1.position.copy(L1).multiplyScalar(6); scene.add(dl1);

try { // tiny procedural studio environment for glossy reflections
  const es = new THREE.Scene();
  es.add(new THREE.Mesh(new THREE.SphereGeometry(20, 24, 16), new THREE.MeshBasicMaterial({ color: new THREE.Color().setRGB(0.45, 0.5, 0.5), side: THREE.BackSide })));
  const p1 = new THREE.Mesh(new THREE.BoxGeometry(6, 0.2, 6), new THREE.MeshBasicMaterial({ color: new THREE.Color().setRGB(2, 2, 2) })); p1.position.set(0, 8, 0); es.add(p1);
  const p2 = new THREE.Mesh(new THREE.BoxGeometry(0.2, 5, 6), new THREE.MeshBasicMaterial({ color: new THREE.Color().setRGB(1.6, 1.6, 1.5) })); p2.position.set(-8, 3, 2); es.add(p2);
  const pm = new THREE.PMREMGenerator(renderer);
  scene.environment = pm.fromScene(es, 0.04).texture;
} catch (e) { /* reflections are optional */ }

function radialTex(stops) {
  const c = document.createElement('canvas'); c.width = c.height = 256;
  const g = c.getContext('2d'), gr = g.createRadialGradient(128, 128, 0, 128, 128, 128);
  stops.forEach(s => gr.addColorStop(s[0], s[1])); g.fillStyle = gr; g.fillRect(0, 0, 256, 256);
  const t = new THREE.CanvasTexture(c); t.colorSpace = THREE.SRGBColorSpace; return t;
}
const TABLE_Y = -0.14;
const table = new THREE.Mesh(new THREE.CircleGeometry(40, 64), new THREE.MeshBasicMaterial({ map: radialTex([[0, '#f4fbf8'], [0.1, '#e0f3ed'], [0.3, BG], [1, BG]]), toneMapped: false }));
table.rotation.x = -Math.PI / 2; table.position.y = TABLE_Y; scene.add(table);
const pShadow = new THREE.Mesh(new THREE.PlaneGeometry(5.4, 5.4), new THREE.MeshBasicMaterial({ map: radialTex([[0, 'rgba(20,70,58,0.5)'], [0.6, 'rgba(20,70,58,0.42)'], [0.8, 'rgba(20,70,58,0.13)'], [1, 'rgba(20,70,58,0)']]), transparent: true, depthWrite: false, toneMapped: false }));
pShadow.rotation.x = -Math.PI / 2; pShadow.position.set(0.1, TABLE_Y + 0.004, 0.2); pShadow.renderOrder = 0; scene.add(pShadow);

const platePts = [[0.001, -0.14], [0.95, -0.14], [1.3, -0.09], [1.55, 0.0], [1.8, 0.105], [1.84, 0.135], [1.8, 0.15], [1.62, 0.11], [1.32, 0.015], [1.18, 0], [0.001, 0]].map(p => new THREE.Vector2(p[0], p[1]));
const plate = new THREE.Mesh(new THREE.LatheGeometry(platePts, 96), new THREE.MeshStandardMaterial({ color: 0xfbfaf7, roughness: 0.2, metalness: 0, envMapIntensity: 0.4, side: THREE.DoubleSide }));
scene.add(plate);
const contact = new THREE.Mesh(new THREE.PlaneGeometry(2.6, 0.95), new THREE.MeshBasicMaterial({ map: radialTex([[0, 'rgba(120,50,0,0.34)'], [0.6, 'rgba(120,50,0,0.2)'], [1, 'rgba(120,50,0,0)']]), transparent: true, depthWrite: false, toneMapped: false }));
contact.rotation.x = -Math.PI / 2; contact.position.y = 0.003; contact.renderOrder = 1; scene.add(contact);

/* ---------- citrus shaders ---------- */
const GLSL_COMMON = `
#define PI 3.14159265
const float RC = 0.09;
float h21(vec2 p){ p = fract(p*vec2(123.34,456.21)); p += dot(p,p+45.32); return fract(p.x*p.y); }
float smin(float a,float b,float k){ float h = clamp(0.5+0.5*(b-a)/k,0.,1.); return mix(b,a,h)-k*h*(1.-h); }
void regions(vec3 p, out float flesh, out float peel, out float r, out float th, out float la, out float sidx){
  vec2 q = vec2(p.x, p.y-RC); r = length(q); th = clamp(atan(q.y,q.x+1e-5), 0.001, PI-0.001);
  float rw = r + 0.010*sin(th*9.+1.3) + 0.005*sin(th*23.);
  float SEG = PI/5.; float tw = th + 0.3*SEG + 0.03*sin(r*8.+1.);
  sidx = floor(tw/SEG); la = (fract(tw/SEG)-0.5)*SEG;
  float dS = (SEG*0.5-abs(la))*max(r,0.04);
  float d = smin(smin(dS, 0.815-rw, 0.05), r-0.07, 0.03);
  flesh = smoothstep(0.010,0.028,d);
  peel = smoothstep(0.895,0.912,rw);
}`;
const sliceMat = new THREE.ShaderMaterial({
  side: THREE.DoubleSide, transparent: true, depthWrite: true,
  extensions: { derivatives: true },
  vertexShader: `
attribute vec3 rest; varying vec3 vRest; varying vec3 vW; varying vec3 vN;
void main(){ vRest = rest; vec4 w = modelMatrix*vec4(position,1.); vW = w.xyz; vN = normalize(mat3(modelMatrix)*normal); gl_Position = projectionMatrix*viewMatrix*w; }`,
  fragmentShader: `
precision highp float;
varying vec3 vRest; varying vec3 vW; varying vec3 vN;
${GLSL_COMMON}
vec3 voro(vec2 x){ vec2 n = floor(x), f = fract(x); float f1 = 8., f2 = 8., id = 0.;
  for(int j=-1;j<=1;j++){ for(int i=-1;i<=1;i++){ vec2 g = vec2(float(i),float(j)); vec2 c = n+g; float a = h21(c); vec2 o = vec2(a, h21(c+a+17.13)); vec2 rr = g+o-f; float d = dot(rr,rr);
    if(d<f1){ f2 = f1; f1 = d; id = a; } else if(d<f2){ f2 = d; } } }
  return vec3(sqrt(f1), sqrt(f2), id); }
void main(){
  vec3 N = normalize(vN); if(!gl_FrontFacing) N = -N;
  vec3 V = normalize(cameraPosition - vW);
  float flesh, peel, r, th, la, sidx; regions(vRest, flesh, peel, r, th, la, sidx);
  vec2 cu = vec2(la*(r+0.25)*30. + sidx*7.3, r*9. - abs(la)*2.5);
  vec2 pu = vec2(th*36., vRest.z*36. + r*36.);
  float lod = clamp(1.3 - length(fwidth(cu))*0.9, 0.25, 1.);
  vec3 vc = voro(mix(cu, pu, step(0.5, peel)));
  float wall = 1. - smoothstep(0., 0.16, vc.y - vc.x);
  float dome = 1. - min(vc.x*vc.x*1.5, 1.);
  float pore = smoothstep(0.25, 0.08, vc.x);
  float pith = (1.-flesh)*(1.-peel);
  float fl = flesh*(1.-peel);
  float h = fl*(dome*0.7 - wall*0.5) + peel*(-pore*0.9) + pith*0.25;
  // bump from screen-space derivatives of the cell height
  vec3 dpx = dFdx(vW), dpy = dFdy(vW); float hx = dFdx(h), hy = dFdy(h);
  vec3 r1 = cross(dpy, N), r2 = cross(N, dpx); float det = dot(dpx, r1);
  vec3 gr = sign(det)*(hx*r1 + hy*r2);
  vec3 Nb = normalize(abs(det)*N - 0.014*lod*gr + 1e-6*N);
  // colours
  vec3 fc = mix(vec3(1.0,0.40,0.02), vec3(1.0,0.66,0.10), clamp(vc.z*0.7 + dome*0.3, 0., 1.));
  fc = mix(fc, vec3(1.0,0.80,0.42), wall*0.45);
  fc *= 0.80 + 0.28*smoothstep(0.05, 0.8, r);
  vec3 pc = mix(vec3(1.0,0.86,0.62), vec3(1.0,0.95,0.86), smoothstep(0.78, 0.86, r));
  vec3 pl = mix(vec3(1.0,0.50,0.03), vec3(0.92,0.35,0.0), pore);
  vec3 albedo = mix(mix(pc, fc, flesh), pl, peel);
  // light
  vec3 L1 = normalize(vec3(-0.22,0.78,-0.72)), L2 = normalize(vec3(0.46,0.65,0.60)), L3 = normalize(vec3(-0.7,0.45,0.55));
  float w2 = dot(Nb, L2)*0.5 + 0.5; float d1 = max(dot(Nb, L1), 0.);
  vec3 col = albedo*(0.42 + 0.50*w2*w2 + 0.30*d1);
  float tr = fl + pith*0.4 + peel*0.08;
  float back = pow(clamp(dot(V, -L1)*0.5 + 0.5, 0., 1.), 1.5);
  vec3 glow = mix(vec3(1.0,0.55,0.06), vec3(1.0,0.75,0.25), clamp(dome*0.5 + wall*0.3, 0., 1.));
  col += tr*glow*(0.18 + 0.75*back)*(0.75 + 0.25*dome);
  float ndv = max(dot(N, V), 0.); float fres = pow(1. - ndv, 4.);
  col += vec3(1.0,0.62,0.18)*pow(1. - ndv, 2.5)*(0.15 + 0.55*back)*(0.4 + 0.6*tr);
  float spec = 0.;
  if(gl_FrontFacing){
    vec3 Hh = normalize(L2 + V);
    float s1 = pow(max(dot(Nb, Hh), 0.), 70.)*0.8*lod;
    float s2 = pow(max(dot(N, Hh), 0.), 260.)*1.1;
    float s3 = pow(max(dot(N, normalize(L3 + V)), 0.), 140.)*0.45;
    float s4 = pow(max(dot(Nb, normalize(L1 + V)), 0.), 50.)*0.5;
    spec = s1 + s2 + s3 + s4;
    vec3 Rf = reflect(-V, normalize(mix(N, Nb, 0.35)));
    float sky = smoothstep(-0.2, 0.9, Rf.y);
    col += mix(vec3(0.5,0.58,0.56), vec3(1.), sky)*(0.03 + 0.45*fres);
    col += vec3(1.,0.98,0.92)*spec;
  } else { col *= 0.92; }
  float a = mix(0.94, mix(0.52, 0.80, wall), flesh); a = mix(a, 1., peel);
  a = clamp(a + fres*0.35 + spec*0.7, 0., 1.);
  float m = max(col.r, max(col.g, col.b));
  if(m > 1.) col = mix(col/m, vec3(1.), min(1., (m - 1.)*0.35));
  gl_FragColor = vec4(col, a);
}`
});
const slice = new THREE.Mesh(geo, sliceMat);
slice.frustumCulled = false; slice.renderOrder = 3; scene.add(slice);

// light passing through the slice, projected on the plate like stained glass
const shadowMat = new THREE.ShaderMaterial({
  transparent: true, depthWrite: false, blending: THREE.MultiplyBlending, side: THREE.FrontSide,
  polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -2,
  uniforms: { uL: { value: L1 } },
  vertexShader: `
attribute vec3 rest; uniform vec3 uL; varying vec3 vRest;
void main(){ vRest = rest; vec4 w = modelMatrix*vec4(position,1.); float t = max(w.y,0.)/uL.y; w.xz -= uL.xz*t; w.y = 0.004; gl_Position = projectionMatrix*viewMatrix*w; }`,
  fragmentShader: `
precision highp float; varying vec3 vRest;
${GLSL_COMMON}
void main(){ float flesh, peel, r, th, la, sidx; regions(vRest, flesh, peel, r, th, la, sidx);
  vec3 tint = mix(mix(vec3(0.82,0.64,0.50), vec3(1.0,0.76,0.38), flesh), vec3(0.64,0.44,0.32), peel);
  gl_FragColor = vec4(tint, 1.); }`
});
const shadow = new THREE.Mesh(geo, shadowMat);
shadow.frustumCulled = false; shadow.renderOrder = 2; scene.add(shadow);

/* ---------- juice drops ---------- */
const dropGeo = new THREE.SphereGeometry(1, 16, 12);
const dropMat = new THREE.MeshStandardMaterial({ color: 0xff8c12, roughness: 0.1, metalness: 0, emissive: 0xe85a00, emissiveIntensity: 0.55, envMapIntensity: 1.0 });
const drops = [];
for (let i = 0; i < 18; i++) { const m = new THREE.Mesh(dropGeo, dropMat); m.visible = false; scene.add(m); drops.push({ m, on: false, st: 0, x: 0, y: 0, side: 1, vy: 0, r: 0.04, age: 0, born: 0, a: new THREE.Vector3(), b: new THREE.Vector3() }); }
let dropN = 0;
function spawnDrop() {
  let d = drops.find(q => !q.on);
  if (!d) d = drops.reduce((a, b) => (a.born < b.born ? a : b));
  d.on = true; d.st = 0; d.age = 0; d.vy = 0; d.born = simT; d.side = (dropN++ % 3 === 2) ? -1 : 1;
  d.x = (Math.random() * 2 - 1) * 0.6; d.y = 0.2 + Math.random() * 0.26; d.r = 0.034 + Math.random() * 0.02;
  d.m.visible = true; d.m.scale.setScalar(0.001);
}
function updateDrops(dt) {
  for (const d of drops) {
    if (!d.on) continue;
    d.age += dt;
    if (d.st === 0) {
      const s = Math.min(1, d.age / 0.45);
      evalPoint(d.x, d.y, d.side * (HZ + 0.012), d.m.position); d.m.scale.set(d.r * s, d.r * s * 1.15, d.r * s);
      if (d.age > 0.6) d.st = 1;
    } else if (d.st === 1) {
      d.vy = Math.min(d.vy + 1.5 * dt, 0.6); d.y -= d.vy * dt;
      evalPoint(d.x, d.y, d.side * (HZ + 0.012), d.m.position); d.m.scale.set(d.r * 0.9, d.r * 1.5, d.r * 0.9);
      if (d.y < 0.075) { d.st = 2; d.age = 0; d.a.copy(d.m.position); d.b.set(d.m.position.x, 0.008, d.m.position.z + d.side * 0.12); }
    } else {
      const u = smooth(d.age / 0.5);
      d.m.position.lerpVectors(d.a, d.b, u);
      d.m.scale.set(lerp(d.r * 0.9, d.r * 1.9, u), lerp(d.r * 1.5, d.r * 0.38, u), lerp(d.r * 0.9, d.r * 1.9, u));
    }
  }
}
function clearDrops() { for (const d of drops) { d.on = false; d.m.visible = false; } }

/* ---------- squeeze presser ---------- */
const presser = new THREE.Group();
const glass = new THREE.Mesh(new THREE.CylinderGeometry(1.3, 1.3, 0.05, 56), new THREE.MeshStandardMaterial({ color: 0xeaf6ff, transparent: true, opacity: 0.3, roughness: 0.05, metalness: 0, envMapIntensity: 1.5, depthWrite: false }));
glass.position.y = 0.025; glass.renderOrder = 5; presser.add(glass);
const ring = new THREE.Mesh(new THREE.TorusGeometry(1.3, 0.028, 10, 64), new THREE.MeshStandardMaterial({ color: 0xffffff, transparent: true, opacity: 0.65, roughness: 0.1, depthWrite: false }));
ring.rotation.x = Math.PI / 2; ring.position.y = 0.025; ring.renderOrder = 5; presser.add(ring);
const hMat = new THREE.MeshStandardMaterial({ color: 0xfbfaf7, roughness: 0.25, envMapIntensity: 0.4 });
const stem = new THREE.Mesh(new THREE.CylinderGeometry(0.07, 0.1, 0.42, 20), hMat); stem.position.y = 0.26; presser.add(stem);
const knob = new THREE.Mesh(new THREE.SphereGeometry(0.15, 20, 14), hMat); knob.position.y = 0.52; presser.add(knob);
presser.visible = false; scene.add(presser);
const sq = { on: false, t: 0, n: 0, low: 0.65 };
function startSqueeze() { if (sq.on) return; sq.on = true; sq.t = 0; sq.n = 0; sq.low = HT * (0.58 + 0.08 * firmness); $('squeeze').disabled = true; }
function pressAt(t, low) {
  if (t < 0.7) return lerp(2.8, HT + 0.02, 1 - Math.pow(1 - t / 0.7, 2));
  if (t < 1.7) return lerp(HT + 0.02, low, smooth((t - 0.7) / 1.0));
  if (t < 2.7) return low + 0.008 * Math.sin((t - 1.7) * 9);
  if (t < 3.3) return lerp(low, 2.8, Math.pow((t - 2.7) / 0.6, 2));
  return 9;
}
function updateSqueeze(dt) {
  if (!sq.on) { pressOn = false; return; }
  sq.t += dt; pressY = pressAt(sq.t, sq.low); pressOn = pressY < HT + 0.4;
  presser.visible = true; presser.position.y = pressY;
  while (sq.n < 7 && sq.t > 1.3 + sq.n * 0.2) { spawnDrop(); sq.n++; }
  if (sq.t >= 3.3) { sq.on = false; pressOn = false; presser.visible = false; $('squeeze').disabled = false; }
}
function stopSqueeze() { sq.on = false; pressOn = false; presser.visible = false; $('squeeze').disabled = false; }

/* ---------- UI ---------- */
const slider = $('firm');
let firmTarget = null;
function applyFirm() { const v = +slider.value / 100; setFirmness(v); $('firmVal').textContent = v < 0.33 ? 'Soft' : v < 0.67 ? 'Medium' : 'Firm'; }
slider.addEventListener('input', () => { firmTarget = null; applyFirm(); });
applyFirm();
function doReset(keepCam) {
  releaseGrab(); stopSqueeze(); clearDrops(); resetBody(); slider.value = 45; firmTarget = null; applyFirm();
  if (!keepCam) { cam.az = 0.38; cam.el = 0.36; }
}
$('squeeze').addEventListener('click', () => startSqueeze());
$('reset').addEventListener('click', () => doReset(false));
function hideHint() { $('hint').style.opacity = 0; }

function layout() {
  const W = Math.max(1, window.innerWidth), H = Math.max(1, window.innerHeight);
  renderer.setSize(W, H, false);
  camera.aspect = W / H; camera.updateProjectionMatrix();
  const th = Math.tan(camera.fov * Math.PI / 360);
  cam.dist = Math.max(6.2, 2.05 / (th * camera.aspect));
  const uiFrac = Math.min(0.45, $('ui').offsetHeight / H);
  cam.ty = 0.42 - uiFrac * cam.dist * th * 0.9;
}
window.addEventListener('resize', layout);
layout();
function updateCamera() {
  const ce = Math.cos(cam.el);
  camera.position.set(Math.sin(cam.az) * ce * cam.dist, cam.ty + Math.sin(cam.el) * cam.dist, Math.cos(cam.az) * ce * cam.dist);
  camera.lookAt(0, cam.ty, 0);
  camera.updateMatrixWorld();
}

/* ---------- pointer: poke / drag the jelly, or orbit on empty space ---------- */
const ray = new THREE.Raycaster(), ndc = new THREE.Vector2(), plane = new THREE.Plane(), tmp = new THREE.Vector3(), tmp2 = new THREE.Vector3();
let ptr = null;
function setRay(e) {
  const r = canvas.getBoundingClientRect();
  ndc.set(((e.clientX - r.left) / r.width) * 2 - 1, -((e.clientY - r.top) / r.height) * 2 + 1);
  ray.setFromCamera(ndc, camera);
}
canvas.addEventListener('pointerdown', e => {
  if (ptr) return;
  e.preventDefault();
  try { canvas.setPointerCapture(e.pointerId); } catch (_) {}
  hideHint(); updateCamera(); setRay(e);
  const hit = ray.intersectObject(slice, false)[0];
  if (hit) {
    camera.getWorldDirection(tmp);
    plane.setFromNormalAndCoplanarPoint(tmp, hit.point);
    startGrab(hit.point, ray.ray.direction, 1.8);
    ptr = { id: e.pointerId, mode: grab.on ? 'grab' : 'none' };
    canvas.style.cursor = 'grabbing';
  } else ptr = { id: e.pointerId, mode: 'orbit', x: e.clientX, y: e.clientY };
});
canvas.addEventListener('pointermove', e => {
  if (!ptr || e.pointerId !== ptr.id) return;
  if (ptr.mode === 'grab') { setRay(e); if (ray.ray.intersectPlane(plane, tmp)) setGrabTarget(tmp); }
  else if (ptr.mode === 'orbit') {
    cam.az -= (e.clientX - ptr.x) * 0.006; cam.el = clamp(cam.el + (e.clientY - ptr.y) * 0.005, 0.06, 1.25);
    ptr.x = e.clientX; ptr.y = e.clientY;
  }
});
function endPtr(e) { if (!ptr || e.pointerId !== ptr.id) return; if (ptr.mode === 'grab') releaseGrab(); ptr = null; canvas.style.cursor = 'grab'; }
canvas.addEventListener('pointerup', endPtr);
canvas.addEventListener('pointercancel', endPtr);
canvas.addEventListener('contextmenu', e => e.preventDefault());

/* ---------- hands-free demo (#demo) ---------- */
const demo = { on: /#demo$/.test(String(location.href)), t: 0, i: 0, drag: null };
const capEl = $('cap'), curEl = $('cur');
function say(s) { capEl.textContent = s; capEl.style.opacity = 1; }
function dStart(x, y, z, ox2, oy2, oz2, ramp, hold, wig) {
  evalPoint(x, y, z, tmp);
  tmp2.set(ox2, oy2, oz2); const len = tmp2.length() || 1;
  const dir = tmp2.clone().multiplyScalar(1 / len);
  startGrab(tmp, wig ? new THREE.Vector3(0, 0, -1) : dir, wig ? 0 : 2.0);
  demo.drag = { H: tmp.clone(), off: new THREE.Vector3(ox2, oy2, oz2), t0: demo.t, ramp, hold, wig };
}
const dPoke = (x, y, z, dx, dy, dz) => dStart(x, y, z, dx * 0.16, dy * 0.16, dz * 0.16, 0.1, 0.2, false);
function dRelease() { demo.drag = null; releaseGrab(); curEl.style.display = 'none'; }
const script = [
  [0.05, () => { doReset(true); say('Jelly orange slice'); }],
  [1.3, () => { say('Poke it'); dPoke(0.25, 0.62, HZ, 0, 0, -1); }],
  [2.5, () => dPoke(-0.45, 0.42, HZ, 0.3, 0, -1)],
  [3.6, () => dPoke(0.0, HT, 0, 0, -1, 0)],
  [4.8, () => { say('Drag to stretch…'); dStart(0.38, 0.88, HZ, 0.72, 0.5, 0.35, 1.5, 99, true); }],
  [7.0, () => { say('…let go: it jiggles, then settles'); dRelease(); }],
  [9.3, () => { say('Firmness: soft'); firmTarget = 6; }],
  [10.1, () => dPoke(0.3, 0.7, HZ, -0.4, 0, -1)],
  [12.0, () => { say('Firmness: firm'); firmTarget = 96; }],
  [12.8, () => dPoke(0.3, 0.7, HZ, -0.4, 0, -1)],
  [14.2, () => { firmTarget = 45; say('Squeeze: juice runs out'); startSqueeze(); }],
  [18.5, () => say('Reset')],
  [19.3, () => doReset(true)]
];
function updateDemo(dt) {
  demo.t += dt;
  if (demo.t >= 20) { demo.t -= 20; demo.i = 0; dRelease(); }
  while (demo.i < script.length && demo.t >= script[demo.i][0]) { script[demo.i][1](); demo.i++; }
  cam.az = 0.38 + 0.4 * Math.sin(demo.t * Math.PI / 10); cam.el = 0.36 + 0.06 * Math.sin(demo.t * Math.PI / 5);
  const g = demo.drag;
  if (g) {
    const e = demo.t - g.t0, u = smooth(e / g.ramp);
    tmp.copy(g.H).addScaledVector(g.off, u);
    if (g.wig && e > g.ramp) { tmp.x += 0.09 * Math.sin((e - g.ramp) * 7); tmp.y += 0.07 * Math.sin((e - g.ramp) * 9); }
    setGrabTarget(tmp);
    tmp2.copy(grab.P).project(camera);
    curEl.style.display = 'block';
    curEl.style.transform = 'translate(' + ((tmp2.x * 0.5 + 0.5) * window.innerWidth).toFixed(1) + 'px,' + ((-tmp2.y * 0.5 + 0.5) * window.innerHeight).toFixed(1) + 'px)';
    if (e > g.hold) dRelease();
  }
}
function endDemo() {
  if (!demo.on) return;
  demo.on = false; dRelease(); firmTarget = null; capEl.style.opacity = 0; curEl.style.display = 'none';
}
window.addEventListener('pointerdown', endDemo, true);
window.addEventListener('touchstart', endDemo, { capture: true, passive: true });
if (demo.on) hideHint();

/* ---------- main loop ---------- */
let last = performance.now(), acc = 0;
function frame(now) {
  requestAnimationFrame(frame);
  const dt = Math.min(0.05, Math.max(0, (now - last) / 1000)); last = now;
  updateCamera();
  if (demo.on) updateDemo(dt);
  if (firmTarget !== null) {
    const v = +slider.value, nv = v + (firmTarget - v) * Math.min(1, dt * 6);
    slider.value = Math.abs(firmTarget - nv) < 0.6 ? firmTarget : nv; applyFirm();
    if (+slider.value === firmTarget) firmTarget = null;
  }
  acc += dt; let n = 0;
  while (acc >= FRAME && n < 3) { updateSqueeze(FRAME); simFrame(); acc -= FRAME; n++; }
  if (acc > FRAME) acc = 0;
  updateDrops(dt);
  updateMesh();
  updateCamera();
  renderer.render(scene, camera);
}
requestAnimationFrame(frame);
</script>
</body>
</html>