@woosh/meep-engine 3.68.0 → 3.70.0

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

@@ -1,254 +1,259 @@
-import { verify_gpu_bvh_build } from "../../renderer/gpu_primitive/bvh/verify_gpu_bvh_build.js";
-import { verify_radix_sort } from "../../renderer/gpu_primitive/sort/verify_radix_sort.js";
-import { verify_gpu_tlas_build } from "../../renderer/scene/verify_gpu_tlas_build.js";
-import { bvh_repro_device, describe_device } from "./bvh_repro_device.js";
-
-/**
- * Driver for the standalone GPU BVH repro page.
- *
- * The harnesses it runs report through `console`, which is where they report from the main
- * playground too — so rather than giving them a second output channel, this mirrors the console
- * into the page while a run is in flight. That keeps one implementation of each check and makes the
- * page useful to someone who has devtools closed.
- */
-
-const log_element = document.getElementById('log');
-const status_element = document.getElementById('status');
-const device_element = document.getElementById('device');
-const buttons = [...document.querySelectorAll('button[data-run]')];
-
-/** @type {{graphics: GraphicsContext, device: GPUDevice, adapter: GPUAdapter}|undefined} */
-let context;
-
-/**
- * @param {string} text
- * @param {string} [kind] one of 'pass', 'fail', 'warn', 'note'
- */
-function append(text, kind = '') {
-    const line = document.createElement('div');
-
-    line.className = `line ${kind}`;
-    line.textContent = text;
-
-    log_element.appendChild(line);
-    log_element.scrollTop = log_element.scrollHeight;
-}
-
-/**
- * The harnesses format their PASS lines with `%c` and a CSS string, which is console syntax and
- * nothing else. Strip the directives and drop the style arguments that went with them.
- *
- * @param {any[]} args
- * @returns {string}
- */
-function flatten_console_args(args) {
-    if (args.length === 0) {
-        return '';
-    }
-
-    const [first, ...rest] = args;
-
-    if (typeof first !== 'string' || !first.includes('%c')) {
-        return args.map(value => (typeof value === 'string' ? value : String(value))).join(' ');
-    }
-
-    const directives = (first.match(/%c/g) ?? []).length;
-
-    return [first.replaceAll('%c', ''), ...rest.slice(directives)]
-        .map(value => (typeof value === 'string' ? value : String(value)))
-        .join(' ');
-}
-
-/**
- * Run `body` with the console mirrored into the page.
- *
- * @param {function(): (void|Promise<void>)} body
- * @returns {Promise<void>}
- */
-async function with_mirrored_console(body) {
-    const original = {
-        log: console.log,
-        warn: console.warn,
-        error: console.error,
-        table: console.table,
-    };
-
-    console.log = (...args) => {
-        original.log(...args);
-
-        const text = flatten_console_args(args);
-
-        append(text, /\bPASS\b/.test(text) ? 'pass' : '');
-    };
-
-    console.warn = (...args) => {
-        original.warn(...args);
-        append(flatten_console_args(args), 'warn');
-    };
-
-    console.error = (...args) => {
-        original.error(...args);
-        append(flatten_console_args(args), 'fail');
-    };
-
-    console.table = rows => {
-        original.table(rows);
-
-        if (!Array.isArray(rows)) {
-            return;
-        }
-
-        for (const row of rows) {
-            append(`  ${String(row.label).padEnd(34)} ${Number(row.duration_ms).toFixed(4)} ms`, 'note');
-        }
-    };
-
-    try {
-        await body();
-    } finally {
-        Object.assign(console, original);
-    }
-}
-
-/**
- * Wait until the device has finished the work that was submitted, and until the readback promises
- * chained off it have had a chance to resolve and report.
- *
- * The harnesses are fire-and-forget by design (`graph_inspect_gpu_buffer` calls back from a
- * `mapAsync` promise), so there is nothing to await directly. `onSubmittedWorkDone` covers the
- * device side; the turns after it are what let the mapping promises and their `.then` chains run.
- *
- * @param {GPUDevice} device
- * @returns {Promise<void>}
- */
-async function drain(device) {
-    await device.queue.onSubmittedWorkDone();
-
-    for (let i = 0; i < 8; i++) {
-        await new Promise(resolve => setTimeout(resolve, 0));
-    }
-}
-
-/**
- * @param {boolean} enabled
- */
-function set_enabled(enabled) {
-    for (const button of buttons) {
-        button.disabled = !enabled;
-    }
-}
-
-/**
- * @param {string} text
- * @param {string} [kind]
- */
-function set_status(text, kind = '') {
-    status_element.textContent = text;
-    status_element.className = kind;
-}
-
-/**
- * @returns {Promise<{graphics: GraphicsContext, device: GPUDevice, adapter: GPUAdapter}>}
- */
-async function obtain_context() {
-    if (context !== undefined) {
-        return context;
-    }
-
-    set_status('acquiring a device…');
-
-    context = await bvh_repro_device();
-
-    device_element.innerHTML = '';
-
-    for (const { label, value } of describe_device(context.adapter, context.device)) {
-        const row = document.createElement('div');
-
-        const name = document.createElement('span');
-        name.className = 'key';
-        name.textContent = label;
-
-        const text = document.createElement('span');
-        text.textContent = value;
-
-        row.append(name, text);
-        device_element.appendChild(row);
-    }
-
-    // An uncaptured validation error is the single most useful thing this page can surface: the
-    // harnesses check bytes, and a shader that failed to create says nothing about bytes at all.
-    context.device.addEventListener('uncapturederror', event => {
-        append(`[device] ${event.error.constructor.name}: ${event.error.message}`, 'fail');
-    });
-
-    context.device.lost.then(info => {
-        append(`[device] LOST (${info.reason}): ${info.message}`, 'fail');
-        set_status('device lost', 'fail');
-    });
-
-    return context;
-}
-
-const RUNS = {
-    sort: {
-        title: 'radix sort',
-        run: graphics => verify_radix_sort(graphics),
-    },
-    bvh: {
-        title: 'GPU BVH build',
-        run: graphics => verify_gpu_bvh_build(graphics),
-    },
-    tlas: {
-        title: 'TLAS end to end',
-        run: graphics => verify_gpu_tlas_build(graphics),
-    },
-};
-
-/**
- * @param {string} name
- */
-async function run(name) {
-    set_enabled(false);
-
-    try {
-        const { graphics, device } = await obtain_context();
-
-        const names = name === 'all' ? Object.keys(RUNS) : [name];
-
-        for (const key of names) {
-            const { title, run: body } = RUNS[key];
-
-            append('', '');
-            append(`── ${title} ──`, 'note');
-
-            set_status(`running ${title}…`);
-
-            const started = performance.now();
-
-            await with_mirrored_console(async () => {
-                await body(graphics);
-                await drain(device);
-            });
-
-            append(`   ${title} finished in ${(performance.now() - started).toFixed(0)} ms (wall clock)`, 'note');
-        }
-
-        set_status('done — read the log for PASS/FAIL', 'pass');
-    } catch (error) {
-        append(String(error?.stack ?? error), 'fail');
-        set_status('failed to run — see the log', 'fail');
-    } finally {
-        set_enabled(true);
-    }
-}
-
-for (const button of buttons) {
-    button.addEventListener('click', () => run(button.dataset.run));
-}
-
-document.getElementById('clear').addEventListener('click', () => {
-    log_element.innerHTML = '';
-    set_status('');
-});
-
-set_status('ready — pick a check');
+import { verify_gpu_bvh_build } from "../../renderer/gpu_primitive/bvh/verify_gpu_bvh_build.js";
+import { verify_gpu_bvh8_encode } from "../../renderer/gpu_primitive/bvh8/verify_gpu_bvh8_encode.js";
+import { verify_radix_sort } from "../../renderer/gpu_primitive/sort/verify_radix_sort.js";
+import { verify_gpu_tlas_build } from "../../renderer/scene/verify_gpu_tlas_build.js";
+import { bvh_repro_device, describe_device } from "./bvh_repro_device.js";
+
+/**
+ * Driver for the standalone GPU BVH repro page.
+ *
+ * The harnesses it runs report through `console`, which is where they report from the main
+ * playground too — so rather than giving them a second output channel, this mirrors the console
+ * into the page while a run is in flight. That keeps one implementation of each check and makes the
+ * page useful to someone who has devtools closed.
+ */
+
+const log_element = document.getElementById('log');
+const status_element = document.getElementById('status');
+const device_element = document.getElementById('device');
+const buttons = [...document.querySelectorAll('button[data-run]')];
+
+/** @type {{graphics: GraphicsContext, device: GPUDevice, adapter: GPUAdapter}|undefined} */
+let context;
+
+/**
+ * @param {string} text
+ * @param {string} [kind] one of 'pass', 'fail', 'warn', 'note'
+ */
+function append(text, kind = '') {
+    const line = document.createElement('div');
+
+    line.className = `line ${kind}`;
+    line.textContent = text;
+
+    log_element.appendChild(line);
+    log_element.scrollTop = log_element.scrollHeight;
+}
+
+/**
+ * The harnesses format their PASS lines with `%c` and a CSS string, which is console syntax and
+ * nothing else. Strip the directives and drop the style arguments that went with them.
+ *
+ * @param {any[]} args
+ * @returns {string}
+ */
+function flatten_console_args(args) {
+    if (args.length === 0) {
+        return '';
+    }
+
+    const [first, ...rest] = args;
+
+    if (typeof first !== 'string' || !first.includes('%c')) {
+        return args.map(value => (typeof value === 'string' ? value : String(value))).join(' ');
+    }
+
+    const directives = (first.match(/%c/g) ?? []).length;
+
+    return [first.replaceAll('%c', ''), ...rest.slice(directives)]
+        .map(value => (typeof value === 'string' ? value : String(value)))
+        .join(' ');
+}
+
+/**
+ * Run `body` with the console mirrored into the page.
+ *
+ * @param {function(): (void|Promise<void>)} body
+ * @returns {Promise<void>}
+ */
+async function with_mirrored_console(body) {
+    const original = {
+        log: console.log,
+        warn: console.warn,
+        error: console.error,
+        table: console.table,
+    };
+
+    console.log = (...args) => {
+        original.log(...args);
+
+        const text = flatten_console_args(args);
+
+        append(text, /\bPASS\b/.test(text) ? 'pass' : '');
+    };
+
+    console.warn = (...args) => {
+        original.warn(...args);
+        append(flatten_console_args(args), 'warn');
+    };
+
+    console.error = (...args) => {
+        original.error(...args);
+        append(flatten_console_args(args), 'fail');
+    };
+
+    console.table = rows => {
+        original.table(rows);
+
+        if (!Array.isArray(rows)) {
+            return;
+        }
+
+        for (const row of rows) {
+            append(`  ${String(row.label).padEnd(34)} ${Number(row.duration_ms).toFixed(4)} ms`, 'note');
+        }
+    };
+
+    try {
+        await body();
+    } finally {
+        Object.assign(console, original);
+    }
+}
+
+/**
+ * Wait until the device has finished the work that was submitted, and until the readback promises
+ * chained off it have had a chance to resolve and report.
+ *
+ * The harnesses are fire-and-forget by design (`graph_inspect_gpu_buffer` calls back from a
+ * `mapAsync` promise), so there is nothing to await directly. `onSubmittedWorkDone` covers the
+ * device side; the turns after it are what let the mapping promises and their `.then` chains run.
+ *
+ * @param {GPUDevice} device
+ * @returns {Promise<void>}
+ */
+async function drain(device) {
+    await device.queue.onSubmittedWorkDone();
+
+    for (let i = 0; i < 8; i++) {
+        await new Promise(resolve => setTimeout(resolve, 0));
+    }
+}
+
+/**
+ * @param {boolean} enabled
+ */
+function set_enabled(enabled) {
+    for (const button of buttons) {
+        button.disabled = !enabled;
+    }
+}
+
+/**
+ * @param {string} text
+ * @param {string} [kind]
+ */
+function set_status(text, kind = '') {
+    status_element.textContent = text;
+    status_element.className = kind;
+}
+
+/**
+ * @returns {Promise<{graphics: GraphicsContext, device: GPUDevice, adapter: GPUAdapter}>}
+ */
+async function obtain_context() {
+    if (context !== undefined) {
+        return context;
+    }
+
+    set_status('acquiring a device…');
+
+    context = await bvh_repro_device();
+
+    device_element.innerHTML = '';
+
+    for (const { label, value } of describe_device(context.adapter, context.device)) {
+        const row = document.createElement('div');
+
+        const name = document.createElement('span');
+        name.className = 'key';
+        name.textContent = label;
+
+        const text = document.createElement('span');
+        text.textContent = value;
+
+        row.append(name, text);
+        device_element.appendChild(row);
+    }
+
+    // An uncaptured validation error is the single most useful thing this page can surface: the
+    // harnesses check bytes, and a shader that failed to create says nothing about bytes at all.
+    context.device.addEventListener('uncapturederror', event => {
+        append(`[device] ${event.error.constructor.name}: ${event.error.message}`, 'fail');
+    });
+
+    context.device.lost.then(info => {
+        append(`[device] LOST (${info.reason}): ${info.message}`, 'fail');
+        set_status('device lost', 'fail');
+    });
+
+    return context;
+}
+
+const RUNS = {
+    sort: {
+        title: 'radix sort',
+        run: graphics => verify_radix_sort(graphics),
+    },
+    bvh: {
+        title: 'GPU BVH build',
+        run: graphics => verify_gpu_bvh_build(graphics),
+    },
+    bvh8: {
+        title: 'BVH8 encode',
+        run: graphics => verify_gpu_bvh8_encode(graphics),
+    },
+    tlas: {
+        title: 'TLAS end to end',
+        run: graphics => verify_gpu_tlas_build(graphics),
+    },
+};
+
+/**
+ * @param {string} name
+ */
+async function run(name) {
+    set_enabled(false);
+
+    try {
+        const { graphics, device } = await obtain_context();
+
+        const names = name === 'all' ? Object.keys(RUNS) : [name];
+
+        for (const key of names) {
+            const { title, run: body } = RUNS[key];
+
+            append('', '');
+            append(`── ${title} ──`, 'note');
+
+            set_status(`running ${title}…`);
+
+            const started = performance.now();
+
+            await with_mirrored_console(async () => {
+                await body(graphics);
+                await drain(device);
+            });
+
+            append(`   ${title} finished in ${(performance.now() - started).toFixed(0)} ms (wall clock)`, 'note');
+        }
+
+        set_status('done — read the log for PASS/FAIL', 'pass');
+    } catch (error) {
+        append(String(error?.stack ?? error), 'fail');
+        set_status('failed to run — see the log', 'fail');
+    } finally {
+        set_enabled(true);
+    }
+}
+
+for (const button of buttons) {
+    button.addEventListener('click', () => run(button.dataset.run));
+}
+
+document.getElementById('clear').addEventListener('click', () => {
+    log_element.innerHTML = '';
+    set_status('');
+});
+
+set_status('ready — pick a check');

