@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/playground/path_traced_media/index.html

@@ -0,0 +1,71 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>meep — path-traced participating media</title>
+    <style>
+        :root {
+            color-scheme: dark;
+            --bg: #14161a;
+            --line: #2b3038;
+            --text: #d6dae0;
+            --muted: #8b939f;
+            --pass: #55c46a;
+            --fail: #ff6b6b;
+        }
+
+        * { box-sizing: border-box; }
+
+        body {
+            margin: 0;
+            padding: 16px;
+            background: var(--bg);
+            color: var(--text);
+            font: 13px/1.5 system-ui, -apple-system, Segoe UI, sans-serif;
+        }
+
+        h1 { font-size: 16px; font-weight: 600; margin: 0 0 4px; }
+
+        p { margin: 0 0 12px; color: var(--muted); max-width: 90ch; }
+
+        .stage { display: flex; gap: 16px; align-items: flex-start; flex-wrap: wrap; }
+
+        canvas {
+            display: block;
+            width: 512px;
+            height: 512px;
+            max-width: 100%;
+            image-rendering: pixelated;
+            border: 1px solid var(--line);
+            border-radius: 4px;
+        }
+
+        .controls { display: flex; flex-direction: column; gap: 8px; min-width: 280px; max-width: 640px; }
+
+        select, button { font: inherit; padding: 4px 8px; }
+
+        pre { margin: 0; white-space: pre-wrap; font: 12px/1.45 ui-monospace, Consolas, monospace; }
+
+        pre.pass { color: var(--pass); }
+
+        pre.fail { color: var(--fail); }
+    </style>
+</head>
+<body>
+<h1>Path-traced participating media</h1>
+<p>Participating media in the accumulating path tracer. The first scene is one to look at. The checks
+    below it are built for a number, not a picture: each frames exactly one closed-form answer — a slab
+    filling the view, a white furnace in which a lossless object should vanish — and <b>run the checks</b>
+    renders each to convergence and compares regions of the image with it.</p>
+<div class="stage">
+    <canvas id="view"></canvas>
+    <div class="controls">
+        <label>scene <select id="check"></select></label>
+        <p id="about"></p>
+        <button id="run">run the checks</button>
+        <pre id="report">starting…</pre>
+    </div>
+</div>
+<script type="module" src="./main.js"></script>
+</body>
+</html>

package/src/shade/playground/path_traced_media/main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.d.ts.map

