@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/playground/probe_clipmap_box/main.js

@@ -0,0 +1,323 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { ProbeClipmapDebugView } from "../../renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";
+import { BOX_INSIDE, BoxSunAim, build_hole_box } from "./scene.js";
+
+/**
+ * A closed box with a hole in its ceiling under the probe clipmap GI (`ShadeIndirectLightingMode.ProbeClipmap`):
+ * the sun through the hole onto the red wall, the green wall or the floor, and the hole opened or closed, to
+ * watch how the probes follow a change in the light and in the world.
+ *
+ * Runs under the dev server (`npm run dev`); needs no asset. The panel is hand-rolled, as the other
+ * playgrounds' are.
+ */
+
+/**
+ * Mesh SDF bricks baked a frame while the caches fill, as this page starts: the box's ten slabs are whole in a
+ * few frames.
+ * @type {number}
+ */
+const PAGE_BAKE_BUDGET = 256;
+
+/**
+ * The exposure the page starts at, f-stops; fixed, since eye adaptation would move the picture for seconds
+ * after every change, the very thing the page is for watching.
+ * @type {number}
+ */
+const PAGE_EXPOSURE = 3.5;
+
+/**
+ * A frame-time readout, kept as a rolling mean so the number is readable rather than jittering.
+ */
+class FrameTimer {
+    #samples = new Float64Array(60);
+    #count = 0;
+    #cursor = 0;
+
+    /**
+     * @param {number} seconds
+     */
+    add(seconds) {
+        this.#samples[this.#cursor] = seconds * 1000;
+        this.#cursor = (this.#cursor + 1) % this.#samples.length;
+        this.#count = Math.min(this.#count + 1, this.#samples.length);
+    }
+
+    /**
+     * @returns {number} mean frame time in milliseconds, or 0 before there is anything to average
+     */
+    get mean_ms() {
+        if (this.#count === 0) {
+            return 0;
+        }
+
+        let total = 0;
+
+        for (let i = 0; i < this.#count; i++) {
+            total += this.#samples[i];
+        }
+
+        return total / this.#count;
+    }
+}
+
+/**
+ * Stand the page up. Called by the page rather than run on import, so that nothing here touches the DOM
+ * until there is one.
+ *
+ * @returns {Promise<void>}
+ */
+export async function start() {
+    const element = id => document.getElementById(id);
+
+    const status_element = element('status');
+    const stats_element = element('stats');
+
+    function set_status(text, kind = '') {
+        status_element.textContent = text;
+        status_element.className = kind;
+    }
+
+    const context = element('view').getContext('webgpu');
+
+    if (context === null) {
+        set_status('no WebGPU context — this browser has none, or the page is not a secure context', 'fail');
+        return;
+    }
+
+    const renderer = new Renderer();
+
+    set_status('acquiring a device…');
+
+    await renderer.initialize({ context });
+
+    renderer.indirect_lighting_mode = ShadeIndirectLightingMode.ProbeClipmap;
+    renderer.probe_clipmap.mesh_sdf_bake_budget = PAGE_BAKE_BUDGET;
+    renderer.feature_automatic_exposure_enabled = false;
+    renderer.exposure_compensation = PAGE_EXPOSURE;
+
+    const camera = new PerspectiveCamera();
+
+    camera.near = 0.05;
+    camera.far = 100;
+    camera.fov = 75 * DEG_TO_RAD;
+    camera.aspect = renderer.aspect_ratio;
+
+    const scene = new Scene();
+
+    // the slabs and the sun stand at entities, so the scene names a dataset for them
+    scene.dataset = new EntityComponentDataset();
+
+    const scene_context = renderer.scenes.obtain(scene);
+
+    // body rather than the canvas: the controller's keyboard device needs a focusable element
+    const controller = new OrbitalCameraController(camera, document.body);
+
+    const box = await build_hole_box(scene, scene_context, {
+        aim: BoxSunAim[element('sun_aim').value],
+        open: element('hole_open').checked,
+    });
+
+    // inside, against the front wall, looking at the back one: both coloured walls and the floor in view
+    const h = BOX_INSIDE * 0.5;
+
+    controller.look(new Vector3(0, 0.44 * BOX_INSIDE, 0.92 * h), new Vector3(0, 0.4 * BOX_INSIDE, -h));
+    controller.movement_speed_scale = BOX_INSIDE * 0.05;
+
+    // handy from the console
+    globalThis.renderer = renderer;
+    globalThis.scene = scene;
+    globalThis.camera = camera;
+    globalThis.box = box;
+
+    // ---- what changed, and when -----------------------------------------------------------
+
+    /**
+     * Frames rendered since the sun or the hole last changed, for the stats line: what the probes have had to
+     * follow it.
+     * @type {number}
+     */
+    let frames_since_change = 0;
+
+    /**
+     * The traced reference no longer matches the box. The tracer restarts on its own when the camera
+     * moves, but not when a light or a slab does; while it is off, the restart waits for it to come back
+     * on, so that flipping it on a still camera keeps what it has accumulated.
+     */
+    let trace_stale = false;
+
+    function box_changed() {
+        frames_since_change = 0;
+
+        if (renderer.feature_path_tracing_enabled) {
+            renderer.path_tracer.clear_history = true;
+        } else {
+            trace_stale = true;
+        }
+    }
+
+    const sun_aim_select = element('sun_aim');
+    const hole_toggle = element('hole_open');
+
+    function set_aim(name) {
+        sun_aim_select.value = name;
+        box.aim = BoxSunAim[name];
+        box_changed();
+    }
+
+    function set_open(open) {
+        hole_toggle.checked = open;
+        box.open = open;
+        box_changed();
+    }
+
+    sun_aim_select.addEventListener('change', event => set_aim(event.target.value));
+    hole_toggle.addEventListener('change', event => set_open(event.target.checked));
+
+    // ---- controls -------------------------------------------------------------------------
+
+    element('indirect').addEventListener('change', event => {
+        renderer.indirect_lighting_mode = ShadeIndirectLightingMode[event.target.value];
+    });
+
+    element('debug_view').addEventListener('change', event => {
+        renderer.probe_clipmap.debug_view = ProbeClipmapDebugView[event.target.value];
+    });
+
+    /**
+     * Set by the restart: the next frame renders under IBL, which gives the GI's clipmaps back, and the one
+     * after returns to the probes, which build them again from nothing. The geometry caches stay.
+     * @type {boolean}
+     */
+    let restart_pending = false;
+
+    function restart_gi() {
+        if (renderer.indirect_lighting_mode !== ShadeIndirectLightingMode.ProbeClipmap) {
+            return;
+        }
+
+        renderer.indirect_lighting_mode = ShadeIndirectLightingMode.IBL;
+        restart_pending = true;
+        frames_since_change = 0;
+    }
+
+    element('restart').addEventListener('click', restart_gi);
+
+    const exposure_slider = element('exposure');
+
+    function show_exposure() {
+        element('exposure_value').textContent = `${Number(exposure_slider.value).toFixed(1)}`;
+    }
+
+    exposure_slider.value = String(PAGE_EXPOSURE);
+    show_exposure();
+    exposure_slider.addEventListener('input', () => {
+        renderer.exposure_compensation = Number(exposure_slider.value);
+        show_exposure();
+    });
+
+    const taa_toggle = element('taa');
+    const path_tracing_toggle = element('path_tracing');
+
+    taa_toggle.addEventListener('change', event => {
+        renderer.feature_taa_enabled = event.target.checked;
+    });
+
+    /**
+     * What TAA was before the tracer turned it off, to give it back when the tracer goes.
+     * @type {boolean}
+     */
+    let taa_before_tracing = taa_toggle.checked;
+
+    function set_path_tracing(enabled) {
+        if (enabled === renderer.feature_path_tracing_enabled) {
+            return;
+        }
+
+        path_tracing_toggle.checked = enabled;
+        renderer.feature_path_tracing_enabled = enabled;
+
+        // two temporal filters over one image fight; the tracer accumulates on its own
+        if (enabled) {
+            taa_before_tracing = taa_toggle.checked;
+            taa_toggle.checked = false;
+
+            if (trace_stale) {
+                renderer.path_tracer.clear_history = true;
+                trace_stale = false;
+            }
+        } else {
+            taa_toggle.checked = taa_before_tracing;
+        }
+
+        taa_toggle.disabled = enabled;
+        renderer.feature_taa_enabled = taa_toggle.checked;
+    }
+
+    path_tracing_toggle.addEventListener('change', event => set_path_tracing(event.target.checked));
+
+    const AIM_KEYS = { Digit1: 'RedWall', Digit2: 'GreenWall', Digit3: 'Down' };
+
+    document.addEventListener('keydown', event => {
+        // not in a select, where the keys pick an option
+        if (event.repeat || event.target instanceof HTMLSelectElement) {
+            return;
+        }
+
+        if (event.code in AIM_KEYS) {
+            set_aim(AIM_KEYS[event.code]);
+        } else if (event.code === 'KeyH') {
+            set_open(!hole_toggle.checked);
+        } else if (event.code === 'KeyP') {
+            set_path_tracing(!renderer.feature_path_tracing_enabled);
+        } else if (event.code === 'KeyK') {
+            restart_gi();
+        }
+    });
+
+    document.body.focus();
+
+    set_status('the box is up', 'pass');
+
+    // ---- frame loop -----------------------------------------------------------------------
+
+    const frame_timer = new FrameTimer();
+    const sdf = scene_context.geometries.sdf;
+
+    create_frame_loop((time_delta_s, raf_time_s) => {
+        const width = window.innerWidth;
+        const height = window.innerHeight;
+
+        renderer.resize(width, height);
+        renderer.pixel_ratio = window.devicePixelRatio;
+        camera.aspect = width / height;
+
+        controller.update();
+
+        renderer.render(camera, scene, time_delta_s);
+
+        if (restart_pending) {
+            restart_pending = false;
+            renderer.indirect_lighting_mode = ShadeIndirectLightingMode.ProbeClipmap;
+        }
+
+        frames_since_change++;
+        frame_timer.add(raf_time_s);
+
+        const mean = frame_timer.mean_ms;
+        const baking = sdf.baking_count + sdf.queued_count;
+
+        stats_element.textContent =
+            `${mean.toFixed(1)} ms  ·  ${mean > 0 ? (1000 / mean).toFixed(0) : '0'} fps\n`
+            + `mesh SDFs: ${sdf.resident_count} resident${baking > 0 ? `, ${baking} baking` : ''}\n`
+            + `frames since the last change: ${frames_since_change}`
+            + `${renderer.feature_path_tracing_enabled ? `\npath traced: ${renderer.path_tracer.min_sample_count} samples` : ''}`;
+    }, 60);
+}

