Add five 3D assets written by Qwen3.5-4B-3D-Coder-OptiQ-4bit, as GLB plus source HTML

.gitattributes

@@ -58,3 +58,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+assets/cannon.glb filter=lfs diff=lfs merge=lfs -text
+assets/golem.glb filter=lfs diff=lfs merge=lfs -text
+assets/potions.glb filter=lfs diff=lfs merge=lfs -text
+assets/tower.glb filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,59 @@
+---
+license: apache-2.0
+pretty_name: OptiQ 3D Coder assets
+tags:
+- 3d
+- glb
+- gltf
+- three.js
+- game-assets
+- mlx
+- optiq
+- apple-silicon
+size_categories:
+- n<1K
+---
+
+# OptiQ 3D Coder assets
+
+Five game-style 3D assets written by [mlx-community/Qwen3.5-4B-3D-Coder-OptiQ-4bit](https://huggingface.co/mlx-community/Qwen3.5-4B-3D-Coder-OptiQ-4bit), a 4B model running locally on a Mac (M4, 24 GB). The model writes each asset as a single-file Three.js HTML scene. That code is unedited. The `.glb` files in `assets/` were exported from those generated scenes in a headless browser, so they can be viewed in the gallery here or dropped into a game engine.
+
+## Assets
+
+| Asset | GLB | Source | Prompt | Tokens |
+|---|---|---|---|---:|
+| Stone golem boss | [golem.glb](assets/golem.glb) | [HTML](source/golem.html), [front](source/golem-front.png), [side](source/golem-side.png) | Please create one self-contained HTML file with Three.js from cdnjs showing a stone golem boss with glowing green crystals growing from its shoulders. Make it a single game-ready asset: centred on a plain ground plane, a clear readable silhouette, built from separate named meshes, slowly turning on a turntable, with mouse orbit controls. | 10,771 |
+| Pirate deck cannon | [cannon.glb](assets/cannon.glb) | [HTML](source/cannon.html), [PNG](source/cannon.png) | Please create one self-contained HTML file with Three.js from cdnjs showing a pirate deck cannon on a wooden carriage with a stack of cannonballs. Make it a single game-ready asset: centred on a plain ground plane, a clear readable silhouette, built from separate named meshes, slowly turning on a turntable, with mouse orbit controls. | 14,269 |
+| Potion set | [potions.glb](assets/potions.glb) | [HTML](source/potions.html), [PNG](source/potions.png) | Please create one self-contained HTML file with Three.js from cdnjs showing a set of three potion bottles, red, blue and green, with corks, on a small wooden tray. Make it a single game-ready asset: centred on a plain ground plane, a clear readable silhouette, built from separate named meshes, slowly turning on a turntable, with mouse orbit controls. | 12,802 |
+| Voxel swamp goblin | [voxel-goblin.glb](assets/voxel-goblin.glb) | [HTML](source/voxel-goblin.html), [PNG](source/voxel-goblin.png) | Please create one self-contained HTML file with Three.js from cdnjs showing a swamp goblin enemy with big ears, a leather vest and a spiked wooden club. Render it as a deliberate 3D voxel model built from visible cubic blocks, with clear depth, readable silhouettes, and solid spatial relationships. Make it a single game-ready asset centred on a plain ground plane, slowly turning on a turntable, with mouse orbit controls. | 20,079 |
+| Castle guard tower | [tower.glb](assets/tower.glb) | [HTML](source/tower.html), [PNG](source/tower.png) | Please create one self-contained HTML file with Three.js from cdnjs showing a medieval castle guard tower module with battlements, a wooden door and a flag waving at the top. Make it a single game-ready asset: centred on a plain ground plane, a clear readable silhouette, built from separate named meshes, slowly turning on a turntable, with mouse orbit controls. | 14,070 |
+
+Token counts include the model's reasoning. Each run used this system prompt from the base model's author:
+
+```text
+Use only the Three.js core ES module from
+https://cdnjs.cloudflare.com/ajax/libs/three.js/0.160.0/three.module.min.js.
+Do not import addons or legacy examples/js paths;
+implement any camera controls directly inside the HTML.
+```
+
+Settings: temperature 0.6, top_p 0.95, top_k 20, no repetition penalty, `max_tokens` 64000, thinking on, seeded.
+
+## Notes
+
+- **These are picks, not a typical sample.** Of 18 attempts, 11 rendered in the browser, 3 crashed on load and 4 looped in reasoning until the 64k token cap. These five were chosen from the 11 that rendered.
+- **They aren't flawless.** The potions have no visible corks, the goblin's ears are flat from the side, and the tower's battlements are oversized.
+- **The GLBs are exports of the rendered scenes.** Each was exported with Three.js r160's `GLTFExporter` after the scene had built. The large ground plane, lights, fog, background and the golem's floating dust particles were left out, and animation is not included, so each file is the static asset. Materials are simplified in the conversion: glow, shadows and some non-standard materials won't look exactly as they do in the original page. Open the HTML in `source/` to see the scene as the model wrote it.
+
+## Run the model
+
+```bash
+pip install mlx-optiq
+optiq serve --model mlx-community/Qwen3.5-4B-3D-Coder-OptiQ-4bit
+```
+
+[OptiQ](https://mlx-optiq.com/?utm_source=huggingface&utm_medium=dataset&utm_campaign=3d_assets) is a free MLX toolkit to quantize, fine-tune and serve LLMs locally on Apple Silicon. [OptiQ Code](https://mlx-optiq.com/code?utm_source=huggingface&utm_medium=dataset&utm_campaign=3d_assets) is its coding agent.
+
+## Credits
+
+The base model is [ccore/Qwen3.5-4B-3D-Coder](https://huggingface.co/ccore/Qwen3.5-4B-3D-Coder), a Qwen3.5 4B fine-tune for writing Three.js scenes, released under Apache 2.0. This dataset uses the same license.

assets/cannon.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b160a01848479c3e1e79e1f672d2204744e448406f20b7c721b97b6eac426cc6
+size 986292

assets/golem.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3dd12412971e133253e52d7a26c7bf0219e8db74e06bb92a982845057a390b24
+size 125184

assets/potions.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8de4cf391f9d18567600b9ec39254152e644b7eb1031c0cd06c9a143396a2a0a
+size 367828

assets/tower.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91f148fde3ff23cb72f37746c3ce1feb33f80520e8632e688ae868e715b982df
+size 178576

source/cannon.html

@@ -0,0 +1,800 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Pirate Deck Cannon</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont,
+        "Segoe UI", sans-serif;
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    html,
+    body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+      overflow: hidden;
+      background: #0d1114;
+    }
+
+    #app {
+      position: fixed;
+      inset: 0;
+    }
+
+    canvas {
+      display: block;
+      width: 100%;
+      height: 100%;
+      cursor: grab;
+      touch-action: none;
+    }
+
+    canvas:active {
+      cursor: grabbing;
+    }
+
+    .title-card {
+      position: fixed;
+      top: 24px;
+      left: 26px;
+      z-index: 2;
+      max-width: min(390px, calc(100vw - 52px));
+      padding: 16px 18px;
+      color: #f4e7c9;
+      background: linear-gradient(145deg, rgba(24, 20, 15, 0.88), rgba(20, 17, 13, 0.72));
+      border: 1px solid rgba(225, 184, 111, 0.35);
+      border-radius: 14px;
+      box-shadow: 0 14px 40px rgba(0, 0, 0, 0.3);
+      backdrop-filter: blur(12px);
+      pointer-events: none;
+    }
+
+    .title-card h1 {
+      margin: 0 0 5px;
+      font-family: Georgia, "Times New Roman", serif;
+      font-size: clamp(22px, 3vw, 32px);
+      font-weight: 600;
+      letter-spacing: 0.025em;
+    }
+
+    .title-card p {
+      margin: 0;
+      color: #bda887;
+      font-size: 13px;
+      line-height: 1.45;
+    }
+
+    .controls-hint {
+      position: fixed;
+      right: 22px;
+      bottom: 20px;
+      z-index: 2;
+      padding: 9px 12px;
+      color: #c4b291;
+      background: rgba(12, 15, 17, 0.68);
+      border: 1px solid rgba(255, 255, 255, 0.08);
+      border-radius: 999px;
+      font-size: 12px;
+      letter-spacing: 0.02em;
+      pointer-events: none;
+      backdrop-filter: blur(8px);
+    }
+
+    @media (max-width: 600px) {
+      .title-card {
+        top: 14px;
+        left: 14px;
+        padding: 12px 14px;
+      }
+
+      .title-card p {
+        display: none;
+      }
+
+      .controls-hint {
+        right: 12px;
+        bottom: 12px;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div id="app"></div>
+
+  <div class="title-card">
+    <h1>Pirate Deck Cannon</h1>
+    <p>A turntable-ready cannon mounted on a wooden carriage, with a stacked load of cannonballs.</p>
+  </div>
+
+  <div class="controls-hint">Drag to orbit · Scroll to zoom · Double-click to reset</div>
+
+  <script type="module">
+    import * as THREE from "https://cdnjs.cloudflare.com/ajax/libs/three.js/0.160.0/three.module.min.js";
+
+    const app = document.getElementById("app");
+
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0x101518);
+    scene.fog = new THREE.Fog(0x101518, 17, 42);
+
+    const camera = new THREE.PerspectiveCamera(
+      38,
+      window.innerWidth / window.innerHeight,
+      0.1,
+      100
+    );
+
+    const renderer = new THREE.WebGLRenderer({
+      antialias: true,
+      powerPreference: "high-performance"
+    });
+
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    renderer.outputColorSpace = THREE.SRGBColorSpace;
+    renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    renderer.toneMappingExposure = 1.08;
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    renderer.domElement.setAttribute("aria-label", "Interactive 3D pirate deck cannon");
+    app.appendChild(renderer.domElement);
+
+    // Lighting
+    scene.add(new THREE.HemisphereLight(0xb8c9d3, 0x3a2618, 1.65));
+
+    const keyLight = new THREE.DirectionalLight(0xffe0ad, 3.2);
+    keyLight.position.set(5.5, 9, 6.5);
+    keyLight.castShadow = true;
+    keyLight.shadow.mapSize.set(2048, 2048);
+    keyLight.shadow.camera.left = -7;
+    keyLight.shadow.camera.right = 7;
+    keyLight.shadow.camera.top = 7;
+    keyLight.shadow.camera.bottom = -7;
+    keyLight.shadow.camera.near = 1;
+    keyLight.shadow.camera.far = 25;
+    keyLight.shadow.bias = -0.00035;
+    scene.add(keyLight);
+
+    const rimLight = new THREE.DirectionalLight(0x769ab4, 1.35);
+    rimLight.position.set(-6, 5, -5);
+    scene.add(rimLight);
+
+    const warmFill = new THREE.PointLight(0xd78b42, 22, 12, 2);
+    warmFill.position.set(2.5, 3.5, 3.5);
+    scene.add(warmFill);
+
+    // Deterministic procedural wood texture.
+    function createWoodTexture() {
+      const canvas = document.createElement("canvas");
+      canvas.width = 512;
+      canvas.height = 512;
+      const ctx = canvas.getContext("2d");
+
+      ctx.fillStyle = "#704327";
+      ctx.fillRect(0, 0, 512, 512);
+
+      let seed = 9137;
+      const random = () => {
+        seed = (seed * 16807) % 2147483647;
+        return (seed - 1) / 2147483646;
+      };
+
+      for (let y = -10; y < 530; y += 3) {
+        const amplitude = 2 + random() * 8;
+        const frequency = 0.012 + random() * 0.028;
+        const phase = random() * Math.PI * 2;
+
+        ctx.beginPath();
+        for (let x = 0; x <= 520; x += 8) {
+          const waveY =
+            y +
+            Math.sin(x * frequency + phase) * amplitude +
+            Math.sin(x * frequency * 0.43 + phase) * amplitude * 0.35;
+          if (x === 0) ctx.moveTo(x, waveY);
+          else ctx.lineTo(x, waveY);
+        }
+
+        ctx.strokeStyle = `rgba(35, 15, 7, ${0.08 + random() * 0.16})`;
+        ctx.lineWidth = 0.5 + random() * 2.2;
+        ctx.stroke();
+      }
+
+      for (let i = 0; i < 18; i++) {
+        const x = random() * 512;
+        const y = random() * 512;
+        const rx = 8 + random() * 25;
+        const ry = 2 + random() * 7;
+
+        ctx.beginPath();
+        ctx.ellipse(x, y, rx, ry, 0, 0, Math.PI * 2);
+        ctx.strokeStyle = "rgba(35, 15, 7, 0.16)";
+        ctx.lineWidth = 1.2;
+        ctx.stroke();
+      }
+
+      const texture = new THREE.CanvasTexture(canvas);
+      texture.colorSpace = THREE.SRGBColorSpace;
+      texture.wrapS = THREE.RepeatWrapping;
+      texture.wrapT = THREE.RepeatWrapping;
+      texture.repeat.set(2, 2);
+      texture.anisotropy = renderer.capabilities.getMaxAnisotropy();
+      return texture;
+    }
+
+    const woodTexture = createWoodTexture();
+
+    const materials = {
+      wood: new THREE.MeshStandardMaterial({
+        map: woodTexture,
+        color: 0xffffff,
+        roughness: 0.82,
+        metalness: 0.02
+      }),
+      darkWood: new THREE.MeshStandardMaterial({
+        map: woodTexture,
+        color: 0x8b5938,
+        roughness: 0.9,
+        metalness: 0.01
+      }),
+      iron: new THREE.MeshStandardMaterial({
+        color: 0x252b2d,
+        roughness: 0.48,
+        metalness: 0.78
+      }),
+      blackIron: new THREE.MeshStandardMaterial({
+        color: 0x101517,
+        roughness: 0.58,
+        metalness: 0.72
+      }),
+      steel: new THREE.MeshStandardMaterial({
+        color: 0x8b9291,
+        roughness: 0.35,
+        metalness: 0.9
+      }),
+      brass: new THREE.MeshStandardMaterial({
+        color: 0xb68a45,
+        roughness: 0.38,
+        metalness: 0.8
+      }),
+      ball: new THREE.MeshStandardMaterial({
+        color: 0x8d918e,
+        roughness: 0.42,
+        metalness: 0.82
+      }),
+      ballSeam: new THREE.MeshStandardMaterial({
+        color: 0x484d4c,
+        roughness: 0.55,
+        metalness: 0.68
+      }),
+      ground: new THREE.MeshStandardMaterial({
+        color: 0x252c2d,
+        roughness: 0.96,
+        metalness: 0.02
+      })
+    };
+
+    const model = new THREE.Group();
+    model.name = "Pirate deck cannon assembly";
+    scene.add(model);
+
+    const turntable = new THREE.Group();
+    turntable.name = "Rotating turntable";
+    model.add(turntable);
+
+    function addMesh(
+      geometry,
+      material,
+      parent,
+      position = [0, 0, 0],
+      rotation = [0, 0, 0],
+      name = "Unnamed mesh"
+    ) {
+      const mesh = new THREE.Mesh(geometry, material);
+      mesh.position.set(...position);
+      mesh.rotation.set(...rotation);
+      mesh.name = name;
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      parent.add(mesh);
+      return mesh;
+    }
+
+    // Turntable
+    addMesh(
+      new THREE.CylinderGeometry(2.08, 2.32, 0.24, 64),
+      materials.darkWood,
+      turntable,
+      [0, 0.12, 0],
+      [0, 0, 0],
+      "Turntable pedestal"
+    );
+
+    addMesh(
+      new THREE.CylinderGeometry(2.28, 2.28, 0.16, 64),
+      materials.wood,
+      turntable,
+      [0, 0.32, 0],
+      [0, 0, 0],
+      "Turntable deck"
+    );
+
+    addMesh(
+      new THREE.TorusGeometry(2.19, 0.035, 10, 80),
+      materials.brass,
+      turntable,
+      [0, 0.415, 0],
+      [Math.PI / 2, 0, 0],
+      "Turntable brass rim"
+    );
+
+    // Wooden carriage
+    const carriage = new THREE.Group();
+    carriage.name = "Wooden carriage";
+    model.add(carriage);
+
+    addMesh(
+      new THREE.BoxGeometry(4.8, 0.28, 3.2),
+      materials.wood,
+      carriage,
+      [0, 0.6, 0],
+      [0, 0, 0],
+      "Carriage deck"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(4.95, 0.13, 3.34),
+      materials.darkWood,
+      carriage,
+      [0, 0.78, 0],
+      [0, 0, 0],
+      "Carriage top rail"
+    );
+
+    for (const z of [-1.48, 1.48]) {
+      addMesh(
+        new THREE.BoxGeometry(4.85, 0.24, 0.18),
+        materials.darkWood,
+        carriage,
+        [0, 0.84, z],
+        [0, 0, 0],
+        "Carriage side rail"
+      );
+    }
+
+    for (const x of [-1.72, 1.72]) {
+      addMesh(
+        new THREE.BoxGeometry(0.22, 0.25, 2.85),
+        materials.darkWood,
+        carriage,
+        [x, 0.79, 0],
+        [0, 0, 0],
+        "Carriage cross brace"
+      );
+    }
+
+    for (const x of [-2.02, 2.02]) {
+      addMesh(
+        new THREE.BoxGeometry(0.2, 0.22, 2.9),
+        materials.darkWood,
+        carriage,
+        [x, 0.78, 0],
+        [0, 0, 0],
+        "Carriage end brace"
+      );
+    }
+
+    // Deck bolts
+    for (const x of [-1.9, -0.95, 0.1, 1.15, 2.1]) {
+      for (const z of [-1.48, 1.48]) {
+        addMesh(
+          new THREE.CylinderGeometry(0.055, 0.055, 0.035, 12),
+          materials.brass,
+          carriage,
+          [x, 0.865, z],
+          [0, 0, 0],
+          "Carriage bolt"
+        );
+      }
+    }
+
+    // Four wooden carriage wheels
+    function createWheel(x, z, facing) {
+      const wheel = new THREE.Group();
+      wheel.name = "Carriage wheel";
+      wheel.position.set(x, 0.57, z);
+      carriage.add(wheel);
+
+      addMesh(
+        new THREE.CylinderGeometry(0.55, 0.55, 0.34, 32),
+        materials.darkWood,
+        wheel,
+        [0, 0, 0],
+        [Math.PI / 2, 0, 0],
+        "Wheel rim"
+      );
+
+      addMesh(
+        new THREE.TorusGeometry(0.45, 0.075, 8, 36),
+        materials.wood,
+        wheel,
+        [0, 0, 0],
+        [0, 0, 0],
+        "Wheel outer rim"
+      );
+
+      addMesh(
+        new THREE.CylinderGeometry(0.19, 0.19, 0.4, 20),
+        materials.iron,
+        wheel,
+        [0, 0, 0],
+        [Math.PI / 2, 0, 0],
+        "Wheel hub"
+      );
+
+      const spokeZ = facing * 0.18;
+      for (let i = 0; i < 6; i++) {
+        const angle = (i / 6) * Math.PI * 2;
+        addMesh(
+          new THREE.BoxGeometry(1.02, 0.09, 0.065),
+          materials.wood,
+          wheel,
+          [Math.cos(angle) * 0.39, Math.sin(angle) * 0.39, spokeZ],
+          [0, 0, angle],
+          "Carriage wheel spoke"
+        );
+      }
+    }
+
+    createWheel(-1.72, -1.38, -1);
+    createWheel(1.72, -1.38, -1);
+    createWheel(-1.72, 1.38, 1);
+    createWheel(1.72, 1.38, 1);
+
+    // Deck cannon
+    const cannon = new THREE.Group();
+    cannon.name = "Iron deck cannon";
+    model.add(cannon);
+
+    // Barrel support cheeks
+    for (const z of [-0.5, 0.5]) {
+      addMesh(
+        new THREE.BoxGeometry(0.52, 0.34, 0.25),
+        materials.iron,
+        cannon,
+        [-0.18, 1.19, z],
+        [0, 0, 0],
+        "Cannon cheek block"
+      );
+    }
+
+    // Trunnion
+    addMesh(
+      new THREE.CylinderGeometry(0.28, 0.33, 0.55, 24),
+      materials.iron,
+      cannon,
+      [-0.62, 1.34, 0],
+      [0, 0, Math.PI / 2],
+      "Cannon trunnion"
+    );
+
+    // Main barrel, tapering toward the muzzle
+    addMesh(
+      new THREE.CylinderGeometry(0.19, 0.34, 2.65, 28),
+      materials.iron,
+      cannon,
+      [0.85, 1.31, 0],
+      [0, 0, -Math.PI / 2],
+      "Cannon barrel"
+    );
+
+    // Barrel bands
+    addMesh(
+      new THREE.TorusGeometry(0.345, 0.045, 8, 36),
+      materials.iron,
+      cannon,
+      [-0.49, 1.31, 0],
+      [0, Math.PI / 2, 0],
+      "Rear barrel band"
+    );
+
+    addMesh(
+      new THREE.TorusGeometry(0.315, 0.04, 8, 36),
+      materials.iron,
+      cannon,
+      [0.12, 1.31, 0],
+      [0, Math.PI / 2, 0],
+      "Middle barrel band"
+    );
+
+    addMesh(
+      new THREE.TorusGeometry(0.225, 0.045, 8, 36),
+      materials.iron,
+      cannon,
+      [2.19, 1.31, 0],
+      [0, Math.PI / 2, 0],
+      "Muzzle barrel band"
+    );
+
+    // Dark bore and muzzle lip
+    addMesh(
+      new THREE.CylinderGeometry(0.13, 0.16, 0.2, 24),
+      materials.blackIron,
+      cannon,
+      [2.28, 1.31, 0],
+      [0, 0, -Math.PI / 2],
+      "Cannon bore"
+    );
+
+    addMesh(
+      new THREE.TorusGeometry(0.19, 0.025, 8, 32),
+      materials.steel,
+      cannon,
+      [2.31, 1.31, 0],
+      [0, Math.PI / 2, 0],
+      "Muzzle lip"
+    );
+
+    // Rear collar and sight
+    addMesh(
+      new THREE.CylinderGeometry(0.37, 0.37, 0.18, 24),
+      materials.iron,
+      cannon,
+      [-0.72, 1.34, 0],
+      [0, 0, Math.PI / 2],
+      "Cannon rear collar"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.18, 0.13, 0.12),
+      materials.brass,
+      cannon,
+      [-0.56, 1.58, 0.5],
+      [0, 0, 0],
+      "Front sight"
+    );
+
+    addMesh(
+      new THREE.CylinderGeometry(0.055, 0.055, 0.3, 12),
+      materials.brass,
+      cannon,
+      [-0.56, 1.49, 0.5],
+      [0, 0, 0],
+      "Sight post"
+    );
+
+    // Handle behind the cannon
+    for (const z of [-0.28, 0.28]) {
+      addMesh(
+        new THREE.CylinderGeometry(0.045, 0.045, 0.48, 12),
+        materials.iron,
+        cannon,
+        [-0.92, 1.31, z],
+        [0, 0, Math.PI / 2],
+        "Handle post"
+      );
+    }
+
+    addMesh(
+      new THREE.BoxGeometry(0.18, 0.12, 0.72),
+      materials.iron,
+      cannon,
+      [-0.92, 1.56, 0],
+      [0, 0, 0],
+      "Cannon handle"
+    );
+
+    // Cannonball stack
+    const ballStack = new THREE.Group();
+    ballStack.name = "Stack of cannonballs";
+    model.add(ballStack);
+
+    const ballPositions = [
+      [-2.02, 1.76, 0.95],
+      [-1.52, 1.76, 0.95],
+      [-1.02, 1.76, 0.95],
+      [-1.77, 2.54, 0.95],
+      [-1.27, 2.54, 0.95],
+      [-1.52, 3.32, 0.95]
+    ];
+
+    for (const [x, y, z] of ballPositions) {
+      const radius = 0.38;
+
+      addMesh(
+        new THREE.SphereGeometry(radius, 32, 24),
+        materials.ball,
+        ballStack,
+        [x, y, z],
+        [0, 0, 0],
+        "Cannonball"
+      );
+
+      // Equatorial seam
+      addMesh(
+        new THREE.TorusGeometry(radius + 0.006, 0.014, 6, 36),
+        materials.ballSeam,
+        ballStack,
+        [x, y, z],
+        [Math.PI / 2, 0, 0],
+        "Cannonball equatorial seam"
+      );
+
+      // Vertical seam
+      addMesh(
+        new THREE.TorusGeometry(radius + 0.006, 0.012, 6, 36),
+        materials.ballSeam,
+        ballStack,
+        [x, y, z],
+        [0, 0, 0],
+        "Cannonball vertical seam"
+      );
+    }
+
+    // Small brass carriage plaque
+    const plaque = new THREE.Group();
+    plaque.name = "Carriage plaque";
+    plaque.position.set(0, 0.87, 1.675);
+    carriage.add(plaque);
+
+    addMesh(
+      new THREE.BoxGeometry(1.45, 0.28, 0.035),
+      materials.brass,
+      plaque,
+      [0, 0, 0],
+      [0, 0, 0],
+      "Carriage plaque"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.34, 0.035, 0.012),
+      materials.iron,
+      plaque,
+      [-0.38, 0, 0.025],
+      [0, 0, 0],
+      "Plaque inset"
+    );
+
+    // Plain ground plane
+    const ground = addMesh(
+      new THREE.PlaneGeometry(100, 100),
+      materials.ground,
+      scene,
+      [0, 0, 0],
+      [-Math.PI / 2, 0, 0],
+      "Plain ground plane"
+    );
+    ground.castShadow = false;
+
+    // Custom orbit controls implemented without external addons.
+    const cameraTarget = new THREE.Vector3(0, 1.35, 0);
+    const desired = {
+      theta: 0.72,
+      phi: 1.08,
+      radius: 10.6
+    };
+    const current = {
+      theta: desired.theta,
+      phi: desired.phi,
+      radius: desired.radius
+    };
+
+    let dragging = false;
+    let previousX = 0;
+    let previousY = 0;
+
+    function updateCamera() {
+      current.theta += (desired.theta - current.theta) * 0.08;
+      current.phi += (desired.phi - current.phi) * 0.08;
+      current.radius += (desired.radius - current.radius) * 0.08;
+
+      const sinPhi = Math.sin(current.phi);
+      camera.position.set(
+        cameraTarget.x + current.radius * sinPhi * Math.sin(current.theta),
+        cameraTarget.y + current.radius * Math.cos(current.phi),
+        cameraTarget.z + current.radius * sinPhi * Math.cos(current.theta)
+      );
+      camera.lookAt(cameraTarget);
+    }
+
+    function resetCamera() {
+      desired.theta = 0.72;
+      desired.phi = 1.08;
+      desired.radius = 10.6;
+    }
+
+    renderer.domElement.addEventListener("pointerdown", (event) => {
+      dragging = true;
+      previousX = event.clientX;
+      previousY = event.clientY;
+      renderer.domElement.setPointerCapture(event.pointerId);
+    });
+
+    renderer.domElement.addEventListener("pointermove", (event) => {
+      if (!dragging) return;
+
+      const deltaX = event.clientX - previousX;
+      const deltaY = event.clientY - previousY;
+      previousX = event.clientX;
+      previousY = event.clientY;
+
+      desired.theta -= deltaX * 0.006;
+      desired.phi = THREE.MathUtils.clamp(
+        desired.phi - deltaY * 0.005,
+        0.34,
+        1.48
+      );
+    });
+
+    function endDrag(event) {
+      dragging = false;
+      if (renderer.domElement.hasPointerCapture(event.pointerId)) {
+        renderer.domElement.releasePointerCapture(event.pointerId);
+      }
+    }
+
+    renderer.domElement.addEventListener("pointerup", endDrag);
+    renderer.domElement.addEventListener("pointercancel", endDrag);
+    renderer.domElement.addEventListener("contextmenu", (event) => event.preventDefault());
+
+    renderer.domElement.addEventListener(
+      "wheel",
+      (event) => {
+        event.preventDefault();
+        desired.radius = THREE.MathUtils.clamp(
+          desired.radius * Math.exp(event.deltaY * 0.001),
+          5.5,
+          18
+        );
+      },
+      { passive: false }
+    );
+
+    renderer.domElement.addEventListener("dblclick", resetCamera);
+
+    window.addEventListener("keydown", (event) => {
+      if (event.key === "ArrowLeft") desired.theta += 0.12;
+      if (event.key === "ArrowRight") desired.theta -= 0.12;
+      if (event.key === "ArrowUp") desired.phi = Math.max(0.34, desired.phi - 0.08);
+      if (event.key === "ArrowDown") desired.phi = Math.min(1.48, desired.phi + 0.08);
+      if (event.key === "+" || event.key === "=") desired.radius = Math.max(5.5, desired.radius - 0.5);
+      if (event.key === "-") desired.radius = Math.min(18, desired.radius + 0.5);
+    });
+
+    window.addEventListener("resize", () => {
+      camera.aspect = window.innerWidth / window.innerHeight;
+      camera.updateProjectionMatrix();
+      renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+      renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+
+    const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    const turntableSpeed = reducedMotion ? 0.035 : 0.22;
+    const initialTurn = reducedMotion ? 0 : -0.28;
+    let elapsed = 0;
+
+    const clock = new THREE.Clock();
+
+    function animate() {
+      requestAnimationFrame(animate);
+
+      const delta = Math.min(clock.getDelta(), 0.05);
+      elapsed += delta;
+
+      turntable.rotation.y = initialTurn + elapsed * turntableSpeed;
+      updateCamera();
+      renderer.render(scene, camera);
+    }
+
+    updateCamera();
+    animate();
+  </script>
+</body>
+</html>

source/golem.html

@@ -0,0 +1,898 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Stone Golem Boss</title>
+
+  <style>
+    :root {
+      color-scheme: dark;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont,
+        "Segoe UI", sans-serif;
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    html,
+    body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+      overflow: hidden;
+      background:
+        radial-gradient(circle at 50% 35%, #172126 0%, #080c0e 48%, #030506 100%);
+    }
+
+    #stage {
+      position: fixed;
+      inset: 0;
+    }
+
+    canvas {
+      display: block;
+      width: 100%;
+      height: 100%;
+      touch-action: none;
+      cursor: grab;
+    }
+
+    canvas:active {
+      cursor: grabbing;
+    }
+
+    .hud {
+      position: fixed;
+      z-index: 10;
+      pointer-events: none;
+      user-select: none;
+    }
+
+    .title {
+      top: 28px;
+      left: 30px;
+      max-width: min(420px, calc(100vw - 60px));
+    }
+
+    .eyebrow {
+      margin-bottom: 8px;
+      color: #75e58c;
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.24em;
+      text-transform: uppercase;
+    }
+
+    h1 {
+      margin: 0;
+      color: #edf4f1;
+      font-size: clamp(25px, 4vw, 48px);
+      font-weight: 800;
+      line-height: 0.98;
+      letter-spacing: -0.04em;
+      text-transform: uppercase;
+      text-shadow: 0 0 30px rgba(47, 225, 116, 0.22);
+    }
+
+    .subtitle {
+      margin-top: 12px;
+      color: #8d9b9b;
+      font-size: 12px;
+      line-height: 1.5;
+      letter-spacing: 0.06em;
+    }
+
+    .controls {
+      right: 24px;
+      bottom: 24px;
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      pointer-events: auto;
+    }
+
+    .hint {
+      color: #899595;
+      font-size: 11px;
+      letter-spacing: 0.05em;
+    }
+
+    button {
+      border: 1px solid rgba(117, 229, 140, 0.35);
+      border-radius: 999px;
+      padding: 9px 14px;
+      color: #bfe9a3;
+      background: rgba(12, 22, 22, 0.72);
+      font: inherit;
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      cursor: pointer;
+      backdrop-filter: blur(10px);
+      transition: background 160ms ease, border-color 160ms ease, transform 160ms ease;
+    }
+
+    button:hover {
+      border-color: rgba(117, 229, 140, 0.75);
+      background: rgba(20, 38, 35, 0.88);
+      transform: translateY(-1px);
+    }
+
+    .status {
+      top: 30px;
+      right: 28px;
+      display: flex;
+      align-items: center;
+      gap: 9px;
+      color: #7d8b8b;
+      font-size: 10px;
+      font-weight: 700;
+      letter-spacing: 0.16em;
+      text-transform: uppercase;
+    }
+
+    .status::before {
+      width: 7px;
+      height: 7px;
+      border-radius: 50%;
+      background: #55ff91;
+      box-shadow: 0 0 12px #55ff91;
+      content: "";
+    }
+
+    #loading {
+      position: fixed;
+      inset: 0;
+      z-index: 20;
+      display: grid;
+      place-items: center;
+      color: #7ce38c;
+      background: #070b0c;
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.2em;
+      text-transform: uppercase;
+      transition: opacity 500ms ease;
+    }
+
+    #loading.hidden {
+      opacity: 0;
+      pointer-events: none;
+    }
+
+    @media (max-width: 620px) {
+      .title {
+        top: 20px;
+        left: 20px;
+      }
+
+      .subtitle {
+        max-width: 270px;
+      }
+
+      .status {
+        display: none;
+      }
+
+      .controls {
+        right: 16px;
+        bottom: 16px;
+      }
+
+      .hint {
+        display: none;
+      }
+    }
+  </style>
+</head>
+
+<body>
+  <div id="stage"></div>
+
+  <div class="hud title">
+    <div class="eyebrow">Sector 07 · Final Guardian</div>
+    <h1>Stone Golem</h1>
+    <div class="subtitle">
+      An ancient guardian awakened by a surge of corrupted bio-luminescent energy.
+    </div>
+  </div>
+
+  <div class="hud status">Turntable active</div>
+
+  <div class="hud controls">
+    <span class="hint">Drag to orbit · Scroll to zoom</span>
+    <button id="rotateButton" type="button">Pause rotation</button>
+  </div>
+
+  <div id="loading">Forging the guardian…</div>
+
+  <script type="module">
+    import * as THREE from "https://cdnjs.cloudflare.com/ajax/libs/three.js/0.160.0/three.module.min.js";
+
+    const stage = document.getElementById("stage");
+    const loading = document.getElementById("loading");
+    const rotateButton = document.getElementById("rotateButton");
+
+    // ---------------------------------------------------------------------
+    // Renderer and scene
+    // ---------------------------------------------------------------------
+
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0x070b0c);
+    scene.fog = new THREE.Fog(0x070b0c, 17, 43);
+
+    const camera = new THREE.PerspectiveCamera(
+      42,
+      window.innerWidth / window.innerHeight,
+      0.1,
+      100
+    );
+
+    const renderer = new THREE.WebGLRenderer({
+      antialias: true,
+      powerPreference: "high-performance"
+    });
+
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    renderer.outputColorSpace = THREE.SRGBColorSpace;
+    renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    renderer.toneMappingExposure = 1.12;
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    stage.appendChild(renderer.domElement);
+
+    const hemi = new THREE.HemisphereLight(0x9ab4c4, 0x17120b, 1.25);
+    scene.add(hemi);
+
+    const keyLight = new THREE.DirectionalLight(0xffe1b0, 3.2);
+    keyLight.position.set(6, 11, 8);
+    keyLight.castShadow = true;
+    keyLight.shadow.mapSize.set(2048, 2048);
+    keyLight.shadow.camera.left = -8;
+    keyLight.shadow.camera.right = 8;
+    keyLight.shadow.camera.top = 10;
+    keyLight.shadow.camera.bottom = -4;
+    keyLight.shadow.camera.near = 1;
+    keyLight.shadow.camera.far = 28;
+    keyLight.shadow.bias = -0.0005;
+    scene.add(keyLight);
+
+    const rimLight = new THREE.DirectionalLight(0x43d99a, 2.1);
+    rimLight.position.set(-7, 5, -6);
+    scene.add(rimLight);
+
+    const frontFill = new THREE.PointLight(0x677b78, 12, 18, 2);
+    frontFill.position.set(0, 4, 7);
+    scene.add(frontFill);
+
+    // ---------------------------------------------------------------------
+    // Materials
+    // ---------------------------------------------------------------------
+
+    const stoneMaterial = new THREE.MeshStandardMaterial({
+      color: 0x667073,
+      roughness: 0.92,
+      metalness: 0.08
+    });
+
+    const darkStoneMaterial = new THREE.MeshStandardMaterial({
+      color: 0x343d40,
+      roughness: 0.98,
+      metalness: 0.04
+    });
+
+    const wornStoneMaterial = new THREE.MeshStandardMaterial({
+      color: 0x858b87,
+      roughness: 0.95,
+      metalness: 0.03
+    });
+
+    const armorMaterial = new THREE.MeshStandardMaterial({
+      color: 0x414b4d,
+      roughness: 0.68,
+      metalness: 0.48
+    });
+
+    const ironMaterial = new THREE.MeshStandardMaterial({
+      color: 0x20282b,
+      roughness: 0.58,
+      metalness: 0.72
+    });
+
+    const crackMaterial = new THREE.LineBasicMaterial({
+      color: 0x171b1c,
+      transparent: true,
+      opacity: 0.72
+    });
+
+    const crystalMaterial = new THREE.MeshStandardMaterial({
+      color: 0x8dffa5,
+      emissive: 0x2dff65,
+      emissiveIntensity: 1.7,
+      roughness: 0.28,
+      metalness: 0.12,
+      flatShading: true
+    });
+
+    const crystalCoreMaterial = new THREE.MeshStandardMaterial({
+      color: 0xd6ffbf,
+      emissive: 0x75ff9d,
+      emissiveIntensity: 2.4,
+      roughness: 0.2,
+      metalness: 0.08,
+      flatShading: true
+    });
+
+    const eyeMaterial = new THREE.MeshStandardMaterial({
+      color: 0x82e8a3,
+      emissive: 0x35ff83,
+      emissiveIntensity: 1.5,
+      roughness: 0.25
+    });
+
+    const edgeMaterial = new THREE.LineBasicMaterial({
+      color: 0x252d2e,
+      transparent: true,
+      opacity: 0.65
+    });
+
+    // ---------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------
+
+    const boss = new THREE.Group();
+    boss.position.y = 0.02;
+    scene.add(boss);
+
+    function box(
+      width,
+      height,
+      depth,
+      material,
+      x,
+      y,
+      z,
+      parent = boss,
+      name = "stone-part"
+    ) {
+      const mesh = new THREE.Mesh(
+        new THREE.BoxGeometry(width, height, depth),
+        material
+      );
+
+      mesh.position.set(x, y, z);
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      mesh.name = name;
+      parent.add(mesh);
+
+      return mesh;
+    }
+
+    function cylinder(
+      radiusTop,
+      radiusBottom,
+      height,
+      material,
+      x,
+      y,
+      z,
+      parent = boss,
+      name = "stone-part"
+    ) {
+      const mesh = new THREE.Mesh(
+        new THREE.CylinderGeometry(radiusTop, radiusBottom, height, 12),
+        material
+      );
+
+      mesh.position.set(x, y, z);
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      mesh.name = name;
+      parent.add(mesh);
+
+      return mesh;
+    }
+
+    function addEdges(mesh, opacity = 0.55) {
+      const edges = new THREE.LineSegments(
+        new THREE.EdgesGeometry(mesh.geometry),
+        new THREE.LineBasicMaterial({
+          color: 0x1c2527,
+          transparent: true,
+          opacity
+        })
+      );
+
+      edges.position.copy(mesh.position);
+      mesh.parent.add(edges);
+      return edges;
+    }
+
+    // ---------------------------------------------------------------------
+    // Ground and subtle environmental marker
+    // ---------------------------------------------------------------------
+
+    const ground = new THREE.Mesh(
+      new THREE.PlaneGeometry(80, 80),
+      new THREE.MeshStandardMaterial({
+        color: 0x111719,
+        roughness: 1,
+        metalness: 0
+      })
+    );
+
+    ground.rotation.x = -Math.PI / 2;
+    ground.position.y = -0.015;
+    ground.receiveShadow = true;
+    scene.add(ground);
+
+    const halo = new THREE.Mesh(
+      new THREE.RingGeometry(3.6, 3.63, 96),
+      new THREE.MeshBasicMaterial({
+        color: 0x55ff8a,
+        transparent: true,
+        opacity: 0.18,
+        side: THREE.DoubleSide,
+        depthWrite: false
+      })
+    );
+
+    halo.rotation.x = -Math.PI / 2;
+    halo.position.y = 0.008;
+    scene.add(halo);
+
+    const innerHalo = new THREE.Mesh(
+      new THREE.RingGeometry(2.25, 2.265, 96),
+      new THREE.MeshBasicMaterial({
+        color: 0x85ff9d,
+        transparent: true,
+        opacity: 0.3,
+        side: THREE.DoubleSide,
+        depthWrite: false
+      })
+    );
+
+    innerHalo.rotation.x = -Math.PI / 2;
+    innerHalo.position.y = 0.012;
+    scene.add(innerHalo);
+
+    // ---------------------------------------------------------------------
+    // Legs and feet
+    // ---------------------------------------------------------------------
+
+    const leftLeg = box(
+      1.55, 2.65, 1.75,
+      stoneMaterial,
+      -1.02, 1.55, 0,
+      boss,
+      "left-thigh"
+    );
+    addEdges(leftLeg, 0.4);
+
+    const rightLeg = box(
+      1.55, 2.65, 1.75,
+      stoneMaterial,
+      1.02, 1.55, 0,
+      boss,
+      "right-thigh"
+    );
+    addEdges(rightLeg, 0.4);
+
+    const leftFoot = box(
+      2.05, 0.55, 2.45,
+      darkStoneMaterial,
+      -1.02, 0.32, 0.1,
+      boss,
+      "left-foot"
+    );
+
+    const rightFoot = box(
+      2.05, 0.55, 2.45,
+      darkStoneMaterial,
+      1.02, 0.32, 0.1,
+      boss,
+      "right-foot"
+    );
+
+    // ---------------------------------------------------------------------
+    // Torso, chest, neck, and head
+    // ---------------------------------------------------------------------
+
+    const lowerTorso = box(
+      3.15, 4.15, 3.0,
+      stoneMaterial,
+      0, 2.68, 0,
+      boss,
+      "lower-torso"
+    );
+    addEdges(lowerTorso, 0.32);
+
+    const chest = box(
+      3.45, 1.75, 3.25,
+      wornStoneMaterial,
+      0, 4.25, 0,
+      boss,
+      "chest-plate"
+    );
+    addEdges(chest, 0.38);
+
+    const upperTorso = box(
+      2.75, 1.1, 2.65,
+      stoneMaterial,
+      0, 5.3, 0,
+      boss,
+      "upper-torso"
+    );
+
+    const neck = box(
+      1.35, 1.1, 1.5,
+      darkStoneMaterial,
+      0, 5.7, 0,
+      boss,
+      "neck"
+    );
+    addEdges(neck, 0.4);
+
+    const skull = box(
+      2.35, 1.65, 2.05,
+      stoneMaterial,
+      0, 6.45, 0,
+      boss,
+      "skull"
+    );
+    addEdges(skull, 0.45);
+
+    const jaw = box(
+      2.65, 0.65, 2.18,
+      darkStoneMaterial,
+      0, 5.55, 0.04,
+      boss,
+      "jaw"
+    );
+
+    // Brow ridges.
+    box(0.85, 0.34, 0.42, darkStoneMaterial, -0.78, 6.94, 0.72, boss, "left-brow");
+    box(0.85, 0.34, 0.42, darkStoneMaterial, 0.78, 6.94, 0.72, boss, "right-brow");
+
+    // Eye sockets and luminous cores.
+    box(0.34, 0.43, 0.18, ironMaterial, -0.57, 6.55, 1.02, boss, "left-eye-socket");
+    box(0.34, 0.43, 0.18, ironMaterial, 0.57, 6.55, 1.02, boss, "right-eye-socket");
+
+    box(0.18, 0.25, 0.12, eyeMaterial, -0.57, 6.55, 1.13, boss, "left-eye");
+    box(0.18, 0.25, 0.12, eyeMaterial, 0.57, 6.55, 1.13, boss, "right-eye");
+
+    // Mouth and cheek stones.
+    box(1.45, 0.16, 0.12, ironMaterial, 0, 5.92, 1.06, boss, "mouth");
+    box(0.45, 0.55, 0.4, darkStoneMaterial, -0.9, 6.08, 0.85, boss, "left-cheek");
+    box(0.45, 0.55, 0.4, darkStoneMaterial, 0.9, 6.08, 0.85, boss, "right-cheek");
+
+    // ---------------------------------------------------------------------
+    // Arms, gauntlets, and shoulder armor
+    // ---------------------------------------------------------------------
+
+    for (const side of [-1, 1]) {
+      const upperArm = box(
+        1.35, 2.15, 1.45,
+        stoneMaterial,
+        side * 2.35, 3.2, 0,
+        boss,
+        `${side === -1 ? "left" : "right"}-upper-arm`
+      );
+      addEdges(upperArm, 0.3);
+
+      const forearm = box(
+        1.0, 2.45, 1.18,
+        wornStoneMaterial,
+        side * 3.08, 2.0, 0.05,
+        boss,
+        `${side === -1 ? "left" : "right"}-forearm`
+      );
+      addEdges(forearm, 0.3);
+
+      const hand = box(
+        1.05, 1.05, 1.15,
+        ironMaterial,
+        side * 3.08, 1.05, 0.08,
+        boss,
+        `${side === -1 ? "left" : "right"}-hand`
+      );
+      addEdges(hand, 0.35);
+
+      const shoulderPad = box(
+        1.7, 0.72, 1.55,
+        armorMaterial,
+        side * 2.2, 4.18, 0.05,
+        boss,
+        `${side === -1 ? "left" : "right"}-shoulder-pad`
+      );
+      addEdges(shoulderPad, 0.35);
+
+      const gauntlet = box(
+        1.12, 0.75, 1.22,
+        ironMaterial,
+        side * 3.05, 1.67, 0.08,
+        boss,
+        `${side === -1 ? "left" : "right"}-gauntlet`
+      );
+      addEdges(gauntlet, 0.3);
+    }
+
+    // Belt and chest trim.
+    const belt = new THREE.Mesh(
+      new THREE.TorusGeometry(1.62, 0.16, 8, 40),
+      ironMaterial
+    );
+    belt.rotation.x = Math.PI / 2;
+    belt.position.y = 2.45;
+    belt.castShadow = true;
+    boss.add(belt);
+
+    box(0.8, 0.22, 0.12, ironMaterial, 0, 4.9, 1.68, boss, "chest-trim");
+
+    // ---------------------------------------------------------------------
+    // Glowing green shoulder crystal clusters
+    // ---------------------------------------------------------------------
+
+    const animatedCrystals = [];
+
+    function createShoulderCrystals(side) {
+      const cluster = new THREE.Group();
+      cluster.position.set(side * 2.18, 4.38, 0.52);
+      cluster.rotation.z = side * 0.035;
+      cluster.name = `${side === -1 ? "left" : "right"}-crystal-cluster`;
+      boss.add(cluster);
+
+      const stem = box(
+        0.22, 0.55, 0.22,
+        ironMaterial,
+        0, 0.25, 0,
+        cluster,
+        "crystal-stem"
+      );
+      addEdges(stem, 0.25);
+
+      const centralCrystal = new THREE.Mesh(
+        new THREE.ConeGeometry(0.42, 1.55, 5, 1),
+        crystalMaterial
+      );
+      centralCrystal.position.set(0, 1.13, 0);
+      centralCrystal.castShadow = true;
+      centralCrystal.name = "central-shoulder-crystal";
+      cluster.add(centralCrystal);
+
+      const sideCrystals = [
+        { x: -0.46, y: 0.86, scale: 0.72 },
+        { x: 0.46, y: 0.86, scale: 0.72 },
+        { x: 0, y: 0.68, scale: 0.48 }
+      ];
+
+      for (const shard of sideCrystals) {
+        const crystal = new THREE.Mesh(
+          new THREE.OctahedronGeometry(0.34, 0),
+          crystalMaterial
+        );
+
+        crystal.position.set(shard.x, shard.y, 0.02);
+        crystal.scale.setScalar(shard.scale);
+        crystal.rotation.y = shard.x * 0.7;
+        crystal.castShadow = true;
+        crystal.name = `shoulder-${side === -1 ? "left" : "right"}-crystal`;
+        cluster.add(crystal);
+      }
+
+      const clusterLight = new THREE.PointLight(0x4dff78, 4.2, 5, 2);
+      clusterLight.position.set(0, 1.15, 0.2);
+      cluster.add(clusterLight);
+
+      animatedCrystals.push({
+        group: cluster,
+        phase: side * 1.7,
+        baseScale: 1
+      });
+    }
+
+    createShoulderCrystals(-1);
+    createShoulderCrystals(1);
+
+    // A smaller crystal at the center of the chest.
+    const chestCrystal = new THREE.Mesh(
+      new THREE.OctahedronGeometry(0.38, 0),
+      crystalCoreMaterial
+    );
+    chestCrystal.position.set(0, 4.75, 1.2);
+    chestCrystal.castShadow = true;
+    boss.add(chestCrystal);
+
+    const chestLight = new THREE.PointLight(0x3dff83, 2.8, 4, 2);
+    chestLight.position.set(0, 4.75, 1.35);
+    boss.add(chestLight);
+
+    // ---------------------------------------------------------------------
+    // Small environmental particles
+    // ---------------------------------------------------------------------
+
+    const particleCount = 28;
+    const particlePositions = new Float32Array(particleCount * 3);
+
+    for (let i = 0; i < particleCount; i++) {
+      const angle = Math.random() * Math.PI * 2;
+      const radius = 2.5 + Math.random() * 5;
+      particlePositions[i * 3] = Math.cos(angle) * radius;
+      particlePositions[i * 3 + 1] = 0.3 + Math.random() * 4.5;
+      particlePositions[i * 3 + 2] = Math.sin(angle) * radius;
+    }
+
+    const particleGeometry = new THREE.BufferGeometry();
+    particleGeometry.setAttribute(
+      "position",
+      new THREE.BufferAttribute(particlePositions, 3)
+    );
+
+    const particles = new THREE.Points(
+      particleGeometry,
+      new THREE.PointsMaterial({
+        color: 0x65ff91,
+        size: 0.045,
+        transparent: true,
+        opacity: 0.65,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending
+      })
+    );
+
+    scene.add(particles);
+
+    // ---------------------------------------------------------------------
+    // Custom camera controls
+    // ---------------------------------------------------------------------
+
+    const cameraState = {
+      radius: 12.2,
+      theta: 0.72,
+      phi: 1.17,
+      target: new THREE.Vector3(0, 3.25, 0)
+    };
+
+    const defaultCamera = { ...cameraState };
+
+    function updateCamera() {
+      const sinPhi = Math.sin(cameraState.phi);
+
+      camera.position.set(
+        cameraState.target.x +
+          cameraState.radius * sinPhi * Math.sin(cameraState.theta),
+        cameraState.target.y +
+          cameraState.radius * Math.cos(cameraState.phi),
+        cameraState.target.z +
+          cameraState.radius * sinPhi * Math.cos(cameraState.theta)
+      );
+
+      camera.lookAt(cameraState.target);
+    }
+
+    updateCamera();
+
+    let dragging = false;
+    let pointerX = 0;
+    let pointerY = 0;
+
+    renderer.domElement.addEventListener("pointerdown", (event) => {
+      dragging = true;
+      pointerX = event.clientX;
+      pointerY = event.clientY;
+      renderer.domElement.setPointerCapture(event.pointerId);
+    });
+
+    renderer.domElement.addEventListener("pointermove", (event) => {
+      if (!dragging) return;
+
+      const deltaX = event.clientX - pointerX;
+      const deltaY = event.clientY - pointerY;
+
+      pointerX = event.clientX;
+      pointerY = event.clientY;
+
+      cameraState.theta -= deltaX * 0.006;
+      cameraState.phi = THREE.MathUtils.clamp(
+        cameraState.phi - deltaY * 0.005,
+        0.55,
+        1.48
+      );
+
+      updateCamera();
+    });
+
+    function endDrag(event) {
+      dragging = false;
+
+      if (renderer.domElement.hasPointerCapture(event.pointerId)) {
+        renderer.domElement.releasePointerCapture(event.pointerId);
+      }
+    }
+
+    renderer.domElement.addEventListener("pointerup", endDrag);
+    renderer.domElement.addEventListener("pointercancel", endDrag);
+
+    renderer.domElement.addEventListener(
+      "wheel",
+      (event) => {
+        event.preventDefault();
+
+        cameraState.radius = THREE.MathUtils.clamp(
+          cameraState.radius * Math.exp(event.deltaY * 0.001),
+          7.2,
+          20
+        );
+
+        updateCamera();
+      },
+      { passive: false }
+    );
+
+    // ---------------------------------------------------------------------
+    // Turntable and animation
+    // ---------------------------------------------------------------------
+
+    let turning = true;
+    let elapsed = 0;
+
+    rotateButton.addEventListener("click", () => {
+      turning = !turning;
+      rotateButton.textContent = turning ? "Pause rotation" : "Resume rotation";
+      rotateButton.setAttribute("aria-pressed", String(!turning));
+    });
+
+    const clock = new THREE.Clock();
+
+    renderer.setAnimationLoop(() => {
+      const delta = Math.min(clock.getDelta(), 0.05);
+      elapsed += delta;
+
+      // Slow 360-degree turntable rotation.
+      if (turning) {
+        boss.rotation.y += delta * 0.15;
+      }
+
+      // Pulsing crystal growth.
+      for (const crystal of animatedCrystals) {
+        const pulse = 1 + Math.sin(elapsed * 1.7 + crystal.phase) * 0.075;
+        crystal.group.scale.setScalar(pulse);
+      }
+
+      crystalMaterial.emissiveIntensity = 1.65 + Math.sin(elapsed * 2.1) * 0.22;
+      crystalCoreMaterial.emissiveIntensity = 2.25 + Math.sin(elapsed * 2.8) * 0.35;
+
+      chestCrystal.scale.setScalar(1 + Math.sin(elapsed * 2.3) * 0.08);
+      particles.rotation.y = elapsed * 0.08;
+      particles.position.y = Math.sin(elapsed * 0.7) * 0.12;
+
+      halo.rotation.z = elapsed * 0.025;
+      halo.material.opacity = 0.16 + Math.sin(elapsed * 0.8) * 0.035;
+
+      renderer.render(scene, camera);
+    });
+
+    // ---------------------------------------------------------------------
+    // Resize handling
+    // ---------------------------------------------------------------------
+
+    window.addEventListener("resize", () => {
+      camera.aspect = window.innerWidth / window.innerHeight;
+      camera.updateProjectionMatrix();
+
+      renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+      renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+
+    requestAnimationFrame(() => {
+      loading.classList.add("hidden");
+      setTimeout(() => loading.remove(), 600);
+    });
+  </script>
+</body>
+</html>

source/potions.html

@@ -0,0 +1,677 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Three Potion Bottles</title>
+
+  <style>
+    :root {
+      color-scheme: light;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont,
+        "Segoe UI", sans-serif;
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    html,
+    body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+      overflow: hidden;
+      background: #dfe5df;
+    }
+
+    #stage {
+      position: fixed;
+      inset: 0;
+    }
+
+    canvas {
+      display: block;
+      width: 100%;
+      height: 100%;
+      touch-action: none;
+      cursor: grab;
+      outline: none;
+    }
+
+    canvas.dragging {
+      cursor: grabbing;
+    }
+
+    .hud {
+      position: fixed;
+      top: 24px;
+      left: 26px;
+      z-index: 2;
+      max-width: min(360px, calc(100vw - 52px));
+      padding: 16px 18px;
+      border: 1px solid rgba(255, 255, 255, 0.58);
+      border-radius: 16px;
+      background: rgba(250, 248, 240, 0.72);
+      box-shadow: 0 12px 36px rgba(49, 58, 51, 0.12);
+      backdrop-filter: blur(12px);
+      pointer-events: none;
+    }
+
+    .eyebrow {
+      margin-bottom: 5px;
+      color: #718078;
+      font-size: 10px;
+      font-weight: 800;
+      letter-spacing: 0.18em;
+      text-transform: uppercase;
+    }
+
+    h1 {
+      margin: 0;
+      color: #303b36;
+      font-size: clamp(25px, 4vw, 38px);
+      font-weight: 750;
+      letter-spacing: -0.045em;
+    }
+
+    .hud p {
+      margin: 8px 0 0;
+      color: #69746d;
+      font-size: 13px;
+    }
+
+    .controls {
+      position: fixed;
+      right: 22px;
+      bottom: 22px;
+      z-index: 3;
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 10px 12px;
+      border: 1px solid rgba(255, 255, 255, 0.62);
+      border-radius: 12px;
+      background: rgba(250, 248, 240, 0.76);
+      box-shadow: 0 10px 30px rgba(49, 58, 51, 0.12);
+      backdrop-filter: blur(10px);
+    }
+
+    .status {
+      color: #738078;
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+    }
+
+    button {
+      border: 0;
+      border-radius: 8px;
+      padding: 9px 12px;
+      background: #415047;
+      color: #fffdf5;
+      font: inherit;
+      font-size: 12px;
+      font-weight: 700;
+      cursor: pointer;
+      transition: transform 150ms ease, background 150ms ease;
+    }
+
+    button:hover {
+      background: #526157;
+      transform: translateY(-1px);
+    }
+
+    button:active {
+      transform: translateY(0);
+    }
+
+    @media (max-width: 600px) {
+      .hud {
+        top: 14px;
+        left: 14px;
+        padding: 13px 15px;
+      }
+
+      .hud p {
+        max-width: 230px;
+        font-size: 12px;
+      }
+
+      .controls {
+        right: 14px;
+        bottom: 14px;
+      }
+
+      .status {
+        display: none;
+      }
+    }
+  </style>
+</head>
+
+<body>
+  <main id="stage" aria-label="Interactive three-dimensional potion bottle scene"></main>
+
+  <section class="hud">
+    <div class="eyebrow">Interactive 3D asset</div>
+    <h1>Three Potions</h1>
+    <p>Drag to orbit · Scroll or pinch to zoom · Double-click to reset</p>
+  </section>
+
+  <div class="controls">
+    <span class="status" id="status">Auto spin</span>
+    <button id="pause" type="button">Pause rotation</button>
+  </div>
+
+  <script type="module">
+    import * as THREE from "https://cdnjs.cloudflare.com/ajax/libs/three.js/0.160.0/three.module.min.js";
+
+    const stage = document.querySelector("#stage");
+    const pauseButton = document.querySelector("#pause");
+    const status = document.querySelector("#status");
+
+    // ---------------------------------------------------------------------
+    // Renderer, scene, and camera
+    // ---------------------------------------------------------------------
+
+    const renderer = new THREE.WebGLRenderer({
+      antialias: true,
+      powerPreference: "high-performance"
+    });
+
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    renderer.outputColorSpace = THREE.SRGBColorSpace;
+    renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    renderer.toneMappingExposure = 1.08;
+
+    renderer.domElement.setAttribute(
+      "aria-label",
+      "Three colored potion bottles with corks resting on a wooden tray"
+    );
+
+    stage.appendChild(renderer.domElement);
+
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0xdfe5df);
+    scene.fog = new THREE.Fog(0xdfe5df, 13, 30);
+
+    const camera = new THREE.PerspectiveCamera(
+      38,
+      window.innerWidth / window.innerHeight,
+      0.1,
+      100
+    );
+
+    const controls = {
+      yaw: 0.58,
+      pitch: 0.52,
+      distance: 8.4,
+      target: new THREE.Vector3(0, 1.08, 0)
+    };
+
+    function updateCamera() {
+      const horizontalDistance =
+        controls.distance * Math.cos(controls.pitch);
+
+      camera.position.set(
+        controls.target.x + Math.sin(controls.yaw) * horizontalDistance,
+        controls.target.y + Math.sin(controls.pitch) * controls.distance,
+        controls.target.z + Math.cos(controls.yaw) * horizontalDistance
+      );
+
+      camera.lookAt(controls.target);
+    }
+
+    updateCamera();
+
+    // ---------------------------------------------------------------------
+    // Lighting
+    // ---------------------------------------------------------------------
+
+    scene.add(new THREE.HemisphereLight(0xf8fcff, 0x8a6848, 2.1));
+
+    const keyLight = new THREE.DirectionalLight(0xfff1d7, 3.2);
+    keyLight.position.set(-4.5, 8, 5.5);
+    keyLight.castShadow = true;
+    keyLight.shadow.mapSize.set(2048, 2048);
+    keyLight.shadow.camera.left = -7;
+    keyLight.shadow.camera.right = 7;
+    keyLight.shadow.camera.top = 7;
+    keyLight.shadow.camera.bottom = -7;
+    keyLight.shadow.camera.near = 0.5;
+    keyLight.shadow.camera.far = 20;
+    keyLight.shadow.normalBias = 0.025;
+    keyLight.target.position.set(0, 0.8, 0);
+    scene.add(keyLight, keyLight.target);
+
+    const fillLight = new THREE.DirectionalLight(0xc5dcff, 1.25);
+    fillLight.position.set(5, 3.5, -4);
+    scene.add(fillLight);
+
+    // ---------------------------------------------------------------------
+    // Materials and geometry helpers
+    // ---------------------------------------------------------------------
+
+    function createWoodTexture() {
+      const canvas = document.createElement("canvas");
+      canvas.width = 512;
+      canvas.height = 512;
+
+      const context = canvas.getContext("2d");
+      context.fillStyle = "#8a542f";
+      context.fillRect(0, 0, 512, 512);
+
+      let seed = 9137;
+
+      function random() {
+        seed = (seed * 16807) % 2147483647;
+        return (seed - 1) / 2147483646;
+      }
+
+      for (let i = 0; i < 100; i++) {
+        const y = random() * 512;
+        const amplitude = 1 + random() * 5;
+        const frequency = 0.008 + random() * 0.018;
+
+        context.beginPath();
+        context.moveTo(0, y);
+
+        for (let x = 0; x <= 512; x += 8) {
+          const wave = Math.sin(x * frequency + i) * amplitude;
+          const noise = (random() - 0.5) * 2;
+          context.lineTo(x, y + wave + noise);
+        }
+
+        context.strokeStyle = `rgba(48, 23, 10, ${0.08 + random() * 0.16})`;
+        context.lineWidth = 0.5 + random() * 2.2;
+        context.stroke();
+      }
+
+      for (let i = 0; i < 8; i++) {
+        const x = random() * 512;
+        const y = random() * 512;
+        const radiusX = 8 + random() * 24;
+        const radiusY = 2 + random() * 7;
+
+        context.beginPath();
+        context.ellipse(x, y, radiusX, radiusY, 0, 0, Math.PI * 2);
+        context.strokeStyle = "rgba(45, 22, 9, 0.18)";
+        context.lineWidth = 2;
+        context.stroke();
+      }
+
+      const texture = new THREE.CanvasTexture(canvas);
+      texture.colorSpace = THREE.SRGBColorSpace;
+      texture.wrapS = THREE.RepeatWrapping;
+      texture.wrapT = THREE.RepeatWrapping;
+      texture.repeat.set(1.5, 1.5);
+      texture.anisotropy = renderer.capabilities.getMaxAnisotropy();
+
+      return texture;
+    }
+
+    const woodTexture = createWoodTexture();
+
+    const materials = {
+      wood: new THREE.MeshStandardMaterial({
+        map: woodTexture,
+        color: 0xffffff,
+        roughness: 0.78
+      }),
+      darkWood: new THREE.MeshStandardMaterial({
+        map: woodTexture,
+        color: 0x6d4127,
+        roughness: 0.86
+      }),
+      cork: new THREE.MeshStandardMaterial({
+        color: 0xb9864e,
+        roughness: 0.82
+      }),
+      corkTop: new THREE.MeshStandardMaterial({
+        color: 0xd0a264,
+        roughness: 0.72
+      }),
+      label: new THREE.MeshStandardMaterial({
+        color: 0xf3e3bd,
+        roughness: 0.88
+      })
+    };
+
+    function addMesh(
+      geometry,
+      material,
+      parent,
+      name,
+      position = [0, 0, 0],
+      rotation = [0, 0, 0],
+      castShadow = true,
+      receiveShadow = true
+    ) {
+      const object = new THREE.Mesh(geometry, material);
+      object.name = name;
+      object.position.set(...position);
+      object.rotation.set(...rotation);
+      object.castShadow = castShadow;
+      object.receiveShadow = receiveShadow;
+      parent.add(object);
+
+      return object;
+    }
+
+    // ---------------------------------------------------------------------
+    // Ground plane
+    // ---------------------------------------------------------------------
+
+    const ground = addMesh(
+      new THREE.PlaneGeometry(40, 40),
+      new THREE.MeshStandardMaterial({
+        color: 0xd9dfda,
+        roughness: 1
+      }),
+      scene,
+      "Plain ground plane",
+      [0, -0.012, 0],
+      [-Math.PI / 2, 0, 0],
+      false,
+      true
+    );
+
+    // ---------------------------------------------------------------------
+    // Turntable and wooden tray
+    // ---------------------------------------------------------------------
+
+    const turntable = new THREE.Group();
+    turntable.name = "Rotating turntable";
+    scene.add(turntable);
+
+    addMesh(
+      new THREE.CylinderGeometry(3.08, 3.14, 0.1, 96),
+      materials.darkWood,
+      turntable,
+      "Turntable plinth",
+      [0, -0.04, 0]
+    );
+
+    addMesh(
+      new THREE.TorusGeometry(3.08, 0.025, 10, 96),
+      materials.wood,
+      turntable,
+      "Turntable rim",
+      [0, 0.012, 0],
+      [Math.PI / 2, 0, 0]
+    );
+
+    const tray = new THREE.Group();
+    tray.name = "Small wooden tray";
+    tray.position.y = 0.07;
+    turntable.add(tray);
+
+    addMesh(
+      new THREE.BoxGeometry(4.95, 0.16, 3.3),
+      materials.wood,
+      tray,
+      "Tray base"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.16, 0.36, 3.3),
+      materials.wood,
+      tray,
+      "Left tray rail",
+      [-2.39, 0, 0]
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.16, 0.36, 3.3),
+      materials.wood,
+      tray,
+      "Right tray rail",
+      [2.39, 0, 0]
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(4.83, 0.36, 0.16),
+      materials.wood,
+      tray,
+      "Front tray rail",
+      [0, 0, 1.59]
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(4.83, 0.36, 0.16),
+      materials.wood,
+      tray,
+      "Back tray rail",
+      [0, 0, -1.59]
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(4.68, 0.035, 3.08),
+      materials.wood,
+      tray,
+      "Tray floor"
+    );
+
+    // ---------------------------------------------------------------------
+    // Bottle construction
+    // ---------------------------------------------------------------------
+
+    const bottleProfile = [
+      new THREE.Vector2(0.0, 0.0),
+      new THREE.Vector2(0.23, 0.0),
+      new THREE.Vector2(0.33, 0.08),
+      new THREE.Vector2(0.41, 0.22),
+      new THREE.Vector2(0.43, 0.55),
+      new THREE.Vector2(0.43, 0.95),
+      new THREE.Vector2(0.4, 1.2),
+      new THREE.Vector2(0.31, 1.4),
+      new THREE.Vector2(0.22, 1.55),
+      new THREE.Vector2(0.17, 1.68),
+      new THREE.Vector2(0.17, 1.82)
+    ];
+
+    function createLabelTexture() {
+      const canvas = document.createElement("canvas");
+      canvas.width = 256;
+      canvas.height = 128;
+
+      const context = canvas.getContext("2d");
+
+      context.fillStyle = "#f3e3bd";
+      context.fillRect(0, 0, 256, 128);
+
+      context.strokeStyle = "#b78b45";
+      context.lineWidth = 8;
+      context.strokeRect(9, 9, 238, 110);
+
+      context.fillStyle = "#59452d";
+      context.textAlign = "center";
+      context.textBaseline = "middle";
+      context.font = "700 42px Georgia, serif";
+      context.fillText("POTION", 128, 65);
+
+      const texture = new THREE.CanvasTexture(canvas);
+      texture.colorSpace = THREE.SRGBColorSpace;
+      texture.anisotropy = renderer.capabilities.getMaxAnisotropy();
+
+      return texture;
+    }
+
+    const labelTexture = createLabelTexture();
+
+    function createBottle(name, bodyColor, xPosition) {
+      const bottle = new THREE.Group();
+      bottle.name = name;
+      bottle.position.set(xPosition, 0.17, 0);
+      turntable.add(bottle);
+
+      const bodyMaterial = new THREE.MeshPhysicalMaterial({
+        color: bodyColor,
+        roughness: 0.22,
+        metalness: 0,
+        clearcoat: 0.65,
+        clearcoatRoughness: 0.24
+      });
+
+      addMesh(
+        new THREE.LatheGeometry(bottleProfile, 64),
+        bodyMaterial,
+        bottle,
+        `${name} bottle body`
+      );
+
+      addMesh(
+        new THREE.CylinderGeometry(0.17, 0.19, 0.42, 32),
+        materials.cork,
+        bottle,
+        `${name} cork`
+      );
+
+      addMesh(
+        new THREE.CylinderGeometry(0.172, 0.172, 0.025, 32),
+        materials.corkTop,
+        bottle,
+        `${name} cork top`
+      );
+
+      const label = addMesh(
+        new THREE.PlaneGeometry(0.48, 0.24),
+        new THREE.MeshStandardMaterial({
+          map: labelTexture,
+          roughness: 0.88
+        }),
+        bottle,
+        `${name} front label`,
+        [0, 0.77, 0.425]
+      );
+
+      label.castShadow = false;
+
+      return bottle;
+    }
+
+    createBottle("Crimson potion bottle", 0xc6353b, -1.25);
+    createBottle("Cobalt potion bottle", 0x245ad4, 0);
+    createBottle("Emerald potion bottle", 0x2d8d65, 1.25);
+
+    // ---------------------------------------------------------------------
+    // Direct mouse orbit controls — no external control modules
+    // ---------------------------------------------------------------------
+
+    let dragging = false;
+    let previousX = 0;
+    let previousY = 0;
+
+    const canvas = renderer.domElement;
+
+    canvas.addEventListener("pointerdown", (event) => {
+      if (event.button !== 0) return;
+
+      dragging = true;
+      previousX = event.clientX;
+      previousY = event.clientY;
+      canvas.setPointerCapture(event.pointerId);
+      canvas.classList.add("dragging");
+    });
+
+    canvas.addEventListener("pointermove", (event) => {
+      if (!dragging) return;
+
+      const deltaX = event.clientX - previousX;
+      const deltaY = event.clientY - previousY;
+
+      previousX = event.clientX;
+      previousY = event.clientY;
+
+      controls.yaw -= deltaX * 0.006;
+      controls.pitch = THREE.MathUtils.clamp(
+        controls.pitch + deltaY * 0.005,
+        0.25,
+        1.35
+      );
+
+      updateCamera();
+    });
+
+    function endDrag(event) {
+      dragging = false;
+      canvas.classList.remove("dragging");
+
+      if (event.pointerId !== undefined && canvas.hasPointerCapture(event.pointerId)) {
+        canvas.releasePointerCapture(event.pointerId);
+      }
+    }
+
+    canvas.addEventListener("pointerup", endDrag);
+    canvas.addEventListener("pointercancel", endDrag);
+
+    canvas.addEventListener(
+      "wheel",
+      (event) => {
+        event.preventDefault();
+
+        controls.distance = THREE.MathUtils.clamp(
+          controls.distance * Math.exp(event.deltaY * 0.001),
+          5.6,
+          13
+        );
+
+        updateCamera();
+      },
+      { passive: false }
+    );
+
+    canvas.addEventListener("dblclick", () => {
+      controls.yaw = 0.58;
+      controls.pitch = 0.52;
+      controls.distance = 8.4;
+      updateCamera();
+    });
+
+    canvas.addEventListener("contextmenu", (event) => {
+      event.preventDefault();
+    });
+
+    // ---------------------------------------------------------------------
+    // Animation and UI
+    // ---------------------------------------------------------------------
+
+    let elapsed = 0;
+    let paused = false;
+
+    pauseButton.addEventListener("click", () => {
+      paused = !paused;
+      pauseButton.textContent = paused ? "Resume rotation" : "Pause rotation";
+      status.textContent = paused ? "Paused" : "Auto spin";
+    });
+
+    const clock = new THREE.Clock();
+
+    function animate() {
+      const delta = Math.min(clock.getDelta(), 0.05);
+
+      if (!paused) {
+        elapsed += delta;
+      }
+
+      turntable.rotation.y = elapsed * 0.28;
+      renderer.render(scene, camera);
+    }
+
+    renderer.setAnimationLoop(animate);
+
+    window.addEventListener("resize", () => {
+      camera.aspect = window.innerWidth / window.innerHeight;
+      camera.updateProjectionMatrix();
+
+      renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+      renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+  </script>
+</body>
+</html>

source/tower.html

@@ -0,0 +1,732 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Medieval Castle Guard Tower</title>
+
+  <style>
+    * {
+      box-sizing: border-box;
+    }
+
+    html,
+    body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+      overflow: hidden;
+      background: #b8ad98;
+      font-family: Georgia, "Times New Roman", serif;
+    }
+
+    canvas {
+      display: block;
+      width: 100%;
+      height: 100%;
+      cursor: grab;
+      touch-action: none;
+    }
+
+    canvas.dragging {
+      cursor: grabbing;
+    }
+
+    .title-card {
+      position: fixed;
+      top: 24px;
+      left: 26px;
+      z-index: 10;
+      max-width: min(390px, calc(100vw - 52px));
+      padding: 15px 18px;
+      color: #f4ead6;
+      background: linear-gradient(145deg, rgba(38, 31, 25, 0.88), rgba(65, 48, 34, 0.72));
+      border: 1px solid rgba(218, 184, 120, 0.55);
+      border-radius: 8px;
+      box-shadow: 0 12px 35px rgba(35, 26, 18, 0.25);
+      backdrop-filter: blur(8px);
+      pointer-events: none;
+    }
+
+    .title-card h1 {
+      margin: 0 0 5px;
+      font-size: 20px;
+      font-weight: 600;
+      letter-spacing: 0.04em;
+    }
+
+    .title-card p {
+      margin: 0;
+      color: #d8c7a8;
+      font-size: 12px;
+      line-height: 1.45;
+    }
+
+    .controls {
+      position: fixed;
+      right: 22px;
+      bottom: 22px;
+      z-index: 10;
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 10px 12px;
+      color: #f4ead6;
+      background: rgba(38, 31, 25, 0.78);
+      border: 1px solid rgba(218, 184, 120, 0.45);
+      border-radius: 7px;
+      box-shadow: 0 8px 24px rgba(35, 26, 18, 0.2);
+      backdrop-filter: blur(8px);
+      font: 12px/1.35 Georgia, "Times New Roman", serif;
+    }
+
+    button {
+      appearance: none;
+      padding: 7px 10px;
+      color: #f4ead6;
+      background: rgba(218, 184, 120, 0.15);
+      border: 1px solid rgba(218, 184, 120, 0.55);
+      border-radius: 4px;
+      font: inherit;
+      cursor: pointer;
+    }
+
+    button:hover {
+      background: rgba(218, 184, 120, 0.28);
+    }
+
+    button:active {
+      transform: translateY(1px);
+    }
+
+    .hint {
+      color: #d8c7a8;
+    }
+
+    @media (max-width: 600px) {
+      .title-card {
+        top: 14px;
+        left: 14px;
+        padding: 11px 13px;
+      }
+
+      .title-card h1 {
+        font-size: 17px;
+      }
+
+      .controls {
+        right: 12px;
+        bottom: 12px;
+      }
+
+      .hint {
+        display: none;
+      }
+    }
+  </style>
+</head>
+
+<body>
+  <canvas id="scene" aria-label="Interactive 3D medieval castle guard tower"></canvas>
+
+  <div class="title-card">
+    <h1>Castle Guard Tower</h1>
+    <p>A stone watchtower with crenellations, an arched oak door, and a waving banner.</p>
+  </div>
+
+  <div class="controls">
+    <span class="hint">Drag to orbit · Scroll to zoom · Double-click to reset</span>
+    <button id="turntableButton" type="button" aria-pressed="false">Pause turntable</button>
+  </div>
+
+  <script type="module">
+    import * as THREE from "https://cdnjs.cloudflare.com/ajax/libs/three.js/0.160.0/three.module.min.js";
+
+    const canvas = document.querySelector("#scene");
+    const turntableButton = document.querySelector("#turntableButton");
+
+    // Renderer
+    const renderer = new THREE.WebGLRenderer({
+      canvas,
+      antialias: true,
+      powerPreference: "high-performance"
+    });
+
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    renderer.outputColorSpace = THREE.SRGBColorSpace;
+    renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    renderer.toneMappingExposure = 1.05;
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+
+    // Scene
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0xb8ad98);
+    scene.fog = new THREE.Fog(0xb8ad98, 18, 42);
+
+    const camera = new THREE.PerspectiveCamera(
+      42,
+      window.innerWidth / window.innerHeight,
+      0.1,
+      100
+    );
+
+    // Lighting
+    scene.add(new THREE.HemisphereLight(0xdde4dc, 0x69533e, 2.1));
+
+    const sun = new THREE.DirectionalLight(0xffe5b5, 3.2);
+    sun.position.set(-7, 11, 8);
+    sun.castShadow = true;
+    sun.shadow.mapSize.set(2048, 2048);
+    sun.shadow.camera.left = -10;
+    sun.shadow.camera.right = 10;
+    sun.shadow.camera.top = 12;
+    sun.shadow.camera.bottom = -8;
+    sun.shadow.camera.near = 1;
+    sun.shadow.camera.far = 30;
+    sun.shadow.bias = -0.00035;
+    scene.add(sun);
+
+    const fill = new THREE.DirectionalLight(0x9fb8c7, 0.75);
+    fill.position.set(7, 5, -8);
+    scene.add(fill);
+
+    // Materials
+    const materials = {
+      stone: new THREE.MeshStandardMaterial({
+        color: 0x8d816d,
+        roughness: 0.96
+      }),
+      stoneLight: new THREE.MeshStandardMaterial({
+        color: 0xa5977c,
+        roughness: 0.94
+      }),
+      stoneDark: new THREE.MeshStandardMaterial({
+        color: 0x685f4e,
+        roughness: 1
+      }),
+      wood: new THREE.MeshStandardMaterial({
+        color: 0x5b321d,
+        roughness: 0.88
+      }),
+      darkWood: new THREE.MeshStandardMaterial({
+        color: 0x2d170d,
+        roughness: 0.96
+      }),
+      iron: new THREE.MeshStandardMaterial({
+        color: 0x303438,
+        roughness: 0.55,
+        metalness: 0.72
+      }),
+      gold: new THREE.MeshStandardMaterial({
+        color: 0xd6a74c,
+        roughness: 0.42,
+        metalness: 0.65
+      }),
+      cloth: new THREE.MeshStandardMaterial({
+        color: 0xc75332,
+        roughness: 0.8,
+        side: THREE.DoubleSide
+      }),
+      ground: new THREE.MeshStandardMaterial({
+        color: 0xb6aa91,
+        roughness: 1
+      })
+    };
+
+    // Helper for adding named, shadowed meshes
+    function addMesh(geometry, material, position, parent, name) {
+      const mesh = new THREE.Mesh(geometry, material);
+      mesh.position.set(position[0], position[1], position[2]);
+      mesh.name = name;
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      parent.add(mesh);
+      return mesh;
+    }
+
+    // Ground plane, kept stationary while the tower rotates on its turntable
+    const ground = addMesh(
+      new THREE.PlaneGeometry(80, 80),
+      materials.ground,
+      [0, -0.045, 0],
+      scene,
+      "Plain ground plane"
+    );
+    ground.rotation.x = -Math.PI / 2;
+    ground.castShadow = false;
+
+    // Turntable and tower assembly
+    const turntable = new THREE.Group();
+    turntable.name = "Rotating turntable";
+    scene.add(turntable);
+
+    // Stone turntable base
+    addMesh(
+      new THREE.BoxGeometry(4.7, 0.18, 4.7),
+      materials.stoneDark,
+      [0, 0.09, 0],
+      turntable,
+      "Stone turntable base"
+    );
+
+    const tower = new THREE.Group();
+    turntable.add(tower);
+
+    // Foundation
+    addMesh(
+      new THREE.BoxGeometry(3.15, 0.55, 3.15),
+      materials.stoneLight,
+      [0, 0.43, 0],
+      tower,
+      "Tower foundation"
+    );
+
+    // Main tower body with a true arched opening
+    const towerShape = new THREE.Shape();
+    towerShape.moveTo(-1.35, 0);
+    towerShape.lineTo(1.35, 0);
+    towerShape.lineTo(1.35, 3.8);
+    towerShape.lineTo(-1.35, 3.8);
+    towerShape.closePath();
+
+    const doorOpening = new THREE.Path();
+    doorOpening.moveTo(-0.48, 0);
+    doorOpening.lineTo(0.48, 0);
+    doorOpening.lineTo(0.48, 1.45);
+    doorOpening.absarc(0, 1.45, 0.48, 0, Math.PI, false);
+    doorOpening.lineTo(-0.48, 0);
+    doorOpening.closePath();
+    towerShape.holes.push(doorOpening);
+
+    const towerBodyGeometry = new THREE.ExtrudeGeometry(towerShape, {
+      depth: 2.4,
+      bevelEnabled: false,
+      curveSegments: 16,
+      steps: 1
+    });
+
+    addMesh(
+      towerBodyGeometry,
+      materials.stone,
+      [0, 0.78, -1.2],
+      tower,
+      "Arched stone tower body"
+    );
+
+    // Dark interior visible through the opening
+    const interiorShape = new THREE.Shape();
+    interiorShape.moveTo(-0.47, 0);
+    interiorShape.lineTo(0.47, 0);
+    interiorShape.lineTo(0.47, 1.45);
+    interiorShape.absarc(0, 1.45, 0.47, 0, Math.PI, false);
+    interiorShape.lineTo(-0.47, 0);
+    interiorShape.closePath();
+
+    const interior = addMesh(
+      new THREE.ShapeGeometry(interiorShape, 16),
+      materials.darkWood,
+      [0, 0.78, -1.185],
+      tower,
+      "Dark tower interior"
+    );
+    interior.castShadow = false;
+
+    // Wooden arched door
+    const doorShape = new THREE.Shape();
+    doorShape.moveTo(-0.47, 0);
+    doorShape.lineTo(0.47, 0);
+    doorShape.lineTo(0.47, 1.45);
+    doorShape.absarc(0, 1.45, 0.47, 0, Math.PI, false);
+    doorShape.lineTo(-0.47, 0);
+    doorShape.closePath();
+
+    addMesh(
+      new THREE.ShapeGeometry(doorShape, 16),
+      materials.wood,
+      [0, 0.79, 1.205],
+      tower,
+      "Arched wooden door"
+    );
+
+    // Door frame
+    addMesh(
+      new THREE.BoxGeometry(0.13, 2.0, 0.14),
+      materials.stoneLight,
+      [-0.56, 1.78, 1.245],
+      tower,
+      "Left door jamb"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.13, 2.0, 0.14),
+      materials.stoneLight,
+      [0.56, 1.78, 1.245],
+      tower,
+      "Right door jamb"
+    );
+
+    const archFrame = addMesh(
+      new THREE.TorusGeometry(0.55, 0.075, 8, 24, Math.PI),
+      materials.stoneLight,
+      [0, 1.45, 1.27],
+      tower,
+      "Arched door frame"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.16, 0.28, 0.16),
+      materials.stoneLight,
+      [0, 2.02, 1.27],
+      tower,
+      "Door keystone"
+    );
+
+    // Iron door hardware
+    addMesh(
+      new THREE.BoxGeometry(0.045, 0.72, 0.035),
+      materials.iron,
+      [-0.31, 1.08, 1.235],
+      tower,
+      "Left iron door strap"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.045, 0.72, 0.035),
+      materials.iron,
+      [0.31, 1.08, 1.235],
+      tower,
+      "Right iron door strap"
+    );
+
+    addMesh(
+      new THREE.BoxGeometry(0.66, 0.045, 0.035),
+      materials.iron,
+      [0, 1.27, 1.235],
+      tower,
+      "Iron crossbar"
+    );
+
+    const handle = addMesh(
+      new THREE.SphereGeometry(0.055, 12, 8),
+      materials.iron,
+      [0.25, 1.35, 1.28],
+      tower,
+      "Door handle"
+    );
+
+    // Alternating corner quoins
+    for (const x of [-1.24, 1.24]) {
+      for (const z of [-1.02, 1.02]) {
+        for (let row = 0; row < 6; row++) {
+          const material = (row + (x > 0 ? 1 : 0)) % 2 === 0
+            ? materials.stoneLight
+            : materials.stone;
+
+          addMesh(
+            new THREE.BoxGeometry(0.3, 0.36, 0.3),
+            material,
+            [x, 1.08 + row * 0.42, z],
+            tower,
+            `Corner quoin ${x > 0 ? "right" : "left"}`
+          );
+        }
+      }
+    }
+
+    // Side buttresses
+    for (const x of [-1.45, 1.45]) {
+      addMesh(
+        new THREE.BoxGeometry(0.28, 2.9, 2.45),
+        materials.stoneDark,
+        [x, 2.55, 0],
+        tower,
+        "Side buttress"
+      );
+    }
+
+    // Parapet walkway
+    addMesh(
+      new THREE.BoxGeometry(2.8, 0.24, 2.5),
+      materials.stoneLight,
+      [0, 4.72, 0],
+      tower,
+      "Top parapet walkway"
+    );
+
+    // Front and back crenellations
+    for (const z of [-1.18, 1.18]) {
+      for (let i = 0; i < 5; i++) {
+        const x = -1.05 + i * 0.42;
+
+        addMesh(
+          new THREE.BoxGeometry(0.68, 0.7, 0.46),
+          materials.stone,
+          [x, 5.12, z],
+          tower,
+          `Front/back crenellation ${i + 1}`
+        );
+      }
+    }
+
+    // Side crenellations
+    for (const x of [-1.35, 1.35]) {
+      for (let i = 0; i < 3; i++) {
+        const z = -0.72 + i * 0.72;
+
+        addMesh(
+          new THREE.BoxGeometry(0.46, 0.7, 0.68),
+          materials.stone,
+          [x, 5.12, z],
+          tower,
+          `Side crenellation ${i + 1}`
+        );
+      }
+    }
+
+    // Four small corner turrets
+    for (const x of [-1.2, 1.2]) {
+      for (const z of [-1.02, 1.02]) {
+        addMesh(
+          new THREE.BoxGeometry(0.55, 1.05, 0.55),
+          materials.stoneDark,
+          [x, 5.455, z],
+          tower,
+          "Corner turret"
+        );
+
+        for (let i = 0; i < 3; i++) {
+          addMesh(
+            new THREE.BoxGeometry(0.62, 0.55, 0.62),
+            materials.stone,
+            [x, 6.1 + i * 0.18, z],
+            tower,
+            "Corner turret crenellation"
+          );
+        }
+      }
+    }
+
+    // Flagpole
+    const poleBase = 5.89;
+    const poleHeight = 1.15;
+
+    addMesh(
+      new THREE.CylinderGeometry(0.035, 0.045, poleHeight, 10),
+      materials.iron,
+      [0, poleBase + poleHeight / 2, 0],
+      tower,
+      "Flagpole"
+    );
+
+    addMesh(
+      new THREE.SphereGeometry(0.065, 12, 8),
+      materials.gold,
+      [0, poleBase + poleHeight + 0.02, 0],
+      tower,
+      "Pole finial"
+    );
+
+    // Animated flag geometry
+    const flagWidth = 1.35;
+    const flagHeight = 1.06;
+    const flagColumns = 16;
+    const flagRows = 8;
+    const flagVertexCount = (flagColumns + 1) * (flagRows + 1);
+
+    const flagPositions = new Float32Array(flagVertexCount * 3);
+    const flagUVs = new Float32Array(flagVertexCount * 2);
+    const flagIndices = [];
+
+    for (let row = 0; row <= flagRows; row++) {
+      for (let column = 0; column <= flagColumns; column++) {
+        const vertex = row * (flagColumns + 1) + column;
+        const u = column / flagColumns;
+        const v = row / flagRows;
+
+        flagPositions[vertex * 3] = u * flagWidth;
+        flagPositions[vertex * 3 + 1] = v * flagHeight;
+        flagPositions[vertex * 3 + 2] = 0;
+
+        flagUVs[vertex * 2] = u;
+        flagUVs[vertex * 2 + 1] = v;
+      }
+    }
+
+    for (let row = 0; row < flagRows; row++) {
+      for (let column = 0; column < flagColumns; column++) {
+        const a = row * (flagColumns + 1) + column;
+        const b = a + 1;
+        const c = a + flagColumns + 1;
+        const d = c + 1;
+
+        flagIndices.push(a, c, b, b, c, d);
+      }
+    }
+
+    const flagGeometry = new THREE.BufferGeometry();
+    flagGeometry.setAttribute(
+      "position",
+      new THREE.BufferAttribute(flagPositions, 3)
+    );
+    flagGeometry.setAttribute(
+      "uv",
+      new THREE.BufferAttribute(flagUVs, 2)
+    );
+    flagGeometry.setIndex(flagIndices);
+    flagGeometry.computeVertexNormals();
+
+    const flag = addMesh(
+      flagGeometry,
+      materials.cloth,
+      [0, 5.98, 0],
+      tower,
+      "Waving banner flag"
+    );
+    flag.castShadow = true;
+
+    // Small gold emblem attached to the flag
+    const emblem = addMesh(
+      new THREE.CircleGeometry(0.115, 20),
+      materials.gold,
+      [0.27, 0.63, 0.115],
+      tower,
+      "Golden flag emblem"
+    );
+    emblem.castShadow = false;
+
+    // Custom orbit camera controls
+    const target = new THREE.Vector3(0, 3.2, 0);
+    const spherical = new THREE.Spherical(10.8, 1.24, 0.72);
+
+    let dragging = false;
+    let previousX = 0;
+    let previousY = 0;
+
+    function updateCamera() {
+      spherical.phi = THREE.MathUtils.clamp(spherical.phi, 0.45, 1.52);
+      spherical.radius = THREE.MathUtils.clamp(spherical.radius, 6.5, 18);
+
+      camera.position.setFromSpherical(spherical).add(target);
+      camera.lookAt(target);
+    }
+
+    function resetCamera() {
+      spherical.set(10.8, 1.24, 0.72);
+      target.set(0, 3.2, 0);
+      updateCamera();
+    }
+
+    canvas.addEventListener("pointerdown", (event) => {
+      dragging = true;
+      previousX = event.clientX;
+      previousY = event.clientY;
+      canvas.setPointerCapture(event.pointerId);
+      canvas.classList.add("dragging");
+    });
+
+    canvas.addEventListener("pointermove", (event) => {
+      if (!dragging) return;
+
+      const deltaX = event.clientX - previousX;
+      const deltaY = event.clientY - previousY;
+
+      previousX = event.clientX;
+      previousY = event.clientY;
+
+      spherical.theta -= deltaX * 0.006;
+      spherical.phi -= deltaY * 0.005;
+
+      updateCamera();
+    });
+
+    function stopDragging(event) {
+      dragging = false;
+      canvas.classList.remove("dragging");
+
+      if (event && canvas.hasPointerCapture(event.pointerId)) {
+        canvas.releasePointerCapture(event.pointerId);
+      }
+    }
+
+    canvas.addEventListener("pointerup", stopDragging);
+    canvas.addEventListener("pointercancel", stopDragging);
+    canvas.addEventListener("contextmenu", (event) => event.preventDefault());
+
+    canvas.addEventListener("wheel", (event) => {
+      event.preventDefault();
+      spherical.radius *= Math.exp(event.deltaY * 0.001);
+      updateCamera();
+    }, { passive: false });
+
+    canvas.addEventListener("dblclick", resetCamera);
+
+    // Turntable and pause controls
+    let autoRotate = true;
+
+    function toggleTurntable() {
+      autoRotate = !autoRotate;
+      turntableButton.textContent = autoRotate ? "Pause turntable" : "Resume turntable";
+      turntableButton.setAttribute("aria-pressed", String(!autoRotate));
+    }
+
+    turntableButton.addEventListener("click", toggleTurntable);
+
+    window.addEventListener("keydown", (event) => {
+      if (event.code === "Space") {
+        event.preventDefault();
+        toggleTurntable();
+      }
+
+      if (event.code === "KeyR") {
+        resetCamera();
+      }
+    });
+
+    window.addEventListener("resize", () => {
+      camera.aspect = window.innerWidth / window.innerHeight;
+      camera.updateProjectionMatrix();
+      renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+      renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+
+    // Animation
+    const clock = new THREE.Clock();
+    let elapsed = 0;
+
+    renderer.setAnimationLoop(() => {
+      const delta = Math.min(clock.getDelta(), 0.05);
+      elapsed += delta;
+
+      if (autoRotate) {
+        turntable.rotation.y += delta * 0.105;
+      }
+
+      // Update the flag's vertices each frame
+      const positions = flagGeometry.attributes.position;
+
+      for (let vertex = 0; vertex < flagVertexCount; vertex++) {
+        const x = positions.getX(vertex);
+        const y = positions.getY(vertex);
+        const normalizedY = y / flagHeight;
+
+        const wave =
+          Math.sin(x * 4.2 - elapsed * 2.35) * 0.21 * normalizedY +
+          Math.sin((x + flagWidth / 2) * 6.0 - elapsed * 3.1) *
+          0.075 *
+          normalizedY;
+
+        positions.setZ(vertex, wave);
+      }
+
+      positions.needsUpdate = true;
+      flagGeometry.computeVertexNormals();
+
+      renderer.render(scene, camera);
+    });
+
+    resetCamera();
+  </script>
+</body>
+</html>

source/voxel-goblin.html

@@ -0,0 +1,768 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Swamp Goblin — Voxel Enemy</title>
+
+  <style>
+    :root {
+      color-scheme: dark;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system,
+        BlinkMacSystemFont, "Segoe UI", sans-serif;
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    html,
+    body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+      overflow: hidden;
+      background: #789887;
+    }
+
+    #stage {
+      position: fixed;
+      inset: 0;
+    }
+
+    canvas {
+      display: block;
+      width: 100%;
+      height: 100%;
+      cursor: grab;
+      touch-action: none;
+    }
+
+    canvas:active {
+      cursor: grabbing;
+    }
+
+    .vignette {
+      position: fixed;
+      inset: 0;
+      pointer-events: none;
+      background:
+        radial-gradient(
+          ellipse at 50% 45%,
+          transparent 45%,
+          rgba(17, 28, 22, 0.22) 100%
+        );
+    }
+
+    .hud {
+      position: fixed;
+      top: 24px;
+      left: 24px;
+      z-index: 2;
+      max-width: min(360px, calc(100vw - 48px));
+      padding: 16px 18px;
+      color: #f2f4df;
+      background: rgba(20, 31, 24, 0.76);
+      border: 1px solid rgba(230, 235, 196, 0.2);
+      border-radius: 14px;
+      box-shadow: 0 14px 40px rgba(15, 26, 20, 0.22);
+      backdrop-filter: blur(12px);
+      pointer-events: none;
+    }
+
+    .eyebrow {
+      margin: 0 0 6px;
+      color: #b8ca91;
+      font-size: 11px;
+      font-weight: 800;
+      letter-spacing: 0.18em;
+      text-transform: uppercase;
+    }
+
+    h1 {
+      margin: 0;
+      font-size: clamp(23px, 4vw, 34px);
+      line-height: 1;
+      letter-spacing: -0.035em;
+    }
+
+    .subtitle {
+      margin: 8px 0 0;
+      color: rgba(242, 244, 223, 0.68);
+      font-size: 13px;
+    }
+
+    .controls {
+      position: fixed;
+      right: 24px;
+      bottom: 24px;
+      z-index: 3;
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 10px 12px;
+      color: rgba(245, 247, 229, 0.82);
+      background: rgba(20, 31, 24, 0.72);
+      border: 1px solid rgba(230, 235, 196, 0.18);
+      border-radius: 12px;
+      box-shadow: 0 12px 35px rgba(15, 26, 20, 0.2);
+      backdrop-filter: blur(10px);
+      font-size: 12px;
+    }
+
+    #pause {
+      appearance: none;
+      padding: 8px 12px;
+      color: #203025;
+      background: #b8ca91;
+      border: 0;
+      border-radius: 8px;
+      font: inherit;
+      font-weight: 800;
+      cursor: pointer;
+    }
+
+    #pause:hover {
+      background: #d2dfb0;
+    }
+
+    #hint {
+      position: fixed;
+      left: 50%;
+      bottom: 24px;
+      z-index: 2;
+      transform: translateX(-50%);
+      padding: 8px 12px;
+      color: rgba(245, 247, 229, 0.72);
+      background: rgba(20, 31, 24, 0.55);
+      border: 1px solid rgba(230, 235, 196, 0.12);
+      border-radius: 999px;
+      box-shadow: 0 8px 25px rgba(15, 26, 20, 0.15);
+      backdrop-filter: blur(8px);
+      font-size: 11px;
+      white-space: nowrap;
+      pointer-events: none;
+    }
+
+    @media (max-width: 640px) {
+      .hud {
+        top: 14px;
+        left: 14px;
+        padding: 12px 14px;
+      }
+
+      .subtitle {
+        display: none;
+      }
+
+      .controls {
+        right: 14px;
+        bottom: 14px;
+      }
+
+      #hint {
+        display: none;
+      }
+    }
+  </style>
+</head>
+
+<body>
+  <div id="stage"></div>
+  <div class="vignette"></div>
+
+  <section class="hud" aria-label="Scene information">
+    <p class="eyebrow">Voxel Enemy Archive</p>
+    <h1>Swamp Goblin</h1>
+    <p class="subtitle">Big-eared woodland raider with a leather vest and spiked club.</p>
+  </section>
+
+  <div id="hint">Drag to orbit · Scroll to zoom · Double-click to reset</div>
+
+  <div class="controls">
+    <button id="pause" type="button">Pause turntable</button>
+    <span>Auto-rotating</span>
+  </div>
+
+  <script type="module">
+    import * as THREE from
+      "https://cdnjs.cloudflare.com/ajax/libs/three.js/0.160.0/three.module.min.js";
+
+    const stage = document.getElementById("stage");
+    const pauseButton = document.getElementById("pause");
+
+    // -------------------------------------------------------------------------
+    // Renderer, scene, camera
+    // -------------------------------------------------------------------------
+
+    const renderer = new THREE.WebGLRenderer({
+      antialias: true,
+      alpha: false,
+      powerPreference: "high-performance"
+    });
+
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    renderer.outputColorSpace = THREE.SRGBColorSpace;
+    renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    renderer.toneMappingExposure = 1.05;
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    renderer.domElement.setAttribute(
+      "aria-label",
+      "Interactive 3D voxel swamp goblin enemy"
+    );
+    stage.appendChild(renderer.domElement);
+
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0x789887);
+    scene.fog = new THREE.Fog(0x789887, 19, 42);
+
+    const camera = new THREE.PerspectiveCamera(
+      38,
+      window.innerWidth / window.innerHeight,
+      0.1,
+      100
+    );
+
+    const cameraTarget = new THREE.Vector3(0, 2.25, 0);
+    const cameraView = {
+      theta: 0.72,
+      phi: 1.12,
+      radius: 12.6
+    };
+
+    function updateCamera() {
+      const sinPhi = Math.sin(cameraView.phi);
+
+      camera.position.set(
+        cameraTarget.x +
+          cameraView.radius * sinPhi * Math.sin(cameraView.theta),
+        cameraTarget.y + cameraView.radius * Math.cos(cameraView.phi),
+        cameraTarget.z +
+          cameraView.radius * sinPhi * Math.cos(cameraView.theta)
+      );
+
+      camera.lookAt(cameraTarget);
+    }
+
+    updateCamera();
+
+    // -------------------------------------------------------------------------
+    // Lighting
+    // -------------------------------------------------------------------------
+
+    const hemisphere = new THREE.HemisphereLight(
+      0xd8ead4,
+      0x344336,
+      1.75
+    );
+    scene.add(hemisphere);
+
+    const keyLight = new THREE.DirectionalLight(0xffe3a6, 3.2);
+    keyLight.position.set(6, 10, 8);
+    keyLight.castShadow = true;
+    keyLight.shadow.mapSize.set(2048, 2048);
+    keyLight.shadow.camera.near = 1;
+    keyLight.shadow.camera.far = 30;
+    keyLight.shadow.camera.left = -7;
+    keyLight.shadow.camera.right = 7;
+    keyLight.shadow.camera.top = 8;
+    keyLight.shadow.camera.bottom = -5;
+    keyLight.shadow.bias = -0.0004;
+    keyLight.shadow.normalBias = 0.025;
+    keyLight.target.position.set(0, 2, 0);
+    scene.add(keyLight, keyLight.target);
+
+    const fillLight = new THREE.DirectionalLight(0x9fc9d0, 1.1);
+    fillLight.position.set(-7, 5, 4);
+    scene.add(fillLight);
+
+    const rimLight = new THREE.DirectionalLight(0xffc96e, 0.8);
+    rimLight.position.set(1, 4, -8);
+    scene.add(rimLight);
+
+    // -------------------------------------------------------------------------
+    // Plain ground plane
+    // -------------------------------------------------------------------------
+
+    const ground = new THREE.Mesh(
+      new THREE.PlaneGeometry(80, 80),
+      new THREE.MeshStandardMaterial({
+        color: 0x53624c,
+        roughness: 1,
+        metalness: 0
+      })
+    );
+
+    ground.rotation.x = -Math.PI / 2;
+    ground.position.y = -0.025;
+    ground.receiveShadow = true;
+    scene.add(ground);
+
+    // -------------------------------------------------------------------------
+    // Voxel construction
+    //
+    // Every visible part of the goblin is assembled from axis-aligned boxes.
+    // Instanced rendering keeps the block count manageable while preserving
+    // clear gaps, shadows, and individual cubic geometry.
+    // -------------------------------------------------------------------------
+
+    const model = new THREE.Group();
+    model.rotation.y = -0.1;
+
+    const voxels = [];
+
+    function addVoxel(x, y, z, sx, sy, sz, color) {
+      voxels.push({ x, y, z, sx, sy, sz, color });
+    }
+
+    const skin = 0x8b954e;
+    const skinLight = 0x9da353;
+    const skinDark = 0x747e3f;
+    const earOuter = 0x68763d;
+    const earInner = 0x9ca258;
+    const leather = 0x4b2d20;
+    const leatherDark = 0x2d1c17;
+    const leatherTrim = 0x714633;
+    const brass = 0xb88a3d;
+    const clubWood = 0x764723;
+    const clubLight = 0xb8773e;
+    const clubDark = 0x57321b;
+    const eyeBlack = 0x11150e;
+    const eyeIris = 0xe0b847;
+    const eyeGlint = 0xfff3b0;
+    const hair = 0x263b2b;
+
+    // Boots and feet.
+    for (const side of [-1, 1]) {
+      const x = side * 0.43;
+
+      addVoxel(x, 0.13, 0.25, 0.48, 0.26, 0.58, clubDark);
+      addVoxel(x, 0.29, 0.25, 0.42, 0.18, 0.54, leather);
+      addVoxel(x, 0.40, 0.04, 0.23, 0.22, 0.50, skin);
+      addVoxel(x, 0.40, 0.38, 0.23, 0.22, 0.20, skinLight);
+      addVoxel(x - 0.10, 0.40, 0.42, 0.16, 0.16, 0.16, skin);
+    }
+
+    // Legs and hips.
+    for (const side of [-1, 1]) {
+      for (let y = 0.58; y <= 1.73; y += 0.23) {
+        addVoxel(side * 0.36, y, 0.02, 0.22, 0.22, 0.24, skin);
+      }
+
+      addVoxel(side * 0.43, 1.78, 0, 0.34, 0.22, 0.38, skinDark);
+    }
+
+    // Torso: a 6 × 6 × 3 grid of visible skin blocks.
+    for (let row = 0; row < 6; row++) {
+      for (let column = 0; column < 6; column++) {
+        for (let depth = 0; depth < 3; depth++) {
+          addVoxel(
+            -0.62 + column * 0.23,
+            1.78 + row * 0.23,
+            -0.34 + depth * 0.34,
+            0.215,
+            0.215,
+            0.215,
+            (row + column + depth) % 4 === 0
+              ? skinDark
+              : skin
+          );
+        }
+      }
+    }
+
+    // Leather vest front and back.
+    for (let row = 0; row < 5; row++) {
+      for (let column = 0; column < 6; column++) {
+        const x = -0.58 + column * 0.22;
+        const y = 1.91 + row * 0.23;
+
+        addVoxel(
+          x,
+          y,
+          0.43,
+          0.208,
+          0.218,
+          0.18,
+          (row + column) % 3 === 0 ? leatherDark : leather
+        );
+
+        addVoxel(
+          x,
+          y,
+          -0.43,
+          0.208,
+          0.218,
+          0.18,
+          (row + column + 1) % 3 === 0 ? leatherDark : leather
+        );
+      }
+    }
+
+    // Shoulder armor.
+    for (const side of [-1, 1]) {
+      addVoxel(side * 0.64, 3.12, 0, 0.30, 0.25, 0.44, leather);
+      addVoxel(side * 0.64, 3.29, 0, 0.25, 0.12, 0.38, leatherDark);
+    }
+
+    // Necklace / neck block.
+    addVoxel(0, 3.22, 0, 0.28, 0.18, 0.28, skinDark);
+    addVoxel(0, 3.31, 0, 0.12, 0.055, 0.13, brass);
+
+    // Arms.
+    for (const side of [-1, 1]) {
+      const armX = [0.65, 0.77, 0.89, 1.01, 1.13, 1.25];
+
+      for (let i = 0; i < armX.length; i++) {
+        addVoxel(
+          side * armX[i],
+          [2.90, 2.67, 2.44, 2.21, 1.98, 1.75][i],
+          0.02,
+          0.20,
+          0.20,
+          0.22,
+          i === 0 ? skinLight : skin
+        );
+      }
+
+      // Arm straps.
+      addVoxel(side * 0.68, 2.78, 0.12, 0.25, 0.32, 0.22, leather);
+      addVoxel(side * 0.68, 2.60, 0.12, 0.24, 0.08, 0.23, leatherDark);
+    }
+
+    // Hands.
+    for (const x of [-1.12, -1.35, 1.12, 1.35]) {
+      addVoxel(x, 1.90, 0.25, 0.20, 0.20, 0.22, skinLight);
+      addVoxel(x, 2.14, 0.25, 0.20, 0.20, 0.22, skin);
+      addVoxel(x, 1.80, 0.37, 0.14, 0.14, 0.14, skin);
+    }
+
+    // Chest belt and pouch.
+    for (let i = 0; i < 7; i++) {
+      addVoxel(
+        -0.60 + i * 0.20,
+        1.55,
+        0.01,
+        0.19,
+        0.10,
+        0.44,
+        i % 2 === 0 ? leather : leatherDark
+      );
+    }
+
+    addVoxel(0, 1.55, 0.28, 0.18, 0.18, 0.12, brass);
+    addVoxel(0.34, 1.38, 0.38, 0.32, 0.28, 0.34, leatherDark);
+    addVoxel(0.34, 1.38, 0.58, 0.24, 0.18, 0.08, leatherTrim);
+
+    // Chest studs.
+    for (const x of [-0.45, 0, 0.45]) {
+      addVoxel(x, 2.68, 0.60, 0.09, 0.09, 0.08, brass);
+    }
+
+    // Horizontal chest strap.
+    for (let i = 0; i < 7; i++) {
+      addVoxel(
+        -0.60 + i * 0.20,
+        2.52,
+        0.57,
+        0.19,
+        0.08,
+        0.08,
+        leatherDark
+      );
+    }
+
+    // -------------------------------------------------------------------------
+    // Head
+    // -------------------------------------------------------------------------
+
+    for (let row = 0; row < 4; row++) {
+      for (let column = 0; column < 5; column++) {
+        for (let depth = 0; depth < 3; depth++) {
+          addVoxel(
+            -0.52 + column * 0.23,
+            3.62 + row * 0.23,
+            -0.30 + depth * 0.33,
+            0.215,
+            0.215,
+            0.215,
+            (row + column + depth) % 5 === 0
+              ? skinDark
+              : skin
+          );
+        }
+      }
+    }
+
+    // Forehead blocks give the face a chunky, readable silhouette.
+    for (const x of [-0.42, -0.21, 0, 0.21, 0.42]) {
+      addVoxel(x, 4.13, 0.34, 0.19, 0.19, 0.10, skinLight);
+      addVoxel(x, 4.35, 0.34, 0.19, 0.19, 0.10, skin);
+    }
+
+    // Eyes, irises, and tiny highlights.
+    for (const x of [-0.23, 0.23]) {
+      addVoxel(x, 4.08, 0.43, 0.15, 0.15, 0.08, skinDark);
+      addVoxel(x, 4.08, 0.49, 0.10, 0.10, 0.05, eyeBlack);
+      addVoxel(x, 4.08, 0.535, 0.055, 0.055, 0.035, eyeIris);
+      addVoxel(x, 4.08, 0.567, 0.025, 0.025, 0.02, eyeGlint);
+    }
+
+    // Eyebrows.
+    for (const x of [-0.25, 0.25]) {
+      addVoxel(x, 4.25, 0.44, 0.34, 0.08, 0.10, skinDark);
+    }
+
+    // Nose and mouth.
+    addVoxel(0, 4.12, 0.48, 0.15, 0.16, 0.15, skinDark);
+    addVoxel(0, 3.99, 0.53, 0.13, 0.12, 0.12, skin);
+    addVoxel(0, 3.57, 0.47, 0.23, 0.07, 0.08, clubDark);
+    addVoxel(-0.12, 3.43, 0.52, 0.08, 0.17, 0.08, clubLight);
+    addVoxel(0.12, 3.43, 0.52, 0.08, 0.17, 0.08, clubLight);
+
+    // -------------------------------------------------------------------------
+    // Large pointed ears
+    // -------------------------------------------------------------------------
+
+    for (const side of [-1, 1]) {
+      // Ear bases.
+      addVoxel(side * 0.78, 3.48, -0.02, 0.25, 0.25, 0.22, earOuter);
+
+      // Four columns and five rows create a tall, pointed silhouette.
+      for (let column = 0; column < 5; column++) {
+        const x = side * (0.96 + column * 0.18);
+
+        for (let row = 0; row < 5; row++) {
+          const y = 3.55 + row * 0.23;
+
+          addVoxel(x, y, -0.02, 0.17, 0.21, 0.18, earOuter);
+
+          // Inner ear panel on the visible/front side.
+          addVoxel(
+            side * (1.03 + column * 0.18),
+            y,
+            0.12,
+            0.12,
+            0.15,
+            0.08,
+            earInner
+          );
+        }
+      }
+
+      // Dark slit in the inner ear.
+      addVoxel(side * 1.16, 4.18, 0.18, 0.045, 0.25, 0.035, eyeBlack);
+    }
+
+    // -------------------------------------------------------------------------
+    // Spiked wooden club in the right hand
+    // -------------------------------------------------------------------------
+
+    // Handle.
+    for (const x of [1.25, 1.48, 1.71]) {
+      addVoxel(x, 2.12, 0.25, 0.22, 0.22, 0.24, clubWood);
+    }
+
+    // Club head.
+    for (const x of [1.90, 2.13, 2.36]) {
+      for (const y of [2.02, 2.25]) {
+        addVoxel(x, y, 0.25, 0.22, 0.22, 0.24, clubLight);
+      }
+    }
+
+    // Handle spikes.
+    for (const x of [1.25, 1.48, 1.71]) {
+      addVoxel(x, 2.12, 0.35, 0.08, 0.18, 0.18, clubLight);
+    }
+
+    // Head spikes pointing outward.
+    for (const x of [2.56, 2.78, 2.99]) {
+      addVoxel(x, 2.12, 0.25, 0.12, 0.22, 0.22, clubLight);
+    }
+
+    // Top and bottom spikes.
+    for (const x of [2.13, 2.36]) {
+      addVoxel(x, 1.90, 0.46, 0.16, 0.12, 0.12, clubLight);
+      addVoxel(x, 2.34, 0.46, 0.16, 0.12, 0.12, clubLight);
+    }
+
+    // Front spike.
+    addVoxel(2.13, 2.12, 0.55, 0.16, 0.16, 0.10, clubLight);
+
+    // -------------------------------------------------------------------------
+    // Convert all cubes into one efficient instanced mesh
+    // -------------------------------------------------------------------------
+
+    const voxelGeometry = new THREE.BoxGeometry(1, 1, 1);
+    const voxelMaterial = new THREE.MeshStandardMaterial({
+      color: 0xffffff,
+      roughness: 0.86,
+      metalness: 0,
+      flatShading: true
+    });
+
+    const voxelMesh = new THREE.InstancedMesh(
+      voxelGeometry,
+      voxelMaterial,
+      voxels.length
+    );
+
+    const matrix = new THREE.Matrix4();
+    const position = new THREE.Vector3();
+    const quaternion = new THREE.Quaternion();
+    const scale = new THREE.Vector3();
+    const color = new THREE.Color();
+
+    voxels.forEach((voxel, index) => {
+      position.set(voxel.x, voxel.y, voxel.z);
+      scale.set(voxel.sx, voxel.sy, voxel.sz);
+      matrix.compose(position, quaternion, scale);
+      voxelMesh.setMatrixAt(index, matrix);
+      voxelMesh.setColorAt(index, color.setHex(voxel.color));
+    });
+
+    voxelMesh.instanceMatrix.needsUpdate = true;
+    if (voxelMesh.instanceColor) {
+      voxelMesh.instanceColor.needsUpdate = true;
+    }
+
+    voxelMesh.castShadow = true;
+    voxelMesh.receiveShadow = true;
+    voxelMesh.frustumCulled = false;
+    voxelMesh.computeBoundingSphere();
+
+    model.add(voxelMesh);
+    scene.add(model);
+
+    // -------------------------------------------------------------------------
+    // Custom mouse orbit controls — no external controls addon
+    // -------------------------------------------------------------------------
+
+    let dragging = false;
+    let pointerId = null;
+    let lastX = 0;
+    let lastY = 0;
+
+    const canvas = renderer.domElement;
+
+    function resetView() {
+      cameraView.theta = 0.72;
+      cameraView.phi = 1.12;
+      cameraView.radius = 12.6;
+      updateCamera();
+    }
+
+    canvas.addEventListener("pointerdown", (event) => {
+      if (event.button !== 0) return;
+
+      dragging = true;
+      pointerId = event.pointerId;
+      lastX = event.clientX;
+      lastY = event.clientY;
+      canvas.setPointerCapture(pointerId);
+    });
+
+    canvas.addEventListener("pointermove", (event) => {
+      if (!dragging || event.pointerId !== pointerId) return;
+
+      const deltaX = event.clientX - lastX;
+      const deltaY = event.clientY - lastY;
+
+      lastX = event.clientX;
+      lastY = event.clientY;
+
+      cameraView.theta -= deltaX * 0.006;
+      cameraView.phi = THREE.MathUtils.clamp(
+        cameraView.phi - deltaY * 0.005,
+        0.42,
+        1.47
+      );
+
+      updateCamera();
+    });
+
+    function endDrag(event) {
+      if (event.pointerId !== pointerId) return;
+
+      dragging = false;
+
+      if (canvas.hasPointerCapture(pointerId)) {
+        canvas.releasePointerCapture(pointerId);
+      }
+
+      pointerId = null;
+    }
+
+    canvas.addEventListener("pointerup", endDrag);
+    canvas.addEventListener("pointercancel", endDrag);
+
+    canvas.addEventListener(
+      "wheel",
+      (event) => {
+        event.preventDefault();
+
+        cameraView.radius = THREE.MathUtils.clamp(
+          cameraView.radius + event.deltaY * 0.008,
+          7.5,
+          20
+        );
+
+        updateCamera();
+      },
+      { passive: false }
+    );
+
+    canvas.addEventListener("dblclick", resetView);
+    canvas.addEventListener("contextmenu", (event) => event.preventDefault());
+
+    // -------------------------------------------------------------------------
+    // Turntable and UI
+    // -------------------------------------------------------------------------
+
+    let paused = false;
+    let lastTime = performance.now();
+
+    function togglePause() {
+      paused = !paused;
+      pauseButton.textContent = paused ? "Resume rotation" : "Pause turntable";
+    }
+
+    pauseButton.addEventListener("click", togglePause);
+
+    window.addEventListener("keydown", (event) => {
+      if (event.code === "Space" && event.target === document.body) {
+        event.preventDefault();
+        togglePause();
+      }
+    });
+
+    window.addEventListener("resize", () => {
+      camera.aspect = window.innerWidth / window.innerHeight;
+      camera.updateProjectionMatrix();
+      renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+      renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+
+    // -------------------------------------------------------------------------
+    // Animation
+    // -------------------------------------------------------------------------
+
+    function animate(now) {
+      requestAnimationFrame(animate);
+
+      const delta = Math.min((now - lastTime) / 1000, 0.05);
+      lastTime = now;
+
+      if (!paused) {
+        model.rotation.y += delta * 0.16;
+      }
+
+      renderer.render(scene, camera);
+    }
+
+    requestAnimationFrame(animate);
+  </script>
+</body>
+</html>