package/src/shade/playground/path_traced_media/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/path_traced_media/main.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,440 @@
+import Quaternion from "../../../core/geom/Quaternion.js";
+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 { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
+import { meshlet_geometry_build_from_geometry } from "../../renderer/geometry/meshlet_geometry_build_from_geometry.js";
+import { MeshletGeometry } from "../../renderer/geometry/MeshletGeometry.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { place_primitive } from "../../renderer/scene/rows/place_primitive.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { load_default_environment } from "../load_default_environment.js";
+import { make_flat_environment } from "../skinned_blas_refit/flat_environment.js";
+import { CaptureRadiance } from "./capture_radiance.js";
+import { agrees, MEDIA_CHECKS, region_statistics } from "./checks.js";
+import { MEDIA_VIEWS } from "./views.js";
+
+/**
+ * The path tracer's participating media against closed-form answers: Beer-Lambert through an
+ * index-matched slab and through glass with every internal reflection summed, a camera that starts
+ * inside a medium, white furnaces for a scattering glass sphere and a fog volume, and shadow rays
+ * through a medium-bounding mesh and through a fog volume. See the README.
+ *
+ * Above them in the list, scenes to look at (`views.js`): the same media in a setting with
+ * something to see through them.
+ *
+ * `npm run dev`, then `/src/shade/playground/path_traced_media/`. From the console:
+ * `run_checks({ frames, only })` runs the checks (all, or the ones whose name contains `only`) and
+ * returns the report; `show(name)` puts a view or a check on screen; `accumulate(frames)` and
+ * `read_radiance()` drive and read it where the page's own frame loop does not run.
+ */
+
+/** small, so a full image is one tile of the accumulating tracer and converges in seconds */
+const SIZE = 256;
+
+/** what is on screen to be looked at, four tiles */
+const VIEW_SIZE = 512;
+
+/**
+ * Frames each check accumulates, one sample per pixel each. Enough for every check's tolerance; the
+ * scattering spheres take tens of milliseconds a frame, so more is minutes of a saturated GPU.
+ */
+const DEFAULT_FRAMES = 256;
+
+function element(id) {
+    return document.getElementById(id);
+}
+
+function report(text, kind = '') {
+    const node = element('report');
+
+    node.textContent = text;
+    node.className = kind;
+}
+
+async function main() {
+    // the meshlet builder's WASM instantiates asynchronously at import
+    await MeshoptClusterizer.ready;
+
+    const canvas = element('view');
+
+    canvas.width = SIZE;
+    canvas.height = SIZE;
+
+    const camera = new PerspectiveCamera();
+
+    camera.near = 0.05;
+    camera.far = 200;
+    camera.aspect = 1;
+
+    const context = canvas.getContext('webgpu');
+
+    if (context === null) {
+        report('no WebGPU context — this browser has none, or the page is not a secure context', 'fail');
+        return;
+    }
+
+    const renderer = new Renderer();
+
+    await renderer.initialize({ context, pixelRatio: 1 });
+
+    renderer.resize(SIZE, SIZE);
+
+    // the tracer's own running mean is what is measured: nothing after it may touch the colour
+    renderer.feature_path_tracing_enabled = true;
+    renderer.feature_taa_enabled = false;
+    renderer.feature_dof_enabled = false;
+    renderer.feature_motion_blur_enabled = false;
+    renderer.feature_sharpening_enabled = false;
+    renderer.feature_bloom_enabled = false;
+    renderer.feature_automatic_exposure_enabled = false;
+    renderer.exposure_compensation = 1;
+
+    // a true running mean, never an exponential one
+    renderer.path_tracer.min_accumulation_alpha = 0;
+
+    const device = renderer.graphics.device;
+
+    const capture = new CaptureRadiance(device);
+
+    renderer.add_extension(capture);
+
+    const scratch_transform = new Transform64();
+
+    /**
+     * @param {number} size
+     */
+    function set_size(size) {
+        if (canvas.width === size) {
+            return;
+        }
+
+        canvas.width = size;
+        canvas.height = size;
+
+        renderer.resize(size, size);
+    }
+
+    /**
+     * @param {MediaCheck} check
+     * @param {function(MediaScene): void} build
+     * @returns {Scene}
+     */
+    function build_scene(check, build) {
+        const scene = new Scene();
+
+        scene.dataset = new EntityComponentDataset();
+
+        if (check.environment === 'sky') {
+            scene.lights.environment = make_flat_environment([0.45, 0.55, 0.75]);
+
+            load_default_environment(scene).then(applied => {
+                if (applied) {
+                    renderer.path_tracer.clear_history = true;
+                }
+            });
+        } else {
+            scene.lights.environment = make_flat_environment(check.environment);
+        }
+
+        const scene_context = renderer.scenes.obtain(scene);
+
+        build({
+            scene,
+            place(geometry, material, position, rotation = new Quaternion()) {
+                scratch_transform.setTranslation(position.x, position.y, position.z);
+                scratch_transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+                scratch_transform.updateMatrix();
+
+                place_primitive(scene_context, geometry, material, scratch_transform);
+            },
+            meshlets(geometry) {
+                const meshlets = new MeshletGeometry();
+
+                meshlet_geometry_build_from_geometry(geometry, meshlets);
+
+                return meshlets;
+            },
+        });
+
+        return scene;
+    }
+
+    function aim(check) {
+        const { position, target, fov_degrees } = check.camera;
+
+        camera.fov = fov_degrees * DEG_TO_RAD;
+        camera.transform.setTranslation(position[0], position[1], position[2]);
+        camera.transform.lookAt(new Vector3(target[0], target[1], target[2]));
+        camera.transform.updateMatrix();
+    }
+
+    /** what the frame loop draws when no check is running */
+    let live_scene = null;
+    let busy = false;
+
+    /**
+     * @param {MediaCheck} check
+     * @param {function(MediaScene): void} build
+     * @param {number} frames
+     */
+    async function measure(check, build, frames) {
+        set_size(SIZE);
+
+        const scene = build_scene(check, build);
+
+        aim(check);
+
+        // a few frames first, so pipeline compilation is not in the timing
+        for (let i = 0; i < 4; i++) {
+            renderer.render(camera, scene, 0);
+        }
+
+        await device.queue.onSubmittedWorkDone();
+
+        renderer.path_tracer.clear_history = true;
+
+        // the accumulation is read halfway too: the two halves differ by the estimate's noise alone
+        const half = frames >> 1;
+
+        let half_image = null;
+        let waited = 0;
+
+        const started = performance.now();
+
+        for (let i = 0; i < frames; i++) {
+            capture.enabled = i === half - 1 || i === frames - 1;
+
+            renderer.render(camera, scene, 0);
+
+            if (i === half - 1) {
+                const waiting = performance.now();
+
+                await device.queue.onSubmittedWorkDone();
+                half_image = await capture.read();
+
+                waited = performance.now() - waiting;
+            } else if ((i & 31) === 31) {
+                await device.queue.onSubmittedWorkDone();
+            }
+        }
+
+        await device.queue.onSubmittedWorkDone();
+
+        const ms_per_frame = (performance.now() - started - waited) / frames;
+
+        capture.enabled = false;
+
+        live_scene = scene;
+
+        return {
+            image: await capture.read(),
+            half_image,
+            samples: renderer.path_tracer.min_sample_count,
+            ms_per_frame,
+        };
+    }
+
+    /**
+     * @param {MediaCheck} check
+     * @param {number} frames
+     */
+    async function run_check(check, frames) {
+        const started = performance.now();
+
+        const test = await measure(check, check.test, frames);
+        const control = check.control !== undefined ? await measure(check, check.control, frames) : null;
+
+        const fov = check.camera.fov_degrees;
+
+        const regions = check.regions.map(region => {
+            const measured = region_statistics(test.image, region.rect, region.expected, fov, test.half_image);
+
+            let mean = measured.mean;
+            let standard_error = measured.standard_error;
+
+            if (region.ratio) {
+                const reference = region_statistics(control.image, region.rect, region.expected, fov, control.half_image);
+
+                mean = measured.mean.map((m, c) => m / reference.mean[c]);
+                standard_error = measured.mean.map((m, c) => Math.hypot(
+                    measured.standard_error[c] / reference.mean[c],
+                    m * reference.standard_error[c] / (reference.mean[c] * reference.mean[c])
+                ));
+            }
+
+            // every frame accumulated, in the control too: a history reset mid-run measures less
+            const accumulated = test.samples === frames && (control === null || control.samples === frames);
+
+            const pass = accumulated
+                && measured.non_finite === 0
+                && mean.every((m, c) => agrees(m, standard_error[c], measured.expected[c], region.allowance));
+
+            return {
+                name: region.name,
+                pass,
+                expected: measured.expected.map(v => +v.toFixed(5)),
+                measured: mean.map(v => +v.toFixed(5)),
+                standard_error: standard_error.map(v => +v.toExponential(2)),
+                pixels: measured.pixels,
+                non_finite: measured.non_finite,
+            };
+        });
+
+        return {
+            name: check.name,
+            pass: regions.every(r => r.pass),
+            samples: test.samples,
+            seconds: +((performance.now() - started) / 1000).toFixed(1),
+            ms_per_frame: +test.ms_per_frame.toFixed(2),
+            regions,
+        };
+    }
+
+    async function run_checks({ frames = DEFAULT_FRAMES, only = '' } = {}) {
+        if (busy) {
+            throw new Error('checks are already running');
+        }
+
+        busy = true;
+
+        const results = [];
+
+        try {
+            for (const check of MEDIA_CHECKS) {
+                if (!check.name.includes(only)) {
+                    continue;
+                }
+
+                report(`running "${check.name}"…`);
+
+                results.push(await run_check(check, frames));
+            }
+        } finally {
+            busy = false;
+        }
+
+        const failed = results.filter(r => !r.pass).length;
+
+        report(
+            results.map(r => `${r.pass ? 'PASS' : 'FAIL'}  ${r.name}\n${r.regions.map(region => `      ${region.pass ? 'ok  ' : 'FAIL'} ${region.name}: ${region.measured.join(', ')} (expected ${region.expected.join(', ')})`).join('\n')}`).join('\n'),
+            failed === 0 ? 'pass' : 'fail'
+        );
+
+        return {
+            adapter: `${renderer.graphics.adapter?.info?.vendor ?? '?'}/${renderer.graphics.adapter?.info?.architecture ?? '?'}`,
+            frames,
+            failed,
+            results,
+        };
+    }
+
+    const entries = [...MEDIA_VIEWS, ...MEDIA_CHECKS];
+
+    /**
+     * @param {string} name of a view or a check
+     */
+    function show(name) {
+        const entry = entries.find(e => e.name === name);
+
+        if (entry === undefined) {
+            throw new Error(`no view or check named "${name}"`);
+        }
+
+        set_size(VIEW_SIZE);
+
+        live_scene = build_scene(entry, entry.test);
+
+        aim(entry);
+
+        renderer.path_tracer.clear_history = true;
+
+        element('check').value = name;
+        element('about').textContent = entry.about;
+    }
+
+    const select = element('check');
+
+    for (const [label, list] of [['to look at', MEDIA_VIEWS], ['checks — closed forms, abstract by design', MEDIA_CHECKS]]) {
+        const group = document.createElement('optgroup');
+
+        group.label = label;
+
+        for (const entry of list) {
+            const option = document.createElement('option');
+
+            option.value = entry.name;
+            option.textContent = entry.name;
+
+            group.appendChild(option);
+        }
+
+        select.appendChild(group);
+    }
+
+    select.addEventListener('change', () => show(select.value));
+
+    element('run').addEventListener('click', () => {
+        run_checks().catch(error => report(`checks: ${error.message}`, 'fail'));
+    });
+
+    show(MEDIA_VIEWS[0].name);
+
+    /**
+     * The radiance of the scene on screen, as the tracer has accumulated it so far.
+     * @returns {Promise<{rgb: Float32Array, width: number, height: number}>}
+     */
+    async function read_radiance() {
+        capture.enabled = true;
+
+        renderer.render(camera, live_scene, 0);
+
+        await device.queue.onSubmittedWorkDone();
+
+        capture.enabled = false;
+
+        return capture.read();
+    }
+
+    /**
+     * Accumulate `frames` more samples of the scene on screen, without waiting for the frame loop —
+     * which a hidden page does not run.
+     * @param {number} frames
+     * @returns {Promise<number>} samples per pixel so far
+     */
+    async function accumulate(frames) {
+        for (let i = 0; i < frames; i++) {
+            renderer.render(camera, live_scene, 0);
+
+            if ((i & 15) === 15) {
+                await device.queue.onSubmittedWorkDone();
+            }
+        }
+
+        await device.queue.onSubmittedWorkDone();
+
+        return renderer.path_tracer.min_sample_count;
+    }
+
+    globalThis.renderer = renderer;
+    globalThis.run_checks = run_checks;
+    globalThis.show = show;
+    globalThis.read_radiance = read_radiance;
+    globalThis.accumulate = accumulate;
+
+    report('ready — pick a scene to look at, or run the checks');
+
+    create_frame_loop(() => {
+        if (!busy && live_scene !== null) {
+            renderer.render(camera, live_scene, 0);
+        }
+    });
+}
+
+main().catch(error => {
+    report(`page: ${error.message}`, 'fail');
+    console.error(error);
+});

package/src/shade/playground/path_traced_media/make_wave_pool_geometry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A closed body of water whose top is a sum of two sine waves: `width` by `length` (x by z), its
+ * bottom at y = 0, its surface at `depth` plus the waves. The surface's vertex normals are the waves'
+ * own, from their gradient, so the interpolated normal is the smooth surface's — what manifold
+ * next-event estimation focuses light through. The sides follow the waves along the top edge, so the
+ * mesh is closed; every face's normal points out.
+ *
+ * @param {object} options
+ * @param {number} options.width
+ * @param {number} options.length
+ * @param {number} options.depth mean height of the surface over the bottom
+ * @param {number} options.amplitude of each wave
+ * @param {number} options.wavelength of the first wave; the second is 0.63 of it, at an angle
+ * @param {number} options.segments grid cells along each side of the surface
+ * @returns {Geometry}
+ */
+export function make_wave_pool_geometry({ width, length, depth, amplitude, wavelength, segments }: {
+    width: number;
+    length: number;
+    depth: number;
+    amplitude: number;
+    wavelength: number;
+    segments: number;
+}): Geometry;
+import { Geometry } from "../../renderer/geometry/Geometry.js";
+//# sourceMappingURL=make_wave_pool_geometry.d.ts.map

package/src/shade/playground/path_traced_media/make_wave_pool_geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make_wave_pool_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/path_traced_media/make_wave_pool_geometry.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH;IAR2B,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,KAAK,EAArB,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACJ,QAAQ,CAkGpB;yBAnHwB,qCAAqC"}

package/src/shade/playground/path_traced_media/make_wave_pool_geometry.js

@@ -0,0 +1,117 @@
+import { Attribute } from "../../renderer/geometry/Attribute.js";
+import { Geometry } from "../../renderer/geometry/Geometry.js";
+import { StandardAttributes } from "../../renderer/geometry/StandardAttributes.js";
+
+/**
+ * A closed body of water whose top is a sum of two sine waves: `width` by `length` (x by z), its
+ * bottom at y = 0, its surface at `depth` plus the waves. The surface's vertex normals are the waves'
+ * own, from their gradient, so the interpolated normal is the smooth surface's — what manifold
+ * next-event estimation focuses light through. The sides follow the waves along the top edge, so the
+ * mesh is closed; every face's normal points out.
+ *
+ * @param {object} options
+ * @param {number} options.width
+ * @param {number} options.length
+ * @param {number} options.depth mean height of the surface over the bottom
+ * @param {number} options.amplitude of each wave
+ * @param {number} options.wavelength of the first wave; the second is 0.63 of it, at an angle
+ * @param {number} options.segments grid cells along each side of the surface
+ * @returns {Geometry}
+ */
+export function make_wave_pool_geometry({ width, length, depth, amplitude, wavelength, segments }) {
+    const k1 = 2 * Math.PI / wavelength;
+    const k2 = k1 / 0.63;
+
+    // two waves, the second across the first at about 40 degrees
+    const d2 = [Math.cos(0.7), Math.sin(0.7)];
+
+    const height = (x, z) => depth
+        + amplitude * Math.sin(k1 * x)
+        + amplitude * Math.sin(k2 * (d2[0] * x + d2[1] * z) + 1.3);
+
+    const gradient = (x, z) => {
+        const c2 = amplitude * k2 * Math.cos(k2 * (d2[0] * x + d2[1] * z) + 1.3);
+        return [amplitude * k1 * Math.cos(k1 * x) + c2 * d2[0], c2 * d2[1]];
+    };
+
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+
+    function vertex(p, n, uv) {
+        positions.push(p[0], p[1], p[2]);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(uv[0], uv[1]);
+        return positions.length / 3 - 1;
+    }
+
+    // the surface, wound counter-clockwise seen from above
+    const top = [];
+
+    for (let j = 0; j <= segments; j++) {
+        for (let i = 0; i <= segments; i++) {
+            const x = (i / segments - 0.5) * width;
+            const z = (j / segments - 0.5) * length;
+            const [gx, gz] = gradient(x, z);
+            const n = [-gx, 1, -gz];
+            const l = Math.hypot(...n);
+
+            top.push(vertex([x, height(x, z), z], n.map(c => c / l), [i / segments, j / segments]));
+        }
+    }
+
+    for (let j = 0; j < segments; j++) {
+        for (let i = 0; i < segments; i++) {
+            const a = top[j * (segments + 1) + i];
+            const b = top[j * (segments + 1) + i + 1];
+            const c = top[(j + 1) * (segments + 1) + i];
+            const d = top[(j + 1) * (segments + 1) + i + 1];
+
+            indices.push(a, c, b, b, c, d);
+        }
+    }
+
+    // the bottom, facing down
+    const hw = width / 2, hl = length / 2;
+    const down = [0, -1, 0];
+    const b0 = vertex([-hw, 0, -hl], down, [0, 0]);
+    const b1 = vertex([hw, 0, -hl], down, [1, 0]);
+    const b2 = vertex([-hw, 0, hl], down, [0, 1]);
+    const b3 = vertex([hw, 0, hl], down, [1, 1]);
+
+    indices.push(b0, b1, b2, b1, b3, b2);
+
+    // the four sides, each a strip from the bottom edge up to the surface's edge
+    const sides = [
+        { normal: [0, 0, -1], at: t => [(t - 0.5) * width, -hl] },
+        { normal: [1, 0, 0], at: t => [hw, (t - 0.5) * length] },
+        { normal: [0, 0, 1], at: t => [(0.5 - t) * width, hl] },
+        { normal: [-1, 0, 0], at: t => [-hw, (0.5 - t) * length] },
+    ];
+
+    for (const side of sides) {
+        for (let i = 0; i < segments; i++) {
+            const [x0, z0] = side.at(i / segments);
+            const [x1, z1] = side.at((i + 1) / segments);
+
+            const lower0 = vertex([x0, 0, z0], side.normal, [i / segments, 0]);
+            const lower1 = vertex([x1, 0, z1], side.normal, [(i + 1) / segments, 0]);
+            const upper0 = vertex([x0, height(x0, z0), z0], side.normal, [i / segments, 1]);
+            const upper1 = vertex([x1, height(x1, z1), z1], side.normal, [(i + 1) / segments, 1]);
+
+            // counter-clockwise seen from outside
+            indices.push(lower0, upper1, lower1, lower0, upper0, upper1);
+        }
+    }
+
+    const geometry = new Geometry();
+
+    geometry.name = "WavePool";
+    geometry.index = Attribute.from(new Uint32Array(indices), 1, 'index');
+    geometry.addAttribute(Attribute.from(new Float32Array(positions), 3, StandardAttributes.Position));
+    geometry.addAttribute(Attribute.from(new Float32Array(normals), 3, StandardAttributes.Normal));
+    geometry.addAttribute(Attribute.from(new Float32Array(uvs), 2, StandardAttributes.TextureCoordinates0));
+
+    return geometry;
+}

package/src/shade/playground/path_traced_media/views.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @type {MediaView[]}
+ */
+export const MEDIA_VIEWS: MediaView[];
+/**
+ * Scenes to look at, not to measure: what the media do in a setting with something to see through
+ * them. `environment: 'sky'` lights them with the playground's default sky when `test_assets/` has
+ * it, and a flat blue one until then.
+ */
+export type MediaView = {
+    name: string;
+    about: string;
+    environment: number[] | 'sky';
+    camera: {
+        position: number[];
+        target: number[];
+        fov_degrees: number;
+    };
+    test: (arg0: MediaScene) => void;
+};
+//# sourceMappingURL=views.d.ts.map

package/src/shade/playground/path_traced_media/views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/path_traced_media/views.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,0BAFU,SAAS,EAAE,CAqHnB;;;;;;;UA5IY,MAAM;WACN,MAAM;iBACN,MAAM,EAAE,GAAC,KAAK;YACd;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC;gCACrC,IAAI"}