npm - @woosh/meep-engine - Versions diffs - 3.19.0 → 3.20.0 - Mend

@woosh/meep-engine 3.19.0 → 3.20.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 (123) hide show

package/src/shade/playground/ssr_motion/index.html ADDED Viewed

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>SSR cross · camera motion</title><style>
+body{margin:24px;background:#14161a;color:#e7e9ee;font:14px/1.5 system-ui}h1{font-size:24px;margin-bottom:8px}p{color:#acb5c5;max-width:900px}main{display:grid;grid-template-columns:minmax(0,800px) 260px;gap:24px}canvas{display:block;width:100%;height:auto;background:#08090a;touch-action:none;outline:none}canvas:focus{outline:1px solid #749ac4}label{display:block;margin:0 0 14px}input[type=range],select{width:100%}button,select{font:inherit;padding:8px;background:#29313e;color:inherit;border:1px solid #4b586d;border-radius:4px}button{margin:0 4px 8px 0}output{float:right;font-variant-numeric:tabular-nums}a{color:#9ac9ff}#status{white-space:pre-wrap}.error{color:#ff9a9a}@media(max-width:900px){main{grid-template-columns:1fr}}
+</style></head><body tabindex="0">
+<h1>SSR cross · camera motion</h1>
+<p>The same glowing cross and colored markers as the variance lab. Fixed exposure; final-image TAA defaults off. Drag to orbit, right-drag to pan, scroll to zoom, or focus the scene and use WASD.</p>
+<main><section><canvas id="view" width="800" height="500" tabindex="0" aria-label="Interactive reflection scene"></canvas><p id="status" role="status">Initializing…</p><p><a href="../ssr_variance/">Exact variance and convergence measurements</a></p></section><aside>
+<label>Floor roughness <output id="roughness-value">0.30</output><input id="roughness" aria-label="Floor roughness" type="range" min="0.01" max="1" step="0.01" value="0.3"></label>
+<label>Camera <select id="motion"><option value="free">Free camera</option><option value="lateral">Lateral movement</option><option value="forward">Forward movement</option><option value="orbit">Orbit movement</option><option value="still">Still camera</option></select></label>
+<label>Motion speed <output id="speed-value">1.0×</output><input id="speed" aria-label="Motion speed" type="range" min="0.1" max="3" step="0.1" value="1"></label>
+<label>SSR history <select id="temporal"><option value="0">Parallax</option><option value="1">Surface only</option><option value="2">No temporal history</option></select></label>
+<label><input id="spatial" type="checkbox" checked> Spatial denoising</label>
+<label><input id="taa" type="checkbox"> Final-image TAA</label>
+<label><input id="jitter" type="checkbox"> Raster jitter</label>
+<button id="motion-pause">Pause motion</button><button id="render-pause">Pause rendering</button><button id="step">Step frame</button><button id="restart">Reset camera</button><button id="reset">Reset SSR history</button>
+<p>Pausing motion keeps sampling. Pausing rendering freezes the displayed frame. Ordinary camera movement preserves history; resets and material changes clear it.</p>
+</aside></main><script type="module" src="./main.js"></script></body></html>

package/src/shade/playground/ssr_motion/main.d.ts ADDED Viewed

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

package/src/shade/playground/ssr_motion/main.d.ts.map ADDED Viewed

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

package/src/shade/playground/ssr_motion/main.js ADDED Viewed

@@ -0,0 +1,149 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";
+import { FixedProjection } from "../ssr_variance/capture.js";
+import { create_scene } from "../ssr_variance/scene.js";
+const element = id => document.getElementById(id);
+const params = new URLSearchParams(location.search);
+const number = (name, fallback, min, max) => {
+    const value = Number(params.get(name) ?? fallback);
+    return Number.isFinite(value) ? Math.min(max, Math.max(min, value)) : fallback;
+};
+element('roughness').value = number('roughness', 0.3, 0.01, 1);
+element('speed').value = number('speed', 1, 0.1, 3);
+if (['free', 'lateral', 'forward', 'orbit', 'still'].includes(params.get('motion'))) { element('motion').value = params.get('motion'); }
+if (['0', '1', '2'].includes(params.get('temporal'))) { element('temporal').value = params.get('temporal'); }
+element('spatial').checked = params.get('spatial') !== 'off';
+for (const name of ['taa', 'jitter']) { element(name).checked = params.get(name) === 'on'; }
+async function start() {
+    const canvas = element('view'), renderer = new Renderer();
+    await renderer.initialize({ context: canvas.getContext('webgpu'), pixelRatio: 1 });
+    renderer.feature_ssr_enabled = true;
+    renderer.indirect_lighting_mode = ShadeIndirectLightingMode.IBL;
+    for (const name of ['ssao', 'bloom', 'sharpening', 'motion_blur', 'automatic_exposure']) { renderer[`feature_${name}_enabled`] = false; }
+    renderer.exposure_compensation = 1;
+    renderer.internal_resolution_scale = 1;
+    renderer.feature_taa_enabled = element('taa').checked;
+    renderer.ssr.spatial_denoising_enabled = element('spatial').checked;
+    renderer.ssr.reprojection_mode = Number(element('temporal').value);
+    const world = await create_scene();
+    world.ground_material.roughness_factor = Number(element('roughness').value);
+    const floor_materials = new Map([[world.ground_material.roughness_factor, world.ground_material]]);
+    const camera = new PerspectiveCamera();
+    camera.near = 0.1; camera.far = 50; camera.fov = 50 * Math.PI / 180;
+    camera.aspect = canvas.width / canvas.height;
+    const controller = new OrbitalCameraController(camera, canvas);
+    controller.movement_speed_scale = 2;
+    renderer.resize(canvas.width, canvas.height);
+    class ProjectionControl extends FixedProjection {
+        record(frame) { if (!element('jitter').checked) { super.record(frame); } }
+    }
+    renderer.add_extension(new ProjectionControl());
+    let phase = 0, frame_count = 0, motion_paused = false;
+    let rendering_paused = params.has('manual'), stopped = false, request, last_time, last_status = 0;
+    const pose = (position, target) => {
+        camera.transform.setTranslation(...position);
+        camera.transform.lookAt(new Vector3(...target));
+        camera.transform.updateMatrix();
+        controller.look(new Vector3(...position), new Vector3(...target));
+    };
+    function status() {
+        element('status').textContent = `Frame ${frame_count} · roughness ${world.ground_material.roughness_factor.toFixed(2)}\n${rendering_paused ? 'Rendering paused' : motion_paused ? 'Motion paused · sampling continues' : 'Running'} · final TAA ${renderer.feature_taa_enabled ? 'on' : 'off'}`;
+        element('render-pause').textContent = rendering_paused ? 'Resume rendering' : 'Pause rendering';
+    }
+    function fail(error) {
+        stopped = true; cancelAnimationFrame(request);
+        element('status').textContent = error.message ?? String(error);
+        element('status').classList.add('error'); console.error(error);
+    }
+    function reset_camera() {
+        phase = 0; pose([0, 3.2, 7], [0, 0.2, -2]);
+        renderer.indicate_view_change(); status();
+    }
+    function set_roughness() {
+        const roughness = Number(element('roughness').value);
+        // GPU material contexts are immutable after upload. Reuse at most one
+        // material per slider value, and refresh the scene's material membership.
+        let material = floor_materials.get(roughness);
+        if (!material) {
+            material = world.ground_material.clone();
+            material.roughness_factor = roughness;
+            floor_materials.set(roughness, material);
+        }
+        if (material !== world.ground_material) {
+            world.scene.remove(world.ground);
+            world.ground.material = world.ground_material = material;
+            world.ground.updateMatrices();
+            renderer.graphics.materials.obtain(material);
+            world.scene.add(world.ground);
+        }
+        element('roughness-value').textContent = world.ground_material.roughness_factor.toFixed(2);
+        renderer.indicate_view_change(); status();
+    }
+    function frame(dt = 1 / 60, advance = true) {
+        if (stopped) { throw new Error('Renderer stopped after an error'); }
+        const mode = element('motion').value;
+        if (advance && !motion_paused) {
+            phase += dt * Number(element('speed').value) * 0.7;
+            const t = Math.sin(phase);
+            if (mode === 'free') { controller.update(dt); }
+            else if (mode === 'lateral') { pose([2 * t, 3.2, 7], [2 * t, 0.2, -2]); }
+            else if (mode === 'forward') { pose([0, 3.2, 7 + 1.6 * t], [0, 0.2, -2 + 1.6 * t]); }
+            else if (mode === 'orbit') { pose([4 * t, 3.2, 7 - 0.7 * t * t], [0, 0.2, -2]); }
+        }
+        if (renderer.render(camera, world.scene, dt) === false) { throw new Error('Renderer did not submit the frame'); }
+        frame_count++;
+        if (performance.now() - last_status > 250 || rendering_paused) { status(); last_status = performance.now(); }
+        return frame_count;
+    }
+    function tick(time) {
+        if (stopped) { return; }
+        const dt = last_time === undefined ? 1 / 60 : Math.min((time - last_time) / 1000, 0.05);
+        last_time = time;
+        try { if (!rendering_paused) { frame(dt); } }
+        catch (error) { fail(error); return; }
+        request = requestAnimationFrame(tick);
+    }
+    element('roughness').oninput = set_roughness;
+    element('speed').oninput = () => { element('speed-value').textContent = `${Number(element('speed').value).toFixed(1)}×`; };
+    element('speed').oninput();
+    element('motion').onchange = () => {
+        if (element('motion').value !== 'free') { reset_camera(); }
+    };
+    canvas.addEventListener('pointerdown', () => { canvas.focus(); element('motion').value = 'free'; motion_paused = false; element('motion-pause').textContent = 'Pause motion'; });
+    canvas.addEventListener('contextmenu', event => event.preventDefault());
+    element('temporal').onchange = () => { renderer.ssr.reprojection_mode = Number(element('temporal').value); };
+    element('spatial').onchange = () => { renderer.ssr.spatial_denoising_enabled = element('spatial').checked; };
+    element('taa').onchange = () => { renderer.feature_taa_enabled = element('taa').checked; renderer.indicate_view_change(); status(); };
+    element('jitter').onchange = () => renderer.indicate_view_change();
+    element('motion-pause').onclick = () => { motion_paused = !motion_paused; element('motion-pause').textContent = motion_paused ? 'Resume motion' : 'Pause motion'; status(); };
+    element('render-pause').onclick = () => { rendering_paused = !rendering_paused; status(); };
+    element('step').onclick = () => { rendering_paused = true; try { frame(); } catch (error) { fail(error); } };
+    element('restart').onclick = reset_camera;
+    element('reset').onclick = () => { renderer.ssr.reset_history = true; };
+    const device = renderer.graphics.device;
+    device.addEventListener('uncapturederror', event => fail(event.error));
+    device.lost.then(info => { if (!stopped) { fail(new Error(`GPU device lost: ${info.message}`)); } });
+    addEventListener('pagehide', () => { stopped = true; cancelAnimationFrame(request); controller.pointer.stop(); controller.keyboard.stop(); renderer.destroy(); device.destroy(); });
+    addEventListener('pageshow', event => { if (event.persisted) { location.reload(); } });
+    reset_camera(); set_roughness();
+    const lab = globalThis.ssr_motion_lab = {
+        renderer, camera, world, frame, pose,
+        step(n = 1, advance = true) {
+            if (!rendering_paused) { throw new Error('Pause rendering before exact stepping'); }
+            if (!Number.isSafeInteger(n) || n < 1) { throw new Error('Step count must be a positive integer'); }
+            for (let i = 0; i < n; i++) { frame(1 / 60, advance); }
+            return frame_count;
+        },
+        get frame_count() { return frame_count; },
+    };
+    request = requestAnimationFrame(tick);
+    return lab;
+}
+globalThis.ssr_motion_ready = start().catch(error => {
+    element('status').textContent = error.message ?? String(error); console.error(error); throw error;
+});

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

@@ -5,6 +5,7 @@ body{margin:24px;background:#14161a;color:#e7e9ee;font:14px system-ui}h1{font-si
 </style></head><body>
 <h1>SSR variance lab</h1>
 <p>One ground plane · roughness 0.30 · metallic 1 · textured emissive card · fixed camera and exposure. Starts at frame zero. Rendering advances only when requested.</p>
+<p><a href="../ssr_motion/">Move the camera and adjust floor roughness</a></p>
 <label>Spatial <select id="spatial"><option value="on">On</option><option value="off">Off</option></select></label>
 <label>Temporal <select id="temporal"><option value="on">On</option><option value="off">Off</option></select></label>
 <label>Raster jitter <select id="jitter"><option value="off">Off</option><option value="on">On</option></select></label>

package/src/shade/renderer/geometry/Geometry.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"Geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/Geometry.js"],"names":[],"mappings":"~~4BA2BU~~,MAAM;;;;AAQhB;;GAEG;AACH;IAQI;;;;OAIG;IACH,iBAEC;IAED;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,YAFU,SAAS,EAAE,CAEL;IAEhB;;;OAGG;IACH,OAFU,SAAS,GAAC,IAAI,CAEX;IAEb;;;OAGG;IACH,cAFU,YAAY,CAEa;IACnC;;;OAGG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;;;;;;;OAUG;IACH,sBAEC;IAED;;OAEG;IACH,8BAIC;IAGD;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,SACpB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAYnB;IAED,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAkB9B;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QAQnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QASnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAiB9B;IAED;;;OAGG;IACH,kBAFY,MAAM,CAWjB;IAED;;;OAGG;IACH,iBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAIC;IAED;;OAEG;IACH,mBASC;IAED,qBAIC;IAED;;OAEG;IACH,qCAoBC;IAED,8BAaC;IAED,8BAKC;IAED,2BAeC;IAED,sBAOC;IAED,uBA4BC;IAoFD,uBAOC;IAED,wBAWC;IAED;;;OAGG;IACH,YAFW,QAAQ,~~QAmBlB~~;IAED;;;OAGG;IACH,SAFY,QAAQ,CAQnB;IAED,eAEC;IAED;;;OAGG;IACH,iCAYC;IAGL;;;OAGG;IACH,qBAFU,OAAO,CAEY;;CAN5B;~~0BAvkByB~~,gBAAgB"}
1	+ {"version":3,"file":"Geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/Geometry.js"],"names":[],"mappings":"4BA4BU,MAAM;;;;AAQhB;;GAEG;AACH;IAQI;;;;OAIG;IACH,iBAEC;IAED;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,YAFU,SAAS,EAAE,CAEL;IAEhB;;;OAGG;IACH,OAFU,SAAS,GAAC,IAAI,CAEX;IAEb;;;OAGG;IACH,cAFU,YAAY,CAEa;IACnC;;;OAGG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;;;;;;;OAUG;IACH,sBAEC;IAED;;OAEG;IACH,8BAIC;IAGD;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,SACpB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAYnB;IAED,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAkB9B;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QAQnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QASnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAiB9B;IAED;;;OAGG;IACH,kBAFY,MAAM,CAWjB;IAED;;;OAGG;IACH,iBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAIC;IAED;;OAEG;IACH,mBASC;IAED,qBAIC;IAED;;OAEG;IACH,qCAoBC;IAED,8BAaC;IAED,8BAKC;IAED,2BAeC;IAED,sBAOC;IAED,uBA4BC;IAoFD,uBAOC;IAED,wBAWC;IAED;;;OAGG;IACH,YAFW,QAAQ,QAelB;IAED;;;OAGG;IACH,SAFY,QAAQ,CAQnB;IAED,eAEC;IAED;;;OAGG;IACH,iCAYC;IAGL;;;OAGG;IACH,qBAFU,OAAO,CAEY;;CAN5B;0BAnkByB,gBAAgB"}