package/src/shade/playground/probe_clipmap_box/scene.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The direction the sun's light travels for an aim, unit, into `out`.
+ *
+ * @param {Vector3} out
+ * @param {BoxSunAim} aim
+ * @returns {Vector3} out
+ */
+export function box_sun_direction(out: Vector3, aim: BoxSunAim): Vector3;
+/**
+ * The slabs, each [size, centre, colour], every one at unit scale with a geometry of its own size: a mesh's
+ * distance field is cached per geometry and composed per instance, so a scaled unit cube would not be one.
+ * The side walls stand from the floor's underside to the ceiling's top and the front and back between them,
+ * so no seam runs along an inside edge. The ceiling is four pieces around the hole.
+ *
+ * @returns {{name: string, size: number[], centre: number[], colour: number[]}[]}
+ */
+export function box_slabs(): {
+    name: string;
+    size: number[];
+    centre: number[];
+    colour: number[];
+}[];
+/**
+ * The lid that closes the hole: the hole's own size, flush with the ceiling.
+ *
+ * @returns {{name: string, size: number[], centre: number[], colour: number[]}}
+ */
+export function box_lid(): {
+    name: string;
+    size: number[];
+    centre: number[];
+    colour: number[];
+};
+/**
+ * A closed box with a hole in its ceiling, a red wall at −x and a green one at +x, a sun that shines in through
+ * the hole, and a flat sky. Built into a scene that names a dataset, whose context is `scene_context`.
+ *
+ * The hole is closed by placing a lid into it and opened by taking the lid out, so the distance field the
+ * GI's rays march changes as a level's would. Closed, nothing reaches the inside: whatever light is left there is
+ * what the GI still holds.
+ *
+ * @param {import("../../renderer/scene/Scene.js").Scene} scene
+ * @param {import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext} scene_context
+ * @param {object} [options]
+ * @param {number} [options.sun_intensity]
+ * @param {number[]} [options.sky] linear radiance of the flat sky
+ * @param {BoxSunAim} [options.aim]
+ * @param {boolean} [options.open]
+ */
+export function build_hole_box(scene: import("../../renderer/scene/Scene.js").Scene, scene_context: import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext, { sun_intensity, sky, aim, open, }?: {
+    sun_intensity?: number;
+    sky?: number[];
+    aim?: BoxSunAim;
+    open?: boolean;
+}): Promise<{
+    sun: import("../../renderer/light/model/DirectionalLight.js").DirectionalLight;
+    aim: number;
+    open: boolean;
+}>;
+/**
+ * The inside of the box, a side, metres: x and z in [−½, ½] of it, y in [0, 1] of it. Five probe spacings of
+ * the finest cascade at the GI's default spacing.
+ * @type {number}
+ */
+export const BOX_INSIDE: number;
+/**
+ * Every slab's thickness, metres: two voxels of the finest brick at the GI's default voxel, so a wall has an
+ * inside the distance field can tell from its outside.
+ * @type {number}
+ */
+export const BOX_WALL: number;
+/**
+ * The hole in the middle of the ceiling, a side, metres.
+ * @type {number}
+ */
+export const BOX_HOLE: number;
+/**
+ * How far below the horizon the sun stands when it is aimed at a wall, degrees: through the hole's middle it
+ * lands on the wall's middle.
+ * @type {number}
+ */
+export const BOX_SUN_WALL_ELEVATION: number;
+/**
+ * Where the sun's light falls inside the box, through the hole.
+ */
+export type BoxSunAim = number;
+export namespace BoxSunAim {
+    let RedWall: number;
+    let GreenWall: number;
+    let Down: number;
+}
+import Vector3 from "../../../core/geom/Vector3.js";
+//# sourceMappingURL=scene.d.ts.map