package/src/shade/playground/foliage_wind/foliage_world.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foliage_world.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/foliage_wind/foliage_world.js"],"names":[],"mappings":"AAoDA;;;;;;GAMG;AACH,2DAJW,MAAM,iBACN,MAAM,GACJ,OAAO,4CAA4C,EAAE,eAAe,CA4DhF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iDAfW,OAAO,6CAA6C,EAAE,cAAc,SACpE,OAAO,+BAA+B,EAAE,KAAK;IAER,IAAI,GAAzC,UAAU,GAAC,OAAO;IACO,MAAM,GAA/B,MAAM;IACmB,IAAI,GAA7B,MAAM;IACmB,GAAG,GAA5B,MAAM;IACoB,UAAU,GAApC,OAAO;IACkB,SAAS,GAAlC,MAAM;IACmB,UAAU,GAAnC,MAAM;IACmB,YAAY,GAArC,MAAM;IACmB,UAAU,GAAnC,MAAM;IACmB,UAAU,GAAnC,MAAM;IACoB,cAAc,GAAxC,OAAO;;;;;;;;;;;;;;;;;cAoJS,MAAM;kBAAY,OAAO,oDAAoD,EAAE,cAAc;mBAAa,OAAO,mDAAmD,EAAE,YAAY;gBAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkK7L,QAAQ,GAAzB,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,MAAM,GAAvB,MAAM;QACW,QAAQ,GAAzB,MAAM;;eAsCN,MAAM;;;;;;;;;;;;;;;;;;GAwGpB;AAnjBD;;;GAGG;AACH,yCAFU,MAAM,EAAE,CAYhB;8BA3C4B,sCAAsC;uCAD7B,+CAA+C;oCAmBlD,+DAA+D;qCAC9D,gEAAgE;oCACjE,+DAA+D"}
+{"version":3,"file":"foliage_world.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/foliage_wind/foliage_world.js"],"names":[],"mappings":"AAoDA;;;;;;GAMG;AACH,2DAJW,MAAM,iBACN,MAAM,GACJ,OAAO,4CAA4C,EAAE,eAAe,CA4DhF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iDAfW,OAAO,6CAA6C,EAAE,cAAc,SACpE,OAAO,+BAA+B,EAAE,KAAK;IAER,IAAI,GAAzC,UAAU,GAAC,OAAO;IACO,MAAM,GAA/B,MAAM;IACmB,IAAI,GAA7B,MAAM;IACmB,GAAG,GAA5B,MAAM;IACoB,UAAU,GAApC,OAAO;IACkB,SAAS,GAAlC,MAAM;IACmB,UAAU,GAAnC,MAAM;IACmB,YAAY,GAArC,MAAM;IACmB,UAAU,GAAnC,MAAM;IACmB,UAAU,GAAnC,MAAM;IACoB,cAAc,GAAxC,OAAO;;;;;;;;;;;;;;;;;cAqJS,MAAM;kBAAY,OAAO,oDAAoD,EAAE,cAAc;mBAAa,OAAO,mDAAmD,EAAE,YAAY;gBAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoK7L,QAAQ,GAAzB,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,MAAM,GAAvB,MAAM;QACW,QAAQ,GAAzB,MAAM;;eAsCN,MAAM;;;;;;;;;;;;;;;;;;GAwGpB;AAtjBD;;;GAGG;AACH,yCAFU,MAAM,EAAE,CAYhB;8BA3C4B,sCAAsC;uCAD7B,+CAA+C;oCAmBlD,+DAA+D;qCAC9D,gEAAgE;oCACjE,+DAA+D"}

package/src/shade/playground/foliage_wind/foliage_world.js

@@ -237,8 +237,9 @@ export async function createFoliageWindWorld(graphics, scene, initial_options =
     const global_wind = new GlobalFluidEffector();
     global_wind.wind = [6.5, 0, 2.5];
     global_wind.drag = 1.5;
-    global_wind.gust = 0.5;
-    global_wind.gust_period = 5.5;
+    // a gust of about 3.5 m/s rms on 7 m/s, its strongest eddies going by every 5.5 s
+    global_wind.turbulence_intensity = 0.5;
+    global_wind.turbulence_length = 7 * 5.5 / 4.05;
 
     const fluid_effectors = new FluidEffectorsComponent();
     fluid_effectors.addEffector(global_wind);
@@ -436,8 +437,10 @@ export async function createFoliageWindWorld(graphics, scene, initial_options =
         global_wind.wind[1] = 0.0;
         global_wind.wind[2] = dir_z * eff_speed;
         global_wind.drag = 1.5;
-        global_wind.gust = eff_speed > 0 ? state.gustStrength / eff_speed : 0;
-        global_wind.gust_period = Math.max(0.5, state.gustPeriod);
+        // the gust strength is the turbulence's rms; its period how long the strongest eddy, 4.05·L,
+        // takes to go by
+        global_wind.turbulence_intensity = eff_speed > 0 ? state.gustStrength / eff_speed : 0;
+        global_wind.turbulence_length = eff_speed > 0 ? eff_speed * Math.max(0.5, state.gustPeriod) / 4.05 : global_wind.turbulence_length;
 
         for (let i = 0; i < active_trees.length; i++) {
             const rigs_comp = dataset.getComponent(active_trees[i].root, FoliageWindRigs);

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

@@ -387,8 +387,9 @@ function build_world(dataset) {
 
     weather.wind = [4, 0, 1.5];
     weather.drag = 0.5;
-    weather.gust = 1.5;
-    weather.gust_period = 4;
+    // turbulence of 1.5 m/s rms, its strongest eddies going by every 4 s
+    weather.turbulence_intensity = 1.5 / Math.hypot(4, 1.5);
+    weather.turbulence_length = Math.hypot(4, 1.5) * 4 / 4.05;
 
     const effectors = new FluidEffectorsComponent();
 

package/src/shade/playground/particle_ecs/bonfire_wind.d.ts

@@ -1,13 +1,12 @@
 /**
- * The weather over the fire: a steady wind and a gust on top, written straight onto the scene's
- * published wind field as its far field, `v_far(t)`.
+ * The weather over the fire: a steady wind and its turbulence, written straight onto the scene's
+ * published wind field as its far field.
  *
  * There is no fluid here. The field is the one every `GPUSceneContext` has, with no cascades, so every
- * particle that reads `SAMPLE_WIND` reads `v_far` exactly — the page plays the part a producer plays,
- * through the same `set_far_velocity` it would call. The gust is `GlobalFluidEffector`'s, used on its
- * own as the model it is (three sinusoids per axis, bounded by `gust`, turning as it goes): the page
- * advances it and adds it to the wind, which is what the far field's fold does with one global and
- * no drag.
+ * particle that reads `SAMPLE_WIND` reads the far field exactly — the page plays the part a producer
+ * plays, through the same `set_far_velocity` and `set_turbulence` it would call, and does what the far
+ * field's fold does with one global and no drag: the mean is the wind, the turbulence's rms is the
+ * intensity times its speed, and the mean carries the eddies, `offset += wind · dt`.
  *
  * What reads it is the four effects' own graphs: the flame, the embers and the soot are carried by
  * the air — their positions integrate the wind at the particle on top of their own velocity, the
@@ -26,23 +25,34 @@ export class BonfireWind {
      */
     heading_degrees: number;
     /**
-     * Peak gust on top of the wind, m/s per axis — `GlobalFluidEffector#gust`'s meaning.
+     * Turbulence intensity, `GlobalFluidEffector#turbulence_intensity`'s meaning: the eddies' rms as a
+     * share of the wind's speed. A gusty night.
      * @type {number}
      */
-    gust: number;
+    turbulence_intensity: number;
     /**
-     * `v_far(t)` as last written.
+     * The turbulence's length scale, m, `GlobalFluidEffector#turbulence_length`'s meaning: at the
+     * default speed its most energetic wavelength, `4.05·L`, goes by in about three seconds.
+     * @type {number}
+     */
+    turbulence_length: number;
+    /**
+     * The mean as last written, m/s.
      * @type {Float64Array}
      */
     far_velocity: Float64Array;
     /**
-     * Advance the gust by `dt` and write the wind onto the scene's field. Once a frame, before the
-     * frame renders: the scene context uploads the field's table in its own update.
+     * How far the mean has carried the eddies, m.
+     * @type {Float64Array}
+     */
+    turbulence_offset: Float64Array;
+    /**
+     * Advance the weather by `dt` and write it onto the scene's field. Once a frame, before the frame
+     * renders: the scene context uploads the field's table in its own update.
      *
      * @param {number} dt seconds
      * @param {import("../../renderer/wind/GPUSceneWind.js").GPUSceneWind} wind_field
      */
     blow(dt: number, wind_field: import("../../renderer/wind/GPUSceneWind.js").GPUSceneWind): void;
-    #private;
 }
 //# sourceMappingURL=bonfire_wind.d.ts.map

package/src/shade/playground/particle_ecs/bonfire_wind.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bonfire_wind.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_ecs/bonfire_wind.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,MAFU,MAAM,CAEL;IAWX;;;OAGG;IACH,cAFU,YAAY,CAEa;IAOnC;;;;;;OAMG;IACH,SAHW,MAAM,cACN,OAAO,qCAAqC,EAAE,YAAY,QAkBpE;;CACJ"}
+{"version":3,"file":"bonfire_wind.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_ecs/bonfire_wind.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,sBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,cAFU,YAAY,CAEa;IAEnC;;;OAGG;IACH,mBAFU,YAAY,CAEkB;IAExC;;;;;;OAMG;IACH,SAHW,MAAM,cACN,OAAO,qCAAqC,EAAE,YAAY,QAiBpE;CACJ"}