npm - @woosh/meep-engine - Versions diffs - 3.15.0 → 3.16.0 - Mend

@woosh/meep-engine 3.15.0 → 3.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (952) hide show

package/src/shade/playground/particle_system/index.html CHANGED Viewed

@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
     <meta charset="utf-8">
-    <title>meep — GPU particle system</title>
+    <title>meep — GPU particles through AVBOIT</title>
     <style>
         :root {
             color-scheme: dark;
@@ -32,22 +32,25 @@
             height: 100%;
         }
-        #hud {
+        .panel {
             position: fixed;
-            top: 12px;
-            left: 12px;
-            min-width: 210px;
             padding: 10px 12px;
             border: 1px solid var(--line);
             border-radius: 8px;
             background: var(--panel);
             backdrop-filter: blur(6px);
+        }
+        #hud {
+            top: 12px;
+            left: 12px;
+            min-width: 210px;
             font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
             font-size: 12px;
             pointer-events: none;
         }
-        #hud h1 {
+        #hud h1, #controls h1 {
             font: inherit;
             font-weight: 600;
             margin: 0 0 6px;
@@ -59,16 +62,43 @@
         #hud div { display: flex; gap: 10px; justify-content: space-between; }
         #hud .key { color: var(--muted); }
+        #controls {
+            top: 12px;
+            right: 12px;
+            min-width: 230px;
+            font-size: 12.5px;
+        }
+        #controls h1 { font-family: ui-monospace, SFMono-Regular, Consolas, monospace; font-size: 12px; }
+        #controls label {
+            display: flex;
+            gap: 8px;
+            align-items: center;
+            justify-content: space-between;
+            padding: 3px 0;
+        }
+        #controls select { background: #14161a; color: var(--text); border: 1px solid var(--line); border-radius: 4px; padding: 2px 4px; }
+        #controls button {
+            width: 100%;
+            margin-top: 8px;
+            padding: 6px 10px;
+            background: #14161a;
+            color: var(--text);
+            border: 1px solid var(--line);
+            border-radius: 6px;
+            cursor: pointer;
+            font: inherit;
+        }
+        #controls button:hover { border-color: #3d4450; }
         #legend {
-            position: fixed;
             bottom: 12px;
             left: 12px;
-            max-width: 62ch;
-            padding: 10px 12px;
-            border: 1px solid var(--line);
-            border-radius: 8px;
-            background: var(--panel);
-            backdrop-filter: blur(6px);
+            max-width: 68ch;
             font-size: 12.5px;
             color: var(--muted);
             pointer-events: none;
@@ -95,11 +125,11 @@
         #message:not(:empty) { display: flex; }
     </style>
 </head>
-<body>
+<body tabindex="0">
 <canvas id="view"></canvas>
-<div id="hud">
+<div id="hud" class="panel">
     <h1>GPU particles</h1>
     <div><span class="key">fps</span><span id="stat-fps">—</span></div>
     <div><span class="key">alive</span><span id="stat-alive">—</span></div>
@@ -109,12 +139,28 @@
     <div><span class="key">sim workgroups</span><span id="stat-dispatch">—</span></div>
 </div>
-<div id="legend">
-    <p><b>Four emitters, one pool.</b> Additive fire at the pillar, an alpha soft-depth smoke column
-        above it, velocity-stretched sparks by the block, and a wide soft-depth dust drift.</p>
-    <p>Emit, simulate and the billboard draw are all GPU-sized — the simulate dispatch and the draw
-        read indirect args the build-indirect pass writes. The counters above are read back purely to
-        display; nothing on the CPU sizes a pass.</p>
+<div id="controls" class="panel">
+    <h1>renderer</h1>
+    <label><span>particles</span><input type="checkbox" id="particles" checked></label>
+    <label><span>transparency</span>
+        <select id="transparency">
+            <option value="AVBOIT" selected>AVBOIT (voxels)</option>
+            <option value="MBOIT">MBOIT (legacy)</option>
+        </select>
+    </label>
+    <label><span>TAA</span><input type="checkbox" id="taa" checked></label>
+    <button id="burst">Burst 4000 sparks</button>
+</div>
+<div id="legend" class="panel">
+    <p><b>Drawn by the engine's own Renderer.</b> Five emitters share one pool, and their quads go
+        through the AVBOIT transparency pipeline as a side channel — the same volume, the same
+        accumulators and the same resolve as the transparent pane in the middle of the set.</p>
+    <p>Orbit around the pane: it and the particles occlude each other correctly from either side,
+        with no sort between them. Switch to MBOIT and the particles disappear while the pane stays
+        — the legacy path has no particle channel, and they are still being simulated.</p>
+    <p>Emit, simulate and the draws are all GPU-sized. The counters above are read back purely to
+        display; nothing on the CPU sizes a pass. Drag to orbit, wheel to zoom, right-drag to pan.</p>
 </div>
 <div id="message"></div>

package/src/shade/playground/particle_system/main.js CHANGED Viewed

@@ -1,166 +1,314 @@
-import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
+import { load_default_environment } from "../load_default_environment.js";
 import {
-    device_supports_immediate_size,
-    immediate_data_supported,
-} from "../../device/immediate_data_supported.js";
-import { GraphicsContext } from "../../renderer/GraphicsContext.js";
-import {
-    PARTICLE_IMMEDIATE_BYTES,
     PARTICLE_STATS_BYTES,
-    create_particle_scene,
+    animate_particle_scene,
+    build_particle_scene,
+    configure_particles,
+    encode_stats_copy,
+    read_stats,
 } from "./particle_scene.js";
 /**
- * The page for the GPU particle playground: acquire a device, build the scene
- * ({@link ./particle_scene.js}, which is where the interesting part lives), and drive it from
- * `requestAnimationFrame`.
+ * The page for the GPU particle playground: build a scene, hand it to the engine's own
+ * {@link Renderer}, and let it draw. There is no frame graph here, no pass, no pipeline and no
+ * camera buffer — the particles are drawn where the renderer draws them, inside the AVBOIT
+ * transparency pipeline as a side channel of the transparent meshes.
+ *
+ * That is the point of the page: the transparent pane and the particles composite against each
+ * other with no sort and no ordering rule, because they share one voxel volume. Switch the
+ * transparency mode to MBOIT and the particles vanish while the pane stays — MBOIT is the legacy
+ * path and has no particle channel — which is a fair way to see where they now live.
  *
  * Serve the workspace with `npm run dev --workspace @woosh/meep-engine` and open
- * `/src/shade/playground/particle_system/index.html`. See README.md for what to look at, and for
- * the `?debug` query flag that swaps rAF for manual stepping.
+ * `/src/shade/playground/particle_system/index.html`. See README.md for what to look at and for
+ * the `?debug` query flag that swaps the frame loop for manual stepping.
  */
+/** Device pixels per CSS pixel, capped: 64k billboards at 3x cost more than they show. */
+const MAX_PIXEL_RATIO = 2;
+/** The page is full-bleed, so the canvas is the window. In CSS pixels: the renderer scales them. */
+const view_size = () => [Math.max(1, window.innerWidth), Math.max(1, window.innerHeight)];
+const CAMERA = {
+    position: new Vector3(9.5, 4.5, 9.5),
+    target: new Vector3(0, 2, 0),
+    fov_degrees: 55,
+    near: 0.1,
+    far: 200,
+};
 /** How often the counters are copied back for the overlay. Display only — nothing sizes a pass. */
 const STATS_INTERVAL_FRAMES = 30;
-/** Device pixels per CSS pixel, capped: 32k billboards at 3x cost more than they show. */
-const MAX_PIXEL_RATIO = 2;
+/** Particles one press of the burst button asks the sparks emitter for. */
+const BURST_COUNT = 4000;
+const element = id => document.getElementById(id);
 async function main() {
-    const canvas = document.getElementById("view");
+    const canvas = element("view");
+    // The canvas is the renderer's: `initialize` and `resize` set its backing size from the CSS
+    // size they are given and the pixel ratio, and pin its style to match. Nothing here writes
+    // canvas.width.
+    const pixel_ratio = Math.min(window.devicePixelRatio || 1, MAX_PIXEL_RATIO);
+    let [view_width, view_height] = view_size();
+    // ---- camera and controls, before anything needs a device --------------------------------
+    // Wired first on purpose: a browser without an adapter still gets a page that can be driven,
+    // and the failure it reports is the device's, not a cascade of undefined handlers.
+    const camera = new PerspectiveCamera();
+    camera.near = CAMERA.near;
+    camera.far = CAMERA.far;
+    camera.fov = CAMERA.fov_degrees * DEG_TO_RAD;
+    camera.aspect = view_width / view_height;
+    camera.transform.setTranslation(CAMERA.position[0], CAMERA.position[1], CAMERA.position[2]);
+    camera.transform.lookAt(CAMERA.target);
+    camera.transform.updateMatrix();
+    // document.body rather than the canvas: the controller starts a keyboard device, and only a
+    // focusable element receives key events
+    const controller = new OrbitalCameraController(camera, document.body);
+    controller.look(CAMERA.position, CAMERA.target);
+    controller.movement_speed_scale = 4;
+    /** @type {Renderer|null} the renderer once its device is up; null before, and on failure */
+    let renderer = null;
+    /** @type {import("../../renderer/particles/GPUParticleSystem.js").GPUParticleSystem|null} */
+    let system = null;
+    const { scene, emitters } = await build_particle_scene();
+    Object.assign(globalThis, { camera, controller, scene, emitters });
+    /**
+     * Where the camera is and what it orbits, as plain numbers: enough to put another instance of
+     * this page in exactly the same view.
+     *
+     * @returns {{position: number[], target: number[], fov_degrees: number}}
+     */
+    globalThis.camera_state = () => {
+        const p = camera.transform;
+        const t = controller.target;
+        const round = v => Math.round(v * 1000) / 1000;
+        return {
+            position: [round(p.translation_x), round(p.translation_y), round(p.translation_z)],
+            target: [round(t.x), round(t.y), round(t.z)],
+            fov_degrees: round(camera.fov / DEG_TO_RAD),
+        };
+    };
-    if (navigator.gpu === undefined) {
-        return show_message("WebGPU is not available in this browser.");
-    }
+    /**
+     * Put the camera where a {@link camera_state} says.
+     *
+     * @param {{position: number[], target: number[], fov_degrees?: number}|string} state
+     */
+    globalThis.apply_camera = state => {
+        const parsed = typeof state === "string" ? JSON.parse(state) : state;
+        if (parsed.fov_degrees !== undefined) {
+            camera.fov = parsed.fov_degrees * DEG_TO_RAD;
+        }
+        controller.look(
+            new Vector3(parsed.position[0], parsed.position[1], parsed.position[2]),
+            new Vector3(parsed.target[0], parsed.target[1], parsed.target[2])
+        );
+    };
-    const adapter = await navigator.gpu.requestAdapter();
+    function apply_settings() {
+        if (renderer === null) {
+            return;
+        }
-    if (adapter === null) {
-        return show_message("No WebGPU adapter — this browser exposes the API but has no usable GPU.");
+        renderer.feature_particles_enabled = element("particles").checked;
+        renderer.transparency_mode = element("transparency").value === "MBOIT"
+            ? ShadeTransparencyMode.MBOIT
+            : ShadeTransparencyMode.AVBOIT;
+        renderer.feature_taa_enabled = element("taa").checked;
     }
-    // The coherence pass's bucket offsets come from the CSDLDF prefix scan, which is built on
-    // subgroup ops — refusing by name beats the pipeline-creation error a device without it raises.
-    if (!adapter.features.has("subgroups")) {
+    element("particles").addEventListener("change", apply_settings);
+    element("transparency").addEventListener("change", apply_settings);
+    element("taa").addEventListener("change", apply_settings);
+    element("burst").addEventListener("click", () => {
+        /*
+         A row is assigned when the system sweeps the scene, which happens inside the frame it
+         simulates — so before the first frame the emitter has none and `spawn` refuses. And a burst
+         queued while the particles are switched off is never drained: the ring only empties inside
+         a simulated frame, so the clicks would pile up and arrive together, seconds late, the
+         moment they are switched back on. Both are the same answer: the button does nothing.
+        */
+        if (system === null || !renderer.feature_particles_enabled || emitters.sparks.row === -1) {
+            return;
+        }
+        // The CPU's one way to ask for particles, and it is a facade over the GPU path: the count
+        // reaches a command buffer, a pass adds it to that emitter's pending spawns, and the same
+        // budget and INIT program serve it as serve the emitter's own rate.
+        system.spawn(emitters.sparks, BURST_COUNT);
+    });
+    document.body.focus();
+    // ---- the device, last --------------------------------------------------------------------
+    const context = canvas.getContext("webgpu");
+    if (context === null) {
         return show_message(
-            "This browser's WebGPU adapter does not offer the 'subgroups' feature.\n"
-            + "The simulate list's program-coherent bucketing scans its bin counts with the CSDLDF\n"
-            + "prefix scan, which is built on subgroup ops."
+            "No WebGPU context.\n\nThis browser has no WebGPU, or the page is not a secure context "
+            + "— it has to be served over http://localhost rather than opened from file://."
         );
     }
-    const device = await adapter.requestDevice({ requiredFeatures: ["subgroups"] });
-    device.addEventListener?.("uncapturederror", (e) => console.error("WebGPU error:", e.error.message));
+    const candidate = new Renderer();
-    // Every compute pass here carries its per-dispatch state as immediate data, an optional
-    // capability. Refusing by name beats the pipeline-creation error a device without it raises,
-    // which names neither the shader nor the feature.
-    if (!immediate_data_supported() || !device_supports_immediate_size(device, PARTICLE_IMMEDIATE_BYTES)) {
-        return show_message(
-            "This browser's WebGPU offers no usable immediate data "
-            + `(needs ${PARTICLE_IMMEDIATE_BYTES} bytes, offers ${device.limits.maxImmediateSize ?? 0}).\n`
-            + "The particle emit / simulate / build-indirect passes all carry their per-dispatch\n"
-            + "state that way, so none of them can be built here."
-        );
+    try {
+        await candidate.initialize({ context, pixelRatio: pixel_ratio });
+    } catch (e) {
+        console.error(e);
+        return show_message("The device could not be acquired.\n\n" + e.message);
     }
-    const graphics = new GraphicsContext(device);
-    const context = canvas.getContext("webgpu");
-    const format = navigator.gpu.getPreferredCanvasFormat();
-    context.configure({ device, format, alphaMode: "opaque" });
+    renderer = candidate;
+    globalThis.renderer = renderer;
+    renderer.resize(view_width, view_height);
+    // eye adaptation drifts for seconds after any change, which makes the picture hard to compare
+    renderer.feature_automatic_exposure_enabled = false;
+    renderer.exposure_compensation = 1.2;
-    const scene = create_particle_scene(graphics, { color_format: format });
+    system = configure_particles(renderer, scene);
+    globalThis.particles = system;
-    // Manual frame stepping instead of rAF — opt in with ?debug. Useful for driving the loop a
-    // known number of frames in a headless / hidden tab, where rAF is suspended.
-    const debug = new URLSearchParams(location.search).has("debug");
+    apply_settings();
+    // the meshes are lit; without an environment they are lit by the sun alone
+    load_default_environment(scene).catch(e => console.warn("environment:", e.message));
+    // ---- frame loop --------------------------------------------------------------------------
+    const device = renderer.graphics.device;
     const stats_buffer = device.createBuffer({
         label: "particles/stats",
         size: PARTICLE_STATS_BYTES,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
     });
-    let stats_pending = false;
-    let last = performance.now();
+    let stats_pending = false;
     let frame_index = 0;
+    let time = 0;
     let fps = 0;
-    function frame(now) {
-        const dt = Math.min((now - last) / 1000, 0.05);
-        last = now;
-        // A rAF-driven loop steps by wall clock; ?debug steps by hand, where dt can be 0.
+    function frame(dt) {
+        time += dt;
         fps = dt > 0 ? fps * 0.9 + 0.1 / dt : fps;
-        // Back the canvas with device pixels, so a HiDPI display gets a sharp image rather than an
-        // upscaled CSS-pixel one.
-        const ratio = Math.min(window.devicePixelRatio || 1, MAX_PIXEL_RATIO);
-        const width = Math.max(1, Math.round(canvas.clientWidth * ratio));
-        const height = Math.max(1, Math.round(canvas.clientHeight * ratio));
+        const [width, height] = view_size();
-        if (canvas.width !== width || canvas.height !== height) {
-            canvas.width = width;
-            canvas.height = height;
+        if (width !== view_width || height !== view_height) {
+            view_width = width;
+            view_height = height;
+            camera.aspect = width / height;
+            renderer.resize(width, height);
         }
-        const cmd = ShadeGPUCommandContext.create(graphics, "particles/frame");
+        animate_particle_scene(emitters, time);
+        controller.update();
-        scene.encode_frame(cmd, {
-            color_view: context.getCurrentTexture().createView(),
-            width,
-            height,
-            dt,
-            time: now / 1000,
-        });
+        renderer.render(camera, scene, dt);
-        const capture_stats = !stats_pending && frame_index % STATS_INTERVAL_FRAMES === 0;
-        if (capture_stats) {
-            scene.encode_stats_copy(cmd, stats_buffer);
+        frame_index++;
+        if (!stats_pending && frame_index % STATS_INTERVAL_FRAMES === 0) {
+            capture_stats();
         }
+    }
-        cmd.finish();
+    /** Read the counters back to display them. Submitted on its own, after the frame's own work. */
+    function capture_stats() {
+        const encoder = device.createCommandEncoder({ label: "particles/stats" });
-        frame_index++;
+        encode_stats_copy(system, encoder, stats_buffer);
+        device.queue.submit([encoder.finish()]);
-        if (capture_stats) {
-            stats_pending = true;
-            stats_buffer.mapAsync(GPUMapMode.READ).then(() => {
-                const bytes = stats_buffer.getMappedRange().slice(0);
-                stats_buffer.unmap();
-                stats_pending = false;
-                window.__stats = { frame: frame_index, fps, ...scene.read_stats(bytes) };
-                write_hud(window.__stats);
-            }).catch(() => {
-                stats_pending = false;
-            });
-        }
+        stats_pending = true;
+        stats_buffer.mapAsync(GPUMapMode.READ).then(() => {
+            const bytes = stats_buffer.getMappedRange().slice(0);
+            stats_buffer.unmap();
+            stats_pending = false;
-        if (!debug) {
-            requestAnimationFrame(frame);
+            globalThis.__stats = { frame: frame_index, fps, ...read_stats(bytes) };
+            write_hud(globalThis.__stats);
+        }).catch(() => {
+            stats_pending = false;
+        });
+    }
+    /** @type {(() => void)|null} */
+    let stop_loop = null;
+    /**
+     * One frame, with the loop stopped on the first failure.
+     *
+     * A lost device makes `render` throw, and the frame loop re-arms itself before it calls back —
+     * so without this the page would throw once per frame, for ever, with the first and most
+     * informative failure scrolled far out of reach.
+     *
+     * @param {number} dt
+     */
+    function guarded_frame(dt) {
+        try {
+            frame(dt);
+        } catch (e) {
+            stop_loop?.();
+            console.error(e);
+            show_message("The frame failed and the loop has stopped.\n\n" + e.message);
         }
     }
-    if (debug) {
+    device.lost?.then(info => {
+        stop_loop?.();
+        show_message("The GPU device was lost.\n\n" + (info?.message ?? ""));
+    });
+    if (new URLSearchParams(location.search).has("debug")) {
         // Drive frames by hand when the tab is hidden (rAF suspended) — headless verification.
         // Nothing is scheduled: a stray rAF frame interleaved with __step would make the count the
         // caller asked for and the count that ran two different numbers.
-        window.__step = (n = 1) => {
+        globalThis.__step = (n = 1, dt = 1 / 60) => {
             for (let i = 0; i < n; i++) {
-                frame(performance.now());
+                guarded_frame(dt);
             }
             return frame_index;
         };
         return;
     }
-    requestAnimationFrame(frame);
+    stop_loop = create_frame_loop(dt => guarded_frame(Math.min(dt, 0.05)));
 }
 /** Push one stats snapshot into the overlay. Absent elements are simply skipped. */
 function write_hud({ fps, alive, dead, dispatch, draw, sim_padded }) {
     const put = (id, value) => {
-        const node = document.getElementById(id);
+        const node = element(id);
         if (node !== null) {
             node.textContent = value;
         }
@@ -177,17 +325,14 @@ function write_hud({ fps, alive, dead, dispatch, draw, sim_padded }) {
 }
 function show_message(text) {
-    const existing = document.getElementById("message");
-    const node = existing ?? document.body.appendChild(document.createElement("div"));
+    const node = element("message");
-    if (existing === null) {
-        node.style.cssText = "position:fixed;inset:0;display:flex;align-items:center;justify-content:center;color:#fff;font-family:sans-serif;font-size:16px;white-space:pre-wrap;text-align:center";
+    if (node !== null) {
+        node.textContent = text;
     }
-    node.textContent = text;
 }
-main().catch((e) => {
+main().catch(e => {
     console.error(e);
     show_message("The particle playground failed to start — see the console.\n\n" + e.message);
 });

package/src/shade/{renderer/particles → playground/particle_system}/particle_prototype.d.ts RENAMED Viewed

@@ -1,9 +1,13 @@
 /**
- * Worked examples of authoring particle effects with the node graph + wiring them into a
- * {@link GPUParticleSystem}. Demonstrates: distinct per-particle lifecycle (no built-in age — the
+ * Worked examples of authoring particle effects with the node graph + placing them in a scene for a
+ * {@link GPUParticleSystem} to run. Demonstrates: distinct per-particle lifecycle (no built-in age — the
  * effect declares it), AnimationCurve sampling over life, flipbook frames, random emission,
  * additive vs alpha blending, projection modes, soft depth and lighting toggles.
  *
+ * These are examples, not engine code, which is why they sit here rather than under
+ * `renderer/particles/`: the only thing that opens them is this playground's page, and keeping them
+ * on this side of the line means the dependency runs playground -> renderer and never back.
+ *
  * `curves` is a `GPUAnimationManager` (or anything with `register_curve(AnimationCurve) -> handle`);
  * `size_curve` / `alpha_curve` are meep `AnimationCurve`s. Both are optional — passing `undefined`
  * yields effects that use constant size/alpha instead (curve handle 0, evaluated as 0 by the
@@ -39,26 +43,25 @@ export function smoke_effect(): {
     emitter: object;
 };
 /**
- * Register a fire + smoke plume on a particle system, optionally attaching the fire to a bone.
+ * Put a fire + smoke plume in a scene, optionally riding a bone.
  *
- * The per-frame loop the integrator runs:
- * ```js
- * const spawn_requests = system.update(dt, { is_visible });     // CPU: bone transforms + spawn counts
- * system.uploadFrame(spawn_requests);                           // upload emitters (if dirty) + requests
- * graph_particles({ graph, gpu: system.gpuHandles(), frame });  // reset -> emit -> simulate -> indirect
- * // caller appends the depth sort + billboard render into its own graph
- * ```
+ * An emitter is a scene node, so this is scene-graph work and nothing else: build the two emitters,
+ * parent them to the bone if there is one, add them to the scene. The particle system finds them
+ * on its next frame, gives them rows, and the GPU composes the bone's motion into every particle
+ * they spawn — there is no per-frame call to make.
  *
- * @param {import("./GPUParticleSystem.js").GPUParticleSystem} system
+ * @param {import("../../renderer/scene/Scene.js").Scene} scene
  * @param {object} [options]
- * @param {object} [options.bone] a Node3D to attach the fire emitter to
- * @returns {{fire: number, smoke: number}} emitter indices
+ * @param {import("../../renderer/scene/Node3D.js").Node3D} [options.bone] a node, already in the
+ *        scene, for both emitters to hang off
+ * @returns {{fire: ParticleEmitter, smoke: ParticleEmitter}}
  */
-export function register_campfire(system: import("./GPUParticleSystem.js").GPUParticleSystem, { bone }?: {
-    bone?: object;
+export function register_campfire(scene: import("../../renderer/scene/Scene.js").Scene, { bone }?: {
+    bone?: import("../../renderer/scene/Node3D.js").Node3D;
 }): {
-    fire: number;
-    smoke: number;
+    fire: ParticleEmitter;
+    smoke: ParticleEmitter;
 };
-import { ParticleLayout } from "./layout/ParticleLayout.js";
+import { ParticleLayout } from "../../renderer/particles/layout/ParticleLayout.js";
+import { ParticleEmitter } from "../../renderer/particles/runtime/ParticleEmitter.js";
 //# sourceMappingURL=particle_prototype.d.ts.map

package/src/shade/playground/particle_system/particle_prototype.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_prototype.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH;IAL4B,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,eAAe,GAAhC,MAAM;;YACK,cAAc;YAAU,MAAM;aAAW,MAAM;EAgHpE;AAED;;;;GAIG;AACH;YAFsB,cAAc;YAAU,MAAM;aAAW,MAAM;EAcpE;AAED;;;;;;;;;;;;;GAaG;AACH,yCANW,OAAO,+BAA+B,EAAE,KAAK;IAEa,IAAI,GAA9D,OAAO,gCAAgC,EAAE,MAAM;;UAEtC,eAAe;WAAS,eAAe;EAe1D;+BA5L8B,mDAAmD;gCAElD,qDAAqD"}