package/src/shade/playground/probe_clipmap_box/scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap_box/scene.js"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,uCAJW,OAAO,OACP,SAAS,GACP,OAAO,CAgBnB;AAED;;;;;;;GAOG;AACH,6BAFa;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAC,EAAE,CAwBhF;AAED;;;;GAIG;AACH,2BAFa;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAC,CAI9E;AAgBD;;;;;;;;;;;;;;;GAeG;AACH,sCARW,OAAO,+BAA+B,EAAE,KAAK,iBAC7C,OAAO,yCAAyC,EAAE,eAAe;IAEhD,aAAa,GAA9B,MAAM;IACa,GAAG,GAAtB,MAAM,EAAE;IACY,GAAG,GAAvB,SAAS;IACS,IAAI,GAAtB,OAAO;;;;;GAuGjB;AAnPD;;;;GAIG;AACH,yBAFU,MAAM,CAEY;AAE5B;;;;GAIG;AACH,uBAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,uBAFU,MAAM,CAEa;AAE7B;;;;GAIG;AACH,qCAFU,MAAM,CAEyB;;;;wBAY/B,MAAM;;;;;;oBA/CI,+BAA+B"}

package/src/shade/playground/probe_clipmap_box/scene.js

@@ -0,0 +1,256 @@
+import { Color } from "../../../core/color/Color.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { BoxGeometry } from "../../renderer/geometry/BoxGeometry.js";
+import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
+import { make_sunlight } from "../../renderer/light/make_sunlight.js";
+import { place_light } from "../../renderer/light/place_light.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { place_primitive, remove_primitive } from "../../renderer/scene/rows/place_primitive.js";
+import { make_flat_environment } from "../skinned_blas_refit/flat_environment.js";
+
+/**
+ * The inside of the box, a side, metres: x and z in [−½, ½] of it, y in [0, 1] of it. Five probe spacings of
+ * the finest cascade at the GI's default spacing.
+ * @type {number}
+ */
+export const BOX_INSIDE = 5;
+
+/**
+ * Every slab's thickness, metres: two voxels of the finest brick at the GI's default voxel, so a wall has an
+ * inside the distance field can tell from its outside.
+ * @type {number}
+ */
+export const BOX_WALL = 0.25;
+
+/**
+ * The hole in the middle of the ceiling, a side, metres.
+ * @type {number}
+ */
+export const BOX_HOLE = 1.25;
+
+/**
+ * How far below the horizon the sun stands when it is aimed at a wall, degrees: through the hole's middle it
+ * lands on the wall's middle.
+ * @type {number}
+ */
+export const BOX_SUN_WALL_ELEVATION = 45;
+
+/**
+ * The classic Cornell box reflectances.
+ */
+const WHITE = [0.73, 0.73, 0.73];
+const RED = [0.63, 0.065, 0.05];
+const GREEN = [0.14, 0.45, 0.091];
+
+/**
+ * Where the sun's light falls inside the box, through the hole.
+ * @readonly
+ * @enum {number}
+ */
+export const BoxSunAim = {
+    /** onto the red wall, at −x, from high over +x */
+    RedWall: 0,
+    /** onto the green wall, at +x, from high over −x */
+    GreenWall: 1,
+    /** straight down onto the middle of the floor */
+    Down: 2,
+};
+
+/**
+ * The direction the sun's light travels for an aim, unit, into `out`.
+ *
+ * @param {Vector3} out
+ * @param {BoxSunAim} aim
+ * @returns {Vector3} out
+ */
+export function box_sun_direction(out, aim) {
+    const elevation = BOX_SUN_WALL_ELEVATION * Math.PI / 180;
+
+    if (aim === BoxSunAim.RedWall) {
+        out.set(-Math.cos(elevation), -Math.sin(elevation), 0);
+    } else if (aim === BoxSunAim.GreenWall) {
+        out.set(Math.cos(elevation), -Math.sin(elevation), 0);
+    } else if (aim === BoxSunAim.Down) {
+        out.set(0, -1, 0);
+    } else {
+        throw new Error(`unknown sun aim ${aim}`);
+    }
+
+    return out;
+}
+
+/**
+ * The slabs, each [size, centre, colour], every one at unit scale with a geometry of its own size: a mesh's
+ * distance field is cached per geometry and composed per instance, so a scaled unit cube would not be one.
+ * The side walls stand from the floor's underside to the ceiling's top and the front and back between them,
+ * so no seam runs along an inside edge. The ceiling is four pieces around the hole.
+ *
+ * @returns {{name: string, size: number[], centre: number[], colour: number[]}[]}
+ */
+export function box_slabs() {
+    const h = BOX_INSIDE * 0.5;
+    const t = BOX_WALL;
+    const a = BOX_HOLE * 0.5;
+    const outer = BOX_INSIDE + 2 * t;
+    const tall = BOX_INSIDE + 2 * t;
+    const mid = BOX_INSIDE * 0.5;
+    const top = BOX_INSIDE + t * 0.5;
+    // a ceiling piece beside the hole, along x, from the hole's edge to the outside
+    const strip = h + t - a;
+
+    return [
+        { name: 'floor', size: [outer, t, outer], centre: [0, -t * 0.5, 0], colour: WHITE },
+        { name: 'red wall', size: [t, tall, outer], centre: [-h - t * 0.5, mid, 0], colour: RED },
+        { name: 'green wall', size: [t, tall, outer], centre: [h + t * 0.5, mid, 0], colour: GREEN },
+        { name: 'back wall', size: [BOX_INSIDE, tall, t], centre: [0, mid, -h - t * 0.5], colour: WHITE },
+        { name: 'front wall', size: [BOX_INSIDE, tall, t], centre: [0, mid, h + t * 0.5], colour: WHITE },
+        { name: 'ceiling, back', size: [outer, t, strip], centre: [0, top, -a - strip * 0.5], colour: WHITE },
+        { name: 'ceiling, front', size: [outer, t, strip], centre: [0, top, a + strip * 0.5], colour: WHITE },
+        { name: 'ceiling, left', size: [strip, t, BOX_HOLE], centre: [-a - strip * 0.5, top, 0], colour: WHITE },
+        { name: 'ceiling, right', size: [strip, t, BOX_HOLE], centre: [a + strip * 0.5, top, 0], colour: WHITE },
+    ];
+}
+
+/**
+ * The lid that closes the hole: the hole's own size, flush with the ceiling.
+ *
+ * @returns {{name: string, size: number[], centre: number[], colour: number[]}}
+ */
+export function box_lid() {
+    return { name: 'lid', size: [BOX_HOLE, BOX_WALL, BOX_HOLE], centre: [0, BOX_INSIDE + BOX_WALL * 0.5, 0], colour: WHITE };
+}
+
+/**
+ * @param {number[]} rgb linear
+ * @returns {StandardShadeMaterial}
+ */
+function diffuse(rgb) {
+    const material = new StandardShadeMaterial();
+
+    material.diffuse_color.copy(new Color(rgb[0], rgb[1], rgb[2]));
+    material.roughness_factor = 1;
+    material.metallic_factor = 0;
+
+    return material;
+}
+
+/**
+ * A closed box with a hole in its ceiling, a red wall at −x and a green one at +x, a sun that shines in through
+ * the hole, and a flat sky. Built into a scene that names a dataset, whose context is `scene_context`.
+ *
+ * The hole is closed by placing a lid into it and opened by taking the lid out, so the distance field the
+ * GI's rays march changes as a level's would. Closed, nothing reaches the inside: whatever light is left there is
+ * what the GI still holds.
+ *
+ * @param {import("../../renderer/scene/Scene.js").Scene} scene
+ * @param {import("../../renderer/scene/GPUSceneContext.js").GPUSceneContext} scene_context
+ * @param {object} [options]
+ * @param {number} [options.sun_intensity]
+ * @param {number[]} [options.sky] linear radiance of the flat sky
+ * @param {BoxSunAim} [options.aim]
+ * @param {boolean} [options.open]
+ */
+export async function build_hole_box(scene, scene_context, {
+    sun_intensity = 7.2,
+    sky = [0.2, 0.25, 0.35],
+    aim = BoxSunAim.RedWall,
+    open = true,
+} = {}) {
+    // meshlet geometry is built as it is made
+    await MeshoptClusterizer.ready;
+
+    /**
+     * @param {{name: string, size: number[], centre: number[], colour: number[]}} slab
+     * @param {BoxGeometry} geometry
+     * @param {StandardShadeMaterial} material
+     * @returns {number} the entity
+     */
+    function place(slab, geometry, material) {
+        const transform = new Transform64();
+
+        transform.setTranslation(slab.centre[0], slab.centre[1], slab.centre[2]);
+        transform.updateMatrix();
+
+        return place_primitive(scene_context, geometry, material, transform, { name: slab.name });
+    }
+
+    for (const slab of box_slabs()) {
+        place(slab, new BoxGeometry(slab.size[0], slab.size[1], slab.size[2]), diffuse(slab.colour));
+    }
+
+    const lid = box_lid();
+    const lid_geometry = new BoxGeometry(lid.size[0], lid.size[1], lid.size[2]);
+    const lid_material = diffuse(lid.colour);
+
+    /**
+     * The lid's entity while it closes the hole, -1 while the hole is open.
+     * @type {number}
+     */
+    let lid_entity = -1;
+
+    scene.lights.environment = make_flat_environment(sky);
+
+    const sun = make_sunlight({ intensity: sun_intensity });
+
+    place_light(scene, sun);
+
+    const direction = new Vector3();
+    const rotation = new Quaternion();
+
+    let current_aim = aim;
+
+    const box = {
+        sun,
+
+        get aim() {
+            return current_aim;
+        },
+
+        /**
+         * @param {BoxSunAim} v
+         */
+        set aim(v) {
+            box_sun_direction(direction, v);
+
+            rotation.fromUnitVectors(Vector3.forward, direction);
+            rotation.normalize();
+
+            sun.transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+            sun.transform.updateMatrix();
+
+            // a light changed in place reaches the GPU only through the collection's version; without it the
+            // shadow cascades, which read the transform themselves, turn and the light does not
+            scene.lights.needsUpdate = true;
+
+            current_aim = v;
+        },
+
+        get open() {
+            return lid_entity === -1;
+        },
+
+        /**
+         * @param {boolean} v
+         */
+        set open(v) {
+            if (v === (lid_entity === -1)) {
+                return;
+            }
+
+            if (v) {
+                remove_primitive(scene_context, lid_entity);
+                lid_entity = -1;
+            } else {
+                lid_entity = place(lid, lid_geometry, lid_material);
+            }
+        },
+
+    };
+
+    box.aim = aim;
+    box.open = open;
+
+    return box;
+}

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}