package/src/shade/renderer/geometry/Geometry.js CHANGED Viewed

@@ -14,8 +14,9 @@ import {
 import {
     geometry_compute_vertex_normals_unindexed
 } from "../../../engine/graphics/geometry/buffered/geometry_compute_vertex_normals_unindexed.js";
-import { optional_equality } from "../../descriptor/util/optional_equality.js";
-import { optional_hash } from "../../descriptor/util/optional_hash.js";
+import { optional_clone } from "../../../core/model/object/optional_clone.js";
+import { optional_equality } from "../../../core/model/object/optional_equality.js";
+import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { Attribute } from "./Attribute.js";
 import { build_tangent_from_normal } from "./normals/build_tangent_from_normal.js";
 import { geometry_build_tangents } from "./normals/geometry_build_tangents.js";
@@ -551,11 +552,7 @@ export class Geometry {
         this.name = other.name;
-        if (other.index !== null) {
-            this.index = other.index.clone();
-        } else {
-            this.index = null;
-        }
+        this.index = optional_clone(other.index);
         this.attributes = other.attributes.map(a => a.clone());

package/src/shade/renderer/material/StandardShadeMaterial.js CHANGED Viewed

@@ -1,8 +1,8 @@
 import { combine_hash } from "../../../core/collection/array/combine_hash.js";
 import { Color } from "../../../core/color/Color.js";
 import LinearModifier from "../../../core/model/stat/LinearModifier.js";
-import { optional_equality } from "../../descriptor/util/optional_equality.js";
-import { optional_hash } from "../../descriptor/util/optional_hash.js";
+import { optional_equality } from "../../../core/model/object/optional_equality.js";
+import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { ShadeMaterial } from "./ShadeMaterial.js";
 export class StandardShadeMaterial extends ShadeMaterial {

package/src/shade/renderer/particles/DESIGN.md CHANGED Viewed

@@ -22,7 +22,7 @@ the decision to spawn is the GPU's.
 - Distinct per-particle lifecycle: **no** built-in age/position — the schema + program define state.
 - Billboard renderer reuses engine shader chunks incl. lighting (forward-shaded, optional per emitter).
 - Blend modes (alpha + additive) via a **single** premultiplied blend setup.
-- `AnimationCurve` sampling during simulation (reuse `chunk_animation_curve_evaluate`).
+- Authored curves and RGB/RGBA gradients compiled into arithmetic for simulation.
 - Spawning decided on the GPU, per emitter, with the CPU able to ask for bursts through the same path.
 - No per-frame allocation on the CPU beyond the frame graph's own records.
@@ -159,7 +159,7 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
   Word 0 packs the opcode (bits 0..7), the lane count (8..10), each source's `VM_KIND` (two bits per
   slot at 16..21) and the destination slot (24..31). A source word means what its kind says: `REG`
   is a base slot plus a swizzle, `IMM` is an `f32` bit pattern read in every lane, and `NONE` is a
-  raw field the opcode reads for itself (attribute word-offset+comp / curve handle / builtin id /
+  raw field the opcode reads for itself (attribute word-offset+comp / builtin id /
   pool index).
 - Constant pool: `array<vec4f>` per program, referenced by `LOAD_CONST`.
 - Two entry sections per program: **INIT** and **UPDATE** (offsets in the emitter record). INIT
@@ -167,8 +167,6 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
 - Builtins (`LOAD_BUILTIN`): DT, EMITTER_AGE, EMITTER_POSITION, EMITTER_DIRECTION, EMITTER_UP,
   PARTICLE_INDEX, SPAWN_FRACTION, TIME … assembled per-invocation by the host shader. The emitter's
   position and axes are its node's `global` out of the scene database.
-- `CURVE dst, handle, s0`: `dst.x = animation_curve_evaluate(curves[handle], s0.x)` — reuses the
-  engine's GPU AnimationCurve chunk + database.
 #### Two interpreters
@@ -212,11 +210,13 @@ A core `NodeGraph` holds particle nodes (ports + parameters) for INIT and UPDATE
 2. lowers each node to VM ops (nodes emit via a small builder that allocates result registers),
 3. linear-scan register allocation with liveness,
 4. interns constants into the pool,
-5. resolves curve/attribute references,
-6. emits `Program { init, update, constants, reg_count, attributes, curves }`.
+5. resolves attribute references,
+6. emits `Program { init, update, constants, reg_count, attributes }`.
 Standard node library: constants, attribute get/set, arithmetic/vector/math, random (uniform/sphere/
-disk/cone), curve-sample, noise (curl), integrate, gravity, emit-shapes, compare/select, kill-if.
+disk/cone), authored curves and RGB/RGBA gradients, noise (curl), integrate, gravity, emit-shapes,
+compare/select, kill-if. Curves and gradients expand into graph nodes that emit ordinary VM
+arithmetic; no animation-table binding or sampling opcode is needed.
 ### Emitters are scene nodes
@@ -684,7 +684,6 @@ src/shade/renderer/particles/
   warmup/chunk_particle_warmup_step.js       one particle's advance: per-lane decode, jittered tick
   warmup/shader_particle_warmup_advance.js   the advance over the fast file (+ _wide.js)
   warmup/graph_particle_warmup.js            the loop, recorded on a frame that registered a pre-warm
-  shaders/chunk_particle_curve_disabled.js   the no-curves-bound CURVE provider
   shaders/chunk_particle_billboard_vertex.js the billboard vertex stage, shared by every draw
   shaders/shader_particle_avboit_*.js        occupancy / splat / draw through AVBOIT
   bounds/*                           the measured emitter box: accumulate, publish
@@ -743,6 +742,5 @@ was seeded.
 Done: `Renderer.feature_particles_enabled` (off by default), `Renderer.particles(scene_ctx)` creating
 one system per scene context on first use, `simulate` recorded before the transparency pass and the
 system passed to the AVBOIT orchestrator as its side channel. Remaining:
-1. For lit emitters, compile a simulate/render variant that swaps the disabled curve/lighting hooks
-   for `chunk_particle_curve_animation` (+ bind `GPUAnimationManager.database.buffer`) and a
-   shading-chunk-backed lighting hook (+ the `SHADING_LIGHT_RESOURCE_GROUP`).
+1. For lit emitters, compile a render variant that swaps the disabled lighting hook for a
+   shading-chunk-backed lighting hook (+ the `SHADING_LIGHT_RESOURCE_GROUP`).

package/src/shade/renderer/particles/GPUParticleSystem.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"~~AA2CA~~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~~gCAhnC~~+B,8BAA8B;mCAD3B,yBAAyB"}
1	+ {"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/particles/GPUParticleSystem.js CHANGED Viewed

@@ -41,6 +41,8 @@ const WORD = Uint32Array.BYTES_PER_ELEMENT;
 const STORAGE = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
 const INDIRECT = GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_SRC;
+const DEFAULT_CAPACITY = 524288;
 /**
  * The GPU particle system: a feature of a scene, in the mould of `ReSTIRDI` — construct once
  * against a {@link GPUSceneContext}, and contribute the frame's passes through
@@ -299,7 +301,7 @@ export class GPUParticleSystem {
      * @param {number} [options.capacity] max simultaneous particles
      * @param {number} [options.spawn_command_capacity] most {@link spawn} calls one frame keeps
      */
-    constructor(graphics, scene_context, { capacity = 1 << 16, spawn_command_capacity = 256 } = {}) {
+    constructor(graphics, scene_context, { capacity = DEFAULT_CAPACITY, spawn_command_capacity = 256 } = {}) {
         assert.defined(graphics, "graphics");
         assert.defined(scene_context, "scene_context");
         assert.equal(scene_context.isGPUSceneContext, true, "scene_context.isGPUSceneContext !== true");

package/src/shade/renderer/particles/graph/ParticleGroupBuilder.d.ts CHANGED Viewed

@@ -9,7 +9,7 @@
  *
  * Every stock operation that takes no parameters of its own is a method here, taken from the library
  * rather than listed — a type added to it is callable the same day. The rest — `const`, `swizzle`,
- * `random`, `curve` and the attribute nodes — need a parameter and are reached through
+ * `random`, `curveLiteral` and the attribute nodes — need a parameter and are reached through
  * {@link #op}, or through the shorthands below where there is an obvious one.
  *
  * A number where a value is expected becomes a literal, so `g.mul(v, 0.5)` is what it looks like.

package/src/shade/renderer/particles/graph/ParticleGroupBuilder.js CHANGED Viewed

@@ -17,7 +17,7 @@ import {
  *
  * Every stock operation that takes no parameters of its own is a method here, taken from the library
  * rather than listed — a type added to it is callable the same day. The rest — `const`, `swizzle`,
- * `random`, `curve` and the attribute nodes — need a parameter and are reached through
+ * `random`, `curveLiteral` and the attribute nodes — need a parameter and are reached through
  * {@link #op}, or through the shorthands below where there is an obvious one.
  *
  * A number where a value is expected becomes a literal, so `g.mul(v, 0.5)` is what it looks like.

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":"~~AAqrBA~~;;;;;;;GAOG;AACH,8CAFa,uBAAuB,EAAE,CAIrC;AAED;;;;;GAKG;AACH,oDAJW,MAAM,GACJ,uBAAuB,CAWnC;~~AAhrBD~~;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;GASG;AACH,kCAFU,QAAQ,CAE2C;AAE7D;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,qCAFU,YAAY,CAEmC;wCAhEjB,8BAA8B;yBAZ7C,oDAAoD;6BAFhD,wDAAwD"}
1	+ {"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":"AA+qBA;;;;;;;GAOG;AACH,8CAFa,uBAAuB,EAAE,CAIrC;AAED;;;;;GAKG;AACH,oDAJW,MAAM,GACJ,uBAAuB,CAWnC;AA1qBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;GASG;AACH,kCAFU,QAAQ,CAE2C;AAE7D;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,qCAFU,YAAY,CAEmC;wCAhEjB,8BAA8B;yBAZ7C,oDAAoD;6BAFhD,wDAAwD"}

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.js CHANGED Viewed

@@ -90,12 +90,14 @@ for (const type of PARTICLE_ALL_VALUE_TYPES) {
  *
  * IDs are handed out in declaration order rather than by {@link NodeDescription}'s global counter,
  * so they do not drift with unrelated node usage elsewhere in the engine. Appending new node types
- * at the end of the library is therefore safe; reordering or removing existing ones renumbers every
- * node that follows, which would invalidate already-serialized graphs.
+ * at the end of the library is therefore safe. Removed types leave their IDs unused so existing
+ * serialized graphs retain the same IDs for every remaining type.
  *
  * @type {Map<string, ParticleNodeDescription>}
  */
-const descriptions_by_name = new Map();
+const descriptions_by_name = new Map();
+let next_description_id = 0;
 /**
  * @param {string} name
@@ -123,7 +125,7 @@ function define(name, inputs, emit, {
     const description = new ParticleNodeDescription();
     description.name = name;
-    description.id = descriptions_by_name.size;
+    description.id = next_description_id++;
     // what an author reads is decided in one table, away from the lowering; see
     // ./particle_node_presentation.js
@@ -572,14 +574,8 @@ define("compare", ["a", "b"], (s, c) => {
 }, MASK_RESULT);
 define("select", ["a", "b", "condition"], (s, c) => s.emit(VM_OP.SELECT, c.out, c.in("a"), c.in("b"), c.in("condition"), c.width), blend_controlled_by("condition"));
-// --- curves ---
-// One lane of `t` in, one value out — which the opcode writes across every lane it is asked for, so
-// a curve read wider than a scalar is the broadcast for free.
-define("curve", ["t"], (s, c) => s.curve(c.out, c.parameters.handle, c.in("t"), c.width), {
-    infer_types: () => ({ output: PARTICLE_TYPE_F32, inputs: { t: PARTICLE_TYPE_F32 } }),
-    operation_width: ({ demand }) => demand,
-    input_widths: () => ({ t: 1 }),
-});
+// ID 39 belonged to the removed animation-table sampler. Keep it unused.
+next_description_id++;
 // --- semantic sources ---
 // Appended rather than filed with the other sources, because a node type's id is its position in
@@ -665,9 +661,7 @@ function expanding(name, inputs, output, body) {
     return description;
 }
-// One curve, written into the program. Not the `curve` node above: that one samples a row of the
-// host's animation-curve table and this one *is* the curve, the way `color` is a colour rather than
-// the name of one.
+// One authored curve, written into the program as arithmetic.
 expanding(
     "curveLiteral",
     [{ name: "t", type: PARTICLE_TYPE_F32 }],

package/src/shade/renderer/particles/graph/particle_group_library.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"particle_group_library.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_library.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,+CAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,wBAAwB,EAAE,iBAAiB,~~CAgB9D~~;AAED;;;;GAIG;AACH,mCAFa,OAAO,wBAAwB,EAAE,iBAAiB,EAAE,CAIhE;AAED;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,SAAS,CAIxE;AAED;;;;;GAKG;AACH,6CAHW,MAAM,GACJ,OAAO,CAInB"}
1	+ {"version":3,"file":"particle_group_library.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_library.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,+CAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,wBAAwB,EAAE,iBAAiB,CAqB9D;AAED;;;;GAIG;AACH,mCAFa,OAAO,wBAAwB,EAAE,iBAAiB,EAAE,CAIhE;AAED;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,SAAS,CAIxE;AAED;;;;;GAKG;AACH,6CAHW,MAAM,GACJ,OAAO,CAInB"}

package/src/shade/renderer/particles/graph/particle_group_library.js CHANGED Viewed

@@ -38,9 +38,14 @@ export function register_particle_group(group) {
     // The group node itself, and the two boundary blocks its body is wired to: a view that opens the
     // group draws those, and everything drawn needs a box generated for it.
-    PARTICLE_NODE_REGISTRY.addNode(group.description);
-    PARTICLE_NODE_REGISTRY.addNode(group.inputNode.description);
-    PARTICLE_NODE_REGISTRY.addNode(group.outputNode.description);
+    // Stock types leave holes when removed. Allocate after their highest ID rather than relying
+    // on NodeDescription's global counter, which counts constructions, not reserved IDs.
+    let id = Math.max(...PARTICLE_NODE_REGISTRY.nodes.keys()) + 1;
+    for (const description of [group.description, group.inputNode.description, group.outputNode.description]) {
+        description.id = id++;
+        PARTICLE_NODE_REGISTRY.addNode(description);
+    }
     return group;
 }

package/src/shade/renderer/particles/graph/particle_node_parameters.d.ts CHANGED Viewed

@@ -91,8 +91,6 @@ export const PARTICLE_PARAMETER_KIND: Readonly<{
     ENUM: "enum";
     /** one to four lane selectors in `[0, 4)`, one per output lane */
     SWIZZLE: "swizzle";
-    /** a non-negative integer — a curve handle */
-    INTEGER: "integer";
     /**
      * an {@link ../../../../engine/animation/curve/AnimationCurve.js AnimationCurve}, as the
      * `{keys: [...]}` record that class writes and reads

package/src/shade/renderer/particles/graph/particle_node_parameters.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"particle_node_parameters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_parameters.js"],"names":[],"mappings":"~~AAwMA~~;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAwBD;;;;;;GAMG;AACH,+CAJW,MAAM,GACJ,qBAAqB,EAAE,CAcnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uDANW,MAAM;IAEyD,MAAM,GAArE,OAAO,6BAA6B,EAAE,cAAc;IAElD,MAAM,CAmBlB;AAED;;;;GAIG;AACH,2CAFa,MAAM;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,uBAAuB,CAAC;IAAC,UAAU,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAAC,CAOrI;;;;~~sCA7RS~~,MAAM;AApBhB;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH;IACI,0FAA0F;;IAE1F,kFAAkF;;IAElF,mFAAmF;;IAEnF,2EAA2E;;IAE3E,kEAAkE;;IAElE~~,8CAA8C;;IAE9C~~;;;OAGG;;IAEH;;;OAGG;;GAEJ;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,gDAFU,MAAM,EAAE,CAWf;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,MAAM;EAI7B;AAEF;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,qBAAqB,EAAE;~~EA8F7C~~;;;;;;;;~~UA7IW~~,MAAM;;;;UACN,MAAM;;;;;;;;;;YAGC,MAAM;;;;;;;;YACb,OAAO;;;;kBAIP,MAAM"}
1	+ {"version":3,"file":"particle_node_parameters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_parameters.js"],"names":[],"mappings":"AA+LA;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAwBD;;;;;;GAMG;AACH,+CAJW,MAAM,GACJ,qBAAqB,EAAE,CAcnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uDANW,MAAM;IAEyD,MAAM,GAArE,OAAO,6BAA6B,EAAE,cAAc;IAElD,MAAM,CAmBlB;AAED;;;;GAIG;AACH,2CAFa,MAAM;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,uBAAuB,CAAC;IAAC,UAAU,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAAC,CAOrI;;;;sCApRS,MAAM;AApBhB;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH;IACI,0FAA0F;;IAE1F,kFAAkF;;IAElF,mFAAmF;;IAEnF,2EAA2E;;IAE3E,kEAAkE;;IAElE;;;OAGG;;IAEH;;;OAGG;;GAEJ;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,gDAFU,MAAM,EAAE,CAWf;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,MAAM;EAI7B;AAEF;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,qBAAqB,EAAE;EAuF7C;;;;;;;;UAtIW,MAAM;;;;UACN,MAAM;;;;;;;;;;YAGC,MAAM;;;;;;;;YACb,OAAO;;;;kBAIP,MAAM"}

package/src/shade/renderer/particles/graph/particle_node_parameters.js CHANGED Viewed

@@ -37,8 +37,6 @@ export const PARTICLE_PARAMETER_KIND = Object.freeze({
     ENUM: "enum",
     /** one to four lane selectors in `[0, 4)`, one per output lane */
     SWIZZLE: "swizzle",
-    /** a non-negative integer — a curve handle */
-    INTEGER: "integer",
     /**
      * an {@link ../../../../engine/animation/curve/AnimationCurve.js AnimationCurve}, as the
      * `{keys: [...]}` record that class writes and reads
@@ -172,13 +170,6 @@ export const PARTICLE_NODE_PARAMETER_SCHEMA = Object.freeze({
         description: "Which input lane each output lane reads; one to four of them, and that count is the result's width.",
     }],
-    curve: [{
-        name: "handle",
-        kind: PARTICLE_PARAMETER_KIND.INTEGER,
-        default: 0,
-        description: "Row of the animation-curve table to sample.",
-    }],
     curveLiteral: [{
         name: "curve",
         kind: PARTICLE_PARAMETER_KIND.CURVE,

package/src/shade/renderer/particles/graph/particle_node_presentation.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"particle_node_presentation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_presentation.js"],"names":[],"mappings":"~~AA2UA~~;;;;;;;GAOG;AACH,iDAHW,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAIvD;~~AA3SD~~;;;;;;;;GAQG;AACH;QAFiB,MAAM,GAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;~~EAwRjE~~"}
1	+ {"version":3,"file":"particle_node_presentation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_presentation.js"],"names":[],"mappings":"AAiUA;;;;;;;GAOG;AACH,iDAHW,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAIvD;AAjSD;;;;;;;;GAQG;AACH;QAFiB,MAAM,GAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;EA8QjE"}

package/src/shade/renderer/particles/graph/particle_node_presentation.js CHANGED Viewed

@@ -301,17 +301,7 @@ export const PARTICLE_NODE_PRESENTATION = Object.freeze({
     },
     // --- ramps ---
-    // Two ways to have a curve, and the labels say which is which. The table one came first and was
-    // called just "Curve"; it is renamed here rather than leaving the new one to explain itself,
-    // because "the one that samples the host's table" is the surprising half of the pair and the
-    // one an author has to have decided to want.
-    curve: {
-        label: "Curve Table",
-        icon: `M5 18C10 18 9 6 19 6 ${dot(5, 18, 1.6)} ${dot(19, 6, 1.6)}`,
-        help: "sample a row of the host's animation-curve table at t",
-    },
     curveLiteral: {
-        // the same curve with its keys on it: this one is the curve rather than a handle to one
         label: "Curve",
         icon: `M4 19C10 19 8 5 20 5 ${dot(4, 19, 1.8)} ${dot(12, 12, 1.8)} ${dot(20, 5, 1.8)}`,
         help: "a curve of your own, written into the program: t in, its value out",

package/src/shade/renderer/particles/graph/particle_ramp.d.ts CHANGED Viewed

@@ -128,14 +128,8 @@ export function roll_out_particle_gradient(g: import("./ParticleGroupBuilder.js"
  * {@link ./ParticleNodeDescription.js ParticleNodeDescription#expand}), and this is what they expand
  * *into*: stock nodes, which is to say VM instructions, with the curve rolled out along them.
  *
- * ## Rolled out, not sampled
- *
- * There is a `CURVE` opcode, and it is not this. That one samples a row of the animation-curve table
- * a host uploads, which is the right answer for a curve an author is dragging around at runtime and
- * the wrong one for a curve that is part of the effect: it costs a table, a row, a handle to keep in
- * step with it, and a texture fetch. A ramp with four stops rolls out to about twenty instructions
- * of pure arithmetic, needs nothing from the host, and constant-folds where an author has left a
- * segment flat.
+ * A ramp with four stops rolls out to about twenty instructions of pure arithmetic, needs nothing
+ * from the host, and constant-folds where an author has left a segment flat.
  *
  * ## How a piecewise function becomes straight-line code
  *

package/src/shade/renderer/particles/graph/particle_ramp.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"particle_ramp.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_ramp.js"],"names":[],"mappings":"~~AA2FA~~;;;;;;;;GAQG;AACH,0CAFa,sBAAsB,CASlC;AAED;;;;GAIG;AACH,6CAFa,oBAAoB,EAAE,CAOlC;AAUD;;;;;;;;;GASG;AACH,+CAFa,OAAO,CAanB;AAED;;;;;GAKG;AACH,kDAFa,OAAO,CAanB;AAED;;;;;;;;;GASG;AACH,2CAHW,sBAAsB,GACpB,gBAAgB,EAAE,CAI9B;AAED;;;;;;GAMG;AACH,gDAHW,sBAAsB,GACpB,cAAc,CAQ1B;AAED;;;;;GAKG;AACH,qDAHW,cAAc,GACZ,sBAAsB,CAWlC;AAED;;;;;GAKG;AACH,+CAHW,oBAAoB,EAAE,GACpB,oBAAoB,EAAE,CAMlC;AAED;;;;;;;GAOG;AACH,gDAJW,oBAAoB,EAAE,KACtB,MAAM,GACJ,MAAM,EAAE,CAsBpB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CALW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,sBAAsB,OA+ChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CANW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,oBAAoB,EAAE,cACtB,MAAM,OA8BhB;~~AA/YD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG~~;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AACH,iDAFU,MAAM,CAEoC;;;;;;UAxBtC,MAAM;WACN,MAAM;eACN,MAAM;gBACN,MAAM;;;;;qCAMP;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;CAAC;;;;;;mCAQ1B;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC;+~~BAlFjB~~,sDAAsD"}
1	+ {"version":3,"file":"particle_ramp.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_ramp.js"],"names":[],"mappings":"AAqFA;;;;;;;;GAQG;AACH,0CAFa,sBAAsB,CASlC;AAED;;;;GAIG;AACH,6CAFa,oBAAoB,EAAE,CAOlC;AAUD;;;;;;;;;GASG;AACH,+CAFa,OAAO,CAanB;AAED;;;;;GAKG;AACH,kDAFa,OAAO,CAanB;AAED;;;;;;;;;GASG;AACH,2CAHW,sBAAsB,GACpB,gBAAgB,EAAE,CAI9B;AAED;;;;;;GAMG;AACH,gDAHW,sBAAsB,GACpB,cAAc,CAQ1B;AAED;;;;;GAKG;AACH,qDAHW,cAAc,GACZ,sBAAsB,CAWlC;AAED;;;;;GAKG;AACH,+CAHW,oBAAoB,EAAE,GACpB,oBAAoB,EAAE,CAMlC;AAED;;;;;;;GAOG;AACH,gDAJW,oBAAoB,EAAE,KACtB,MAAM,GACJ,MAAM,EAAE,CAsBpB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CALW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,sBAAsB,OA+ChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CANW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,oBAAoB,EAAE,cACtB,MAAM,OA8BhB;AAzYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AACH,iDAFU,MAAM,CAEoC;;;;;;UAxBtC,MAAM;WACN,MAAM;eACN,MAAM;gBACN,MAAM;;;;;qCAMP;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;CAAC;;;;;;mCAQ1B;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC;+BA5EjB,sDAAsD"}

package/src/shade/renderer/particles/graph/particle_ramp.js CHANGED Viewed

@@ -11,14 +11,8 @@ import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurv
  * {@link ./ParticleNodeDescription.js ParticleNodeDescription#expand}), and this is what they expand
  * *into*: stock nodes, which is to say VM instructions, with the curve rolled out along them.
  *
- * ## Rolled out, not sampled
- *
- * There is a `CURVE` opcode, and it is not this. That one samples a row of the animation-curve table
- * a host uploads, which is the right answer for a curve an author is dragging around at runtime and
- * the wrong one for a curve that is part of the effect: it costs a table, a row, a handle to keep in
- * step with it, and a texture fetch. A ramp with four stops rolls out to about twenty instructions
- * of pure arithmetic, needs nothing from the host, and constant-folds where an author has left a
- * segment flat.
+ * A ramp with four stops rolls out to about twenty instructions of pure arithmetic, needs nothing
+ * from the host, and constant-folds where an author has left a segment flat.
  *
  * ## How a piecewise function becomes straight-line code
  *

package/src/shade/renderer/particles/graph/validate_particle_graph.js CHANGED Viewed

@@ -231,12 +231,6 @@ function check_parameters(node, description, layout, error) {
                 }
                 break;
-            case PARTICLE_PARAMETER_KIND.INTEGER:
-                if (!Number.isInteger(value) || value < 0) {
-                    error(node.id, `Parameter '${parameter.name}' must be a non-negative whole number.`);
-                }
-                break;
             // A curve and a gradient are the only parameters with a shape underneath them, and both
             // are written out into instructions rather than read at runtime — so a malformed one is
             // a compile that throws rather than a value that misbehaves, and it is worth catching

package/src/shade/renderer/particles/graph_particles_avboit.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"~~AAqCA~~;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,~~CAoG~~/E"}
1	+ {"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA2G/E"}

package/src/shade/renderer/particles/graph_particles_avboit.js CHANGED Viewed

@@ -6,7 +6,9 @@ import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/sha
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
 import {
-    PARTICLE_AVBOIT_DRAW_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE,
     PARTICLE_AVBOIT_DRAW_RESOURCES,
 } from "./shaders/shader_particle_avboit_draw.js";
 import {
@@ -268,7 +270,7 @@ export function graph_particle_avboit_draw({
         // allowed because the attachment is read-only.
         const pass_encoder = encoder.constructRenderPass({
             label: "Particle AVBOIT Draw",
-            pipeline: PARTICLE_AVBOIT_DRAW_PIPELINE,
+            pipeline: PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
             bindings,
             colorAttachments: [
                 attachment(data.color),
@@ -281,8 +283,15 @@ export function graph_particle_avboit_draw({
                 depthReadOnly: true,
             },
         });
-        pass_encoder.drawIndirect(resources.get(data.draw_args), 0);
-        pass_encoder.end();
+        // All three use the alive list; their vertex stages select disjoint particle groups.
+        // Premultiplied particles can both cover and emit, so they retain the general pipeline.
+        const args = resources.get(data.draw_args);
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE));
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE));
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.end();
     }
     const pass_data = {};