@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -0,0 +1,571 @@
+import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { GPUFrameRecorder } from "../../device/timing/profile/GPUFrameRecorder.js";
+import { GraphicsContext } from "../../renderer/GraphicsContext.js";
+import { execute_filter_environment_map } from "../../renderer/light/environment/execute_filter_environment_map.js";
+import { load_environment_map, ProjectionMappingType } from "../../renderer/light/environment/rgbe/load_environment_map.js";
+import { SH_EXP_ENCODE_PARAMETERS_STRUCT } from "../../renderer/light/environment/sh_exponential/SH_EXP_ENCODE_PARAMETERS_STRUCT.js";
+import { SH_EXP_P4Q2_SETTINGS, SHExpEncoder } from "../../renderer/light/environment/sh_exponential/SHExpEncoder.js";
+import { shader_sh_exp_environment_cells } from "../../renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.js";
+import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../../renderer/STATIC_GRAPHICS_ENGINE_ASSETS.js";
+import { GPUTextureContext } from "../../renderer/texture/GPUTextureContext.js";
+import { texture_write_to_gpu } from "../../renderer/texture/texture_write_to_gpu.js";
+import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
+import {
+    PLAYGROUND_ROWS,
+    PLAYGROUND_VIEW_STRUCT,
+    shader_playground_accumulate_reference,
+    shader_playground_view,
+} from "./sh_exp_playground_shaders.js";
+
+/**
+ * Pixels per sphere.
+ * @type {number}
+ */
+const CELL_SIZE = 128;
+
+/**
+ * Roughness 0.3 to 1.0 in steps of 0.1, alpha its square: the sweep of the paper's Figure 6
+ * (limitations), so the two leftmost columns (alpha 0.09 and 0.16) sit below the fitted range on purpose.
+ */
+const COLUMNS = 8;
+const ALPHA_FIRST_ROOT = 0.3;
+const ALPHA_ROOT_STEP = 0.1;
+
+/**
+ * Side of the octahedral grid the reference integrates over: twice the encoder's, so the reference
+ * is not the fit's own quadrature.
+ * @type {number}
+ */
+const REFERENCE_CELL_RESOLUTION = 128;
+
+/**
+ * Reference cells added per frame: 64 BRDF evaluations per sphere pixel of the reference row, 256
+ * frames to converge.
+ * @type {number}
+ */
+const REFERENCE_SLICE = 64;
+
+/**
+ * Encodes timed back to back in one submission, by GPU timestamps; the status shows their mean.
+ * Chrome truncates timestamps to a coarse quantum unless started with `--enable-unsafe-webgpu`, and
+ * the five passes run without gaps, so the batch's error is at most one quantum across all of them.
+ * Submit-to-done wall time is no measure of the encode: a 256-byte `clearBuffer` alone takes
+ * 0.5–4.6 ms that way here (RTX 4090), against ~0.11 ms of GPU time for the whole encode.
+ * @type {number}
+ */
+const ENCODE_TIMING_REPEATS = 16;
+
+/**
+ * The engine's two maps, then the eight the paper evaluates on (Section 5, Figures 4 and 5, in that
+ * order). Its "Belfast Sunset" is Poly Haven's pure-sky variant and its "Peppermint Powerplant" the
+ * second one, going by the figures.
+ */
+const ENVIRONMENTS = {
+    venice_sunset: '/test_assets/environments/octahedral/venice_sunset_2k.hdr',
+    rustig_koppie_puresky: '/test_assets/environments/octahedral/rustig_koppie_puresky_2k.hdr',
+    little_paris_eiffel_tower: '/test_assets/environments/octahedral/little_paris_eiffel_tower_2k.hdr',
+    belfast_sunset_puresky: '/test_assets/environments/octahedral/belfast_sunset_puresky_2k.hdr',
+    abandoned_bakery: '/test_assets/environments/octahedral/abandoned_bakery_2k.hdr',
+    pretville_street: '/test_assets/environments/octahedral/pretville_street_2k.hdr',
+    blue_photo_studio: '/test_assets/environments/octahedral/blue_photo_studio_2k.hdr',
+    solitude_night: '/test_assets/environments/octahedral/solitude_night_2k.hdr',
+    spruit_sunrise: '/test_assets/environments/octahedral/spruit_sunrise_2k.hdr',
+    peppermint_powerplant_2: '/test_assets/environments/octahedral/peppermint_powerplant_2_2k.hdr',
+};
+
+/**
+ * @param {string} id
+ * @returns {HTMLElement}
+ */
+function element(id) {
+    return document.getElementById(id);
+}
+
+/**
+ * @param {string} text
+ * @param {string} [kind]
+ */
+function set_status(text, kind = '') {
+    const node = element('status');
+
+    node.textContent = text;
+    node.className = kind;
+}
+
+/**
+ * Orthographic camera looking at the spheres from `yaw`/`pitch` (degrees) about the world's +Y up.
+ *
+ * @param {number} yaw
+ * @param {number} pitch
+ * @returns {{right: number[], up: number[], back: number[]}}
+ */
+function camera_basis(yaw, pitch) {
+    const y = yaw * Math.PI / 180;
+    const p = pitch * Math.PI / 180;
+
+    const back = [Math.sin(y) * Math.cos(p), Math.sin(p), Math.cos(y) * Math.cos(p)];
+    const right = [Math.cos(y), 0, -Math.sin(y)];
+    const up = [
+        back[1] * right[2] - back[2] * right[1],
+        back[2] * right[0] - back[0] * right[2],
+        back[0] * right[1] - back[1] * right[0],
+    ];
+
+    return { right: [...right, 0], up: [...up, 0], back: [...back, 0] };
+}
+
+/**
+ * @param {GPUDevice} device
+ * @param {GPUBuffer} source
+ * @param {number} size
+ * @returns {Promise<Float32Array>}
+ */
+async function read_buffer(device, source, size) {
+    const staging = device.createBuffer({ size, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+    const encoder = device.createCommandEncoder();
+
+    encoder.copyBufferToBuffer(source, 0, staging, 0, size);
+    device.queue.submit([encoder.finish()]);
+
+    await staging.mapAsync(GPUMapMode.READ);
+
+    const result = new Float32Array(staging.getMappedRange().slice(0));
+
+    staging.unmap();
+    staging.destroy();
+
+    return result;
+}
+
+async function main() {
+    const canvas = /** @type {HTMLCanvasElement} */ element('view');
+
+    canvas.width = COLUMNS * CELL_SIZE;
+    canvas.height = PLAYGROUND_ROWS.length * CELL_SIZE;
+
+    element('rows').innerHTML = PLAYGROUND_ROWS.map(label => `<div style="height:${CELL_SIZE}px">${label}</div>`).join('');
+    element('columns').innerHTML = Array.from({ length: COLUMNS }, (_, c) => {
+        const root = ALPHA_FIRST_ROOT + ALPHA_ROOT_STEP * c;
+        const outside = root * root < SH_EXP_P4Q2_SETTINGS.alpha_min ? ' class="outside"' : '';
+        return `<div${outside} style="width:${CELL_SIZE}px">α ${(root * root).toFixed(2)}</div>`;
+    }).join('');
+
+    const adapter = await navigator.gpu?.requestAdapter();
+
+    if (!adapter) {
+        set_status('no WebGPU adapter', 'fail');
+        return;
+    }
+
+    if (!adapter.features.has('subgroups')) {
+        set_status('this adapter has no subgroups, which the engine requires', 'fail');
+        return;
+    }
+
+    // timestamps only time the encode; without them the page runs and says so
+    const device = await adapter.requestDevice({
+        requiredFeatures: adapter.features.has('timestamp-query') ? ['subgroups', 'timestamp-query'] : ['subgroups'],
+    });
+
+    device.lost.then(info => set_status(`device lost: ${info.message}`, 'fail'));
+
+    const graphics = new GraphicsContext(device);
+
+    await STATIC_GRAPHICS_ENGINE_ASSETS.init();
+
+    const context = canvas.getContext('webgpu');
+
+    context.configure({
+        device,
+        format: 'rgba8unorm',
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST,
+        alphaMode: 'opaque',
+    });
+
+    const output = new GPUTextureContext(device);
+    output.descriptor.label = 'SH exponential playground / output';
+    output.descriptor.format = 'rgba8unorm';
+    output.descriptor.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC;
+    output.resize(canvas.width, canvas.height);
+    output.allocate();
+
+    const pixel_slots = COLUMNS * CELL_SIZE * CELL_SIZE;
+
+    const accumulation = device.createBuffer({
+        label: 'SH exponential playground / reference accumulation',
+        size: pixel_slots * 16,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+
+    const values = device.createBuffer({
+        label: 'SH exponential playground / values',
+        size: 3 * pixel_slots * 16,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    const reference_cells = device.createBuffer({
+        label: 'SH exponential playground / reference cells',
+        size: 2 * REFERENCE_CELL_RESOLUTION * REFERENCE_CELL_RESOLUTION * 16,
+        usage: GPUBufferUsage.STORAGE,
+    });
+
+    const construct_start = performance.now();
+    const encoder = new SHExpEncoder(device, SH_EXP_P4Q2_SETTINGS);
+    const construct_ms = performance.now() - construct_start;
+
+    const probe = device.createBuffer({
+        label: 'SH exponential playground / probe',
+        size: encoder.probe_vec4_count * 16,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+    });
+
+    const environment = new GPUTextureContext(device);
+    environment.descriptor.label = 'environment map';
+    environment.descriptor.format = 'rgba16float';
+    environment.descriptor.usage |= GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING;
+
+    const state = {
+        processed: 0,
+        cell_count: REFERENCE_CELL_RESOLUTION * REFERENCE_CELL_RESOLUTION,
+        environment_ready: false,
+        /**
+         * GPU time of one encode, the mean of {@link ENCODE_TIMING_REPEATS}; NaN without timestamps.
+         */
+        encode_gpu_ms: NaN,
+        environment_url: '',
+        load_generation: 0,
+    };
+
+    const read_controls = () => ({
+        yaw: Number(element('yaw').value),
+        pitch: Number(element('pitch').value),
+        exposure: Math.pow(2, Number(element('exposure').value)),
+        error_gain: Number(element('error_gain').value),
+    });
+
+    const reset_reference = () => {
+        state.processed = 0;
+    };
+
+    /**
+     * Uploads an octahedral .hdr, prefilters it as GPULightCollection does, encodes the probe and the
+     * reference grid.
+     *
+     * @param {string} url
+     */
+    async function load(url) {
+        // a later selection supersedes this one at every await; a failed fetch leaves the map that
+        // was showing in place
+        const generation = ++state.load_generation;
+        const superseded = () => generation !== state.load_generation;
+
+        set_status(`loading ${url}…`);
+
+        let texture;
+
+        try {
+            texture = await load_environment_map(url, ProjectionMappingType.Octahedral);
+        } catch (error) {
+            if (!superseded()) {
+                set_status(`could not load ${url} — test_assets/README.md has where the maps come from (${error.message})`, 'fail');
+            }
+            return;
+        }
+
+        if (superseded()) {
+            return;
+        }
+
+        state.environment_ready = false;
+
+        const image = texture.image;
+
+        environment.resize(image.width, image.height);
+        environment.descriptor.mipLevelCount = texture_mip_level_count(image.width, image.height, 1, '2d');
+        environment.allocate();
+
+        texture_write_to_gpu(image, environment.gpu_texture, device.queue, image.level_count);
+
+        const cmd = ShadeGPUCommandContext.create(graphics, 'SH exponential playground / environment');
+
+        // the engine IBL row reads the prefiltered levels, exactly as the forward path does
+        execute_filter_environment_map(environment, cmd);
+
+        // the reference's own grid, finer than the encoder's
+        shader_sh_exp_environment_cells.dispatch({
+            encoder: cmd,
+            group_count_x: state.cell_count,
+            bindings: {
+                parameters: cmd.allocateTransientValueBuffer(SH_EXP_ENCODE_PARAMETERS_STRUCT, {
+                    cell_resolution: REFERENCE_CELL_RESOLUTION,
+                    sample_count: 0,
+                    p_band_count: 0,
+                    q_band_count: 0,
+                    coefficient_count: 0,
+                    output_offset: 0,
+                    alpha_min: 0,
+                    alpha_max: 0,
+                    log_floor_ratio: 0,
+                }, GPUBufferUsage.UNIFORM),
+                tEnvironment: environment.obtainView(),
+                cells: reference_cells,
+            },
+        });
+
+        cmd.finish();
+
+        await device.queue.onSubmittedWorkDone();
+
+        if (superseded()) {
+            // the newer load's submissions follow this one's in the queue, so what it writes stands
+            return;
+        }
+
+        // Once untimed: a pipeline's first use compiles it, which on a fresh browser profile costs
+        // ~130 ms here against ~4 ms for the encode itself.
+        const warm = ShadeGPUCommandContext.create(graphics, 'SH exponential playground / encode, warm-up');
+
+        encoder.encode({ encoder: warm, environment: environment.obtainView(), output: probe, output_offset: 0 });
+        warm.finish();
+
+        await device.queue.onSubmittedWorkDone();
+
+        if (superseded()) {
+            return;
+        }
+
+        // timed on its own submission, after everything it depends on has finished; every repeat
+        // writes the same probe
+        const encode = ShadeGPUCommandContext.create(graphics, 'SH exponential playground / encode');
+        const recorder = new GPUFrameRecorder(0, performance.now());
+
+        encode.enable_profiling(recorder, 0);
+
+        for (let i = 0; i < ENCODE_TIMING_REPEATS; i++) {
+            encoder.encode({ encoder: encode, environment: environment.obtainView(), output: probe, output_offset: 0 });
+        }
+
+        encode.finish();
+
+        // `profiling_absorbed`, not `onSubmittedWorkDone`: the timestamps are read back after the work is done
+        await encode.profiling_absorbed;
+
+        if (superseded()) {
+            return;
+        }
+
+        const timing = recorder.close(performance.now());
+
+        // the timers stay quiet on a device without timestamp-query
+        state.encode_gpu_ms = timing.spans.length === 0
+            ? NaN
+            : timing.gpu_duration_ns / ENCODE_TIMING_REPEATS / 1e6;
+        state.environment_url = url;
+        state.environment_ready = true;
+
+        reset_reference();
+
+        const coefficients = await read_buffer(device, probe, encoder.probe_vec4_count * 16);
+
+        element('probe').textContent = format_probe(coefficients);
+    }
+
+    function format_probe(data) {
+        const lines = [`header: alpha [${data[0]}, ${data[1]}], ${data[2]} and ${data[3]} bands`];
+
+        lines.push(`P band 0 (rgb): ${Array.from(data.subarray(4, 7), x => x.toFixed(3)).join(' ')}`);
+
+        const finite = Array.from(data).every(Number.isFinite);
+
+        lines.push(`all ${data.length / 4} slots finite: ${finite}`);
+
+        return lines.join('\n');
+    }
+
+    function frame() {
+        try {
+            draw();
+        } catch (error) {
+            // stop here rather than retrying the same failure every frame
+            console.error(error);
+            set_status(`frame failed: ${error.message}${error.cause ? ` — ${error.cause.message}` : ''}`, 'fail');
+            state.failed = error;
+            return;
+        }
+
+        requestAnimationFrame(frame);
+    }
+
+    function draw() {
+        if (state.environment_ready) {
+            const controls = read_controls();
+            const basis = camera_basis(controls.yaw, controls.pitch);
+
+            const slice_count = Math.min(REFERENCE_SLICE, state.cell_count - state.processed);
+            const view_uniform = {
+                ...basis,
+                cell_size: CELL_SIZE,
+                columns: COLUMNS,
+                slice_start: state.processed,
+                slice_count,
+                cell_count: state.cell_count,
+                processed: state.processed + slice_count,
+                alpha_first_root: ALPHA_FIRST_ROOT,
+                alpha_root_step: ALPHA_ROOT_STEP,
+                exposure: controls.exposure,
+                error_gain: controls.error_gain,
+            };
+
+            const cmd = ShadeGPUCommandContext.create(graphics, 'SH exponential playground / frame');
+            const view = cmd.allocateTransientValueBuffer(PLAYGROUND_VIEW_STRUCT, view_uniform, GPUBufferUsage.UNIFORM);
+
+            if (state.processed === 0) {
+                cmd.clearBuffer(accumulation);
+            }
+
+            if (slice_count > 0) {
+                shader_playground_accumulate_reference.dispatch({
+                    encoder: cmd,
+                    group_count_x: Math.ceil(COLUMNS * CELL_SIZE / 8),
+                    group_count_y: Math.ceil(CELL_SIZE / 8),
+                    bindings: { view, cells: reference_cells, accumulation },
+                });
+            }
+
+            shader_playground_view.dispatch({
+                encoder: cmd,
+                group_count_x: Math.ceil(canvas.width / 8),
+                group_count_y: Math.ceil(canvas.height / 8),
+                bindings: {
+                    view,
+                    tEnvironment: environment.obtainView(),
+                    tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
+                    probe,
+                    accumulation,
+                    values,
+                    output,
+                },
+            });
+
+            cmd.copyTextureToTexture(
+                { texture: output.gpu_texture },
+                { texture: context.getCurrentTexture() },
+                [canvas.width, canvas.height, 1]
+            );
+
+            cmd.finish();
+
+            state.processed += slice_count;
+
+            const percent = Math.round(100 * state.processed / state.cell_count);
+
+            const encode_time = Number.isNaN(state.encode_gpu_ms)
+                ? 'encode (GPU) untimed: no timestamp-query'
+                : `encode (GPU timestamps) ${state.encode_gpu_ms.toFixed(3)} ms`;
+
+            set_status(
+                `${state.environment_url.split('/').pop()} · encoder setup (CPU) ${construct_ms.toFixed(1)} ms · `
+                + `${encode_time} · reference ${percent}%`,
+                state.processed === state.cell_count ? 'ok' : ''
+            );
+        }
+    }
+
+    for (const id of ['yaw', 'pitch']) {
+        element(id).addEventListener('input', reset_reference);
+    }
+
+    const select = /** @type {HTMLSelectElement} */ element('environment');
+
+    select.innerHTML = Object.keys(ENVIRONMENTS).map(name => `<option value="${name}">${name}</option>`).join('');
+
+    const query = new URLSearchParams(location.search);
+    const custom = query.get('env');
+
+    if (custom !== null) {
+        select.insertAdjacentHTML('beforeend', `<option value="custom">${custom}</option>`);
+        select.value = 'custom';
+    }
+
+    const url_of = (value) => value === 'custom' ? custom : ENVIRONMENTS[value];
+
+    select.addEventListener('change', () => load(url_of(select.value)));
+
+    /**
+     * Waits for the reference to converge, then reads the three rows back and scores each method
+     * against the reference by roughness column: RMSE of the tonemapped luminance over the sphere,
+     * at the page's exposure. For driving the page from a console or a headless browser.
+     *
+     * @returns {Promise<{alpha: number, sh_exp: number, split_sum: number}[]>}
+     */
+    async function verify() {
+        while (!(state.environment_ready && state.processed === state.cell_count)) {
+            if (state.failed !== undefined) {
+                throw state.failed;
+            }
+
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
+
+        // one more frame so the values buffer was written with the converged reference
+        await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+        await device.queue.onSubmittedWorkDone();
+
+        const data = await read_buffer(device, values, 3 * pixel_slots * 16);
+        const exposure = read_controls().exposure;
+        const tonemap = x => 1 - Math.exp(-Math.max(x, 0) * exposure);
+        const luminance = (o) => 0.2126 * data[o] + 0.7152 * data[o + 1] + 0.0722 * data[o + 2];
+
+        const result = [];
+        const per_column = CELL_SIZE * CELL_SIZE;
+
+        for (let c = 0; c < COLUMNS; c++) {
+            const root = ALPHA_FIRST_ROOT + ALPHA_ROOT_STEP * c;
+            let sh_exp = 0;
+            let split_sum = 0;
+            let count = 0;
+
+            for (let i = 0; i < per_column; i++) {
+                const slot = c * per_column + i;
+                const reference_offset = slot * 4;
+
+                if (data[reference_offset + 3] === 0) {
+                    continue;
+                }
+
+                const reference = tonemap(luminance(reference_offset));
+
+                sh_exp += (tonemap(luminance((pixel_slots + slot) * 4)) - reference) ** 2;
+                split_sum += (tonemap(luminance((2 * pixel_slots + slot) * 4)) - reference) ** 2;
+                count++;
+            }
+
+            result.push({
+                alpha: root * root,
+                sh_exp: Math.sqrt(sh_exp / count),
+                split_sum: Math.sqrt(split_sum / count),
+            });
+        }
+
+        return result;
+    }
+
+    globalThis.sh_exp_playground = {
+        device,
+        encoder,
+        probe,
+        state,
+        verify,
+        load,
+        read_probe: () => read_buffer(device, probe, encoder.probe_vec4_count * 16),
+    };
+
+    requestAnimationFrame(frame);
+
+    await load(url_of(select.value));
+}
+
+main().catch(error => {
+    console.error(error);
+    set_status(`failed: ${error.message}`, 'fail');
+});

package/src/shade/playground/sh_exponential/sh_exp_playground_shaders.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Rows of the sphere grid, top to bottom.
+ * @type {string[]}
+ */
+export const PLAYGROUND_ROWS: string[];
+/**
+ * Step through the reference grid's cells: odd, so it visits every cell of a power-of-two grid once
+ * per pass, and large, so any run of consecutive steps is spread over the sphere and a partial sum
+ * is already a fair estimate of the whole.
+ *
+ * @type {number}
+ */
+export const REFERENCE_CELL_STRIDE: number;
+/**
+ * What both playground kernels read.
+ *
+ * - `right`, `up`, `back`: the orthographic camera's basis; `back` points at the viewer and is every
+ *   pixel's view direction;
+ * - `cell_size`: pixels per sphere cell, `columns` spheres per row, one per roughness;
+ * - `alpha_first_root`, `alpha_root_step`: column `c` is at roughness `first + step * c`, GGX alpha
+ *   its square — the paper's own sweep is 0.3 to 1 in steps of 0.1;
+ * - `slice_start`, `slice_count`: which reference cells this frame adds; `processed` how many will
+ *   have been added after it, of `cell_count`;
+ * - `exposure`, `error_gain`: display only.
+ *
+ * @type {WebGPUStruct}
+ */
+export const PLAYGROUND_VIEW_STRUCT: WebGPUStruct;
+/**
+ * Adds one slice of the reference quadrature to every sphere pixel: `E0` summed over
+ * `slice_count` cells of an octahedral grid made by `shader_sh_exp_environment_cells`, at a finer
+ * resolution than the encoder fits on. Spread over frames, so no invocation loops over the sphere.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_playground_accumulate_reference: ComputeShader;
+/**
+ * Draws the four rows of {@link PLAYGROUND_ROWS}, and writes the linear values of the first three
+ * into `values` (`[row][column][pixel]`, `w` = 1 on the sphere) for `verify()` to read.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_playground_view: ComputeShader;
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+//# sourceMappingURL=sh_exp_playground_shaders.d.ts.map

package/src/shade/playground/sh_exponential/sh_exp_playground_shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh_exp_playground_shaders.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/sh_exponential/sh_exp_playground_shaders.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,8BAFU,MAAM,EAAE,CAOhB;AAEF;;;;;;GAMG;AACH,oCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;GAaG;AACH,qCAFU,YAAY,CAgBI;AAsC1B;;;;;;GAMG;AACH,qDAFU,aAAa,CAuDpB;AAcH;;;;;GAKG;AACH,qCAFU,aAAa,CA4FpB;6BAnQ0B,4CAA4C;8BAJ3C,wCAAwC"}