@woosh/meep-engine 3.49.0 → 3.50.0

package/src/engine/physics/narrowphase/rigid_subject_pose.js

@@ -1,54 +1,14 @@
-import { m4_decompose_array } from "../../../core/geom/3d/mat4/m4_decompose_array.js";
+import { m4_decompose_rigid_array } from "../../../core/geom/3d/mat4/m4_decompose_rigid_array.js";
 import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
 import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
 
-/**
- * How far a TransformedShape3D's matrix may be from a rigid motion — column lengths off 1, columns off
- * perpendicular — and still be treated as one. A matrix handed over in float32 arrives rounded at
- * about 1e-7, an exact rotation included.
- * @type {number}
- */
-const RIGID_TOLERANCE = 1e-5;
-
-/** Translation / rotation / scale of the wrapper matrix last passed to {@link decompose_rigid}. */
+/** Translation / rotation of the wrapper matrix last passed to {@link m4_decompose_rigid_array}. */
 const wrapper_translation = new Float64Array(3);
 const wrapper_rotation = new Float64Array(4);
-const wrapper_scale = new Float64Array(3);
 
 /** The wrapper's translation rotated into the world, by {@link rigid_subject_pose}. */
 const wrapper_offset = new Float64Array(3);
 
-/**
- * Whether an affine matrix (column-major) is a rigid motion, leaving its translation and rotation in
- * {@link wrapper_translation} / {@link wrapper_rotation}.
- *
- * @param {ArrayLike<number>} m
- * @returns {boolean}
- */
-function decompose_rigid(m) {
-    if (m[3] !== 0 || m[7] !== 0 || m[11] !== 0 || m[15] !== 1) {
-        return false;
-    }
-
-    // a reflection comes back as a negative x scale, so it fails here too
-    m4_decompose_array(m, wrapper_translation, 0, wrapper_rotation, 0, wrapper_scale, 0);
-
-    if (Math.abs(wrapper_scale[0] - 1) > RIGID_TOLERANCE
-        || Math.abs(wrapper_scale[1] - 1) > RIGID_TOLERANCE
-        || Math.abs(wrapper_scale[2] - 1) > RIGID_TOLERANCE) {
-        return false;
-    }
-
-    // the decomposition assumes no shear; a sheared matrix has unit columns that are not perpendicular
-    const d01 = m[0] * m[4] + m[1] * m[5] + m[2] * m[6];
-    const d02 = m[0] * m[8] + m[1] * m[9] + m[2] * m[10];
-    const d12 = m[4] * m[8] + m[5] * m[9] + m[6] * m[10];
-
-    return Math.abs(d01) <= RIGID_TOLERANCE
-        && Math.abs(d02) <= RIGID_TOLERANCE
-        && Math.abs(d12) <= RIGID_TOLERANCE;
-}
-
 /**
  * The world pose of what a rigid `TransformedShape3D` wraps, given the wrapper's own world pose.
  *
@@ -75,7 +35,7 @@ function decompose_rigid(m) {
  *   is untouched when it is not
  */
 export function rigid_subject_pose(out, shape, px, py, pz, qx, qy, qz, qw) {
-    if (shape.isTransformedShape3D !== true || shape.subject === null || !decompose_rigid(shape.transform)) {
+    if (shape.isTransformedShape3D !== true || shape.subject === null || !m4_decompose_rigid_array(shape.transform, wrapper_translation, 0, wrapper_rotation, 0)) {
         return false;
     }
 

package/src/generation/markers/actions/terrain/MarkerNodeActionPaintTerrain.js

@@ -247,16 +247,16 @@ export class MarkerNodeActionPaintTerrain extends MarkerNodeAction {
 
     initialize(grid, ecd, seed) {
         // find layer index
-        const terrain = ecd.getAnyComponent(Terrain);
+        const terrain = ecd.getAnyComponentInstance(Terrain);
 
-        if (terrain.component === null) {
+        if (terrain === null) {
             throw new Error('No terrain present');
         }
 
-        this._terrain = terrain.component;
+        this._terrain = terrain;
 
         // bind splats
-        this._splat_map = terrain.component.splat;
+        this._splat_map = terrain.splat;
 
         this._layer_index = -1;
 

package/src/shade/device/ShadeGPUCommandContext.d.ts

@@ -163,6 +163,26 @@ export class ShadeGPUCommandContext {
             size: number;
         };
     }): ShadeGPUComputePassEncoder;
+    /**
+     * Set `pipeline` and its bindings on a compute pass that is already open, so that several
+     * pipelines can dispatch in one pass.
+     *
+     * @param {Object} options
+     * @param {ShadeGPUComputePassEncoder} options.pass
+     * @param {ComputePipelineDescriptor} options.pipeline
+     * @param {GPUBindingResource[][]} [options.bindings]
+     * @param {{buffer: BinaryBuffer, offset: number, size: number}} [options.immediate] see {@link constructComputePass}
+     */
+    bindComputePipeline({ pass, pipeline, bindings, immediate }: {
+        pass: ShadeGPUComputePassEncoder;
+        pipeline: ComputePipelineDescriptor;
+        bindings?: GPUBindingResource[][];
+        immediate?: {
+            buffer: BinaryBuffer;
+            offset: number;
+            size: number;
+        };
+    }): void;
     /**
      * Begins a labeled debug group containing subsequent commands.
      * @see https://gpuweb.github.io/gpuweb/#debug-markers

package/src/shade/device/ShadeGPUCommandContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeGPUCommandContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/ShadeGPUCommandContext.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ShadeGPUCommandContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/ShadeGPUCommandContext.js"],"names":[],"mappings":"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"}

package/src/shade/device/ShadeGPUCommandContext.js

@@ -450,21 +450,38 @@ export class ShadeGPUCommandContext {
             pass_descriptor.label = pipeline.label;
         }
 
-        const graphics = this.#graphics;
-
         const pass = this.beginComputePass(pass_descriptor);
 
-        const gpu_pipeline = graphics.compute_pipelines.obtain(pipeline);
+        this.bindComputePipeline({ pass, pipeline, bindings, immediate });
 
-        pass.setPipeline(gpu_pipeline);
+        // console.warn(`cmd.constructComputePass(${pass_descriptor.label})`)
 
-        pass.record_pipeline(pipeline);
+        return pass;
+    }
 
-        graphics.setPipelineBindings(pass, pipeline, bindings, immediate);
+    /**
+     * Set `pipeline` and its bindings on a compute pass that is already open, so that several
+     * pipelines can dispatch in one pass.
+     *
+     * @param {Object} options
+     * @param {ShadeGPUComputePassEncoder} options.pass
+     * @param {ComputePipelineDescriptor} options.pipeline
+     * @param {GPUBindingResource[][]} [options.bindings]
+     * @param {{buffer: BinaryBuffer, offset: number, size: number}} [options.immediate] see {@link constructComputePass}
+     */
+    bindComputePipeline({
+                            pass,
+                            pipeline,
+                            bindings = [],
+                            immediate
+                        }) {
+        const graphics = this.#graphics;
 
-        // console.warn(`cmd.constructComputePass(${pass_descriptor.label})`)
+        pass.setPipeline(graphics.compute_pipelines.obtain(pipeline));
 
-        return pass;
+        pass.record_pipeline(pipeline);
+
+        graphics.setPipelineBindings(pass, pipeline, bindings, immediate);
     }
 
     /**

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.d.ts

@@ -19,15 +19,19 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase impleme
      */
     constructor(encoder: SoftwareGPUCommandEncoder, descriptor?: GPUComputePassDescriptor);
     /**
-     * One entry per {@link dispatchWorkgroups}, in encode order.
+     * One entry per {@link dispatchWorkgroups} or {@link dispatchWorkgroupsIndirect}, in encode order.
+     * An indirect one's `group_counts` is `[-1, -1, -1]`, and it carries the `indirect_buffer` and
+     * `indirect_offset` its counts are read from.
      *
-     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number]}[]}
+     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number], indirect_buffer?: GPUBuffer, indirect_offset?: number}[]}
      */
     dispatches: {
         pipeline: GPUComputePipeline | null;
         bind_groups: GPUBindGroup[];
         dynamic_offsets: number[][];
         group_counts: [number, number, number];
+        indirect_buffer?: GPUBuffer;
+        indirect_offset?: number;
     }[];
     /**
      * The descriptor this pass was begun with, retained so a test can read what the host asked for —

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUComputePassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUComputePassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,oFAFgB,qBAAqB;IA6DjC;;;OAGG;IACH,uFAQC;IAtED;;;;OAIG;IACH,YAFU;QAAC,QAAQ,EAAE,qBAAmB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAC,EAAE,CAEjI;IAEhB;;;;;OAKG;IACH,qCAAW;IAoCX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,gDAIC;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IA4DD;;;;OAIG;IACH,sBAJW,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,wEAFW,MAAM,QAsBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;;CANtE;sCA7RqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUComputePassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUComputePassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,oFAFgB,qBAAqB;IA+DjC;;;OAGG;IACH,uFAQC;IAxED;;;;;;OAMG;IACH,YAFU;QAAC,QAAQ,EAAE,qBAAmB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,eAAe,CAAC,YAAY;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAC,EAAE,CAExL;IAEhB;;;;;OAKG;IACH,qCAAW;IAoCX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,gDAIC;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IA4DD;;;;OAIG;IACH,sBAJW,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,wEAFW,MAAM,QAwBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;;CANtE;sCAjSqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.js

@@ -20,9 +20,11 @@ import { write_pass_timestamp } from "./write_pass_timestamp.js";
  */
 export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
     /**
-     * One entry per {@link dispatchWorkgroups}, in encode order.
+     * One entry per {@link dispatchWorkgroups} or {@link dispatchWorkgroupsIndirect}, in encode order.
+     * An indirect one's `group_counts` is `[-1, -1, -1]`, and it carries the `indirect_buffer` and
+     * `indirect_offset` its counts are read from.
      *
-     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number]}[]}
+     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number], indirect_buffer?: GPUBuffer, indirect_offset?: number}[]}
      */
     dispatches = [];
 
@@ -251,11 +253,13 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
         this.#encoder.notify_pass_uses([indirect_buffer]);
 
         // The group counts live in a buffer a shader wrote, which nothing here executed — recording
-        // a count read out of it would be fiction, so the entry says what it is.
+        // a count read out of it would be fiction, so the entry says what it is, and where they live.
         this.dispatches.push({
             pipeline: this.#pipeline,
             ...this.#snapshot_bindings(),
             group_counts: [-1, -1, -1],
+            indirect_buffer,
+            indirect_offset,
         });
     }
 

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/avboit/main.js"],"names":[],"mappings":"AA+RA,uCAwlBC;8BAn1BY,OAAO,yCAAyC,EAAE,eAAe"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/avboit/main.js"],"names":[],"mappings":"AAkSA,uCAwlBC;8BAp1BY,OAAO,yCAAyC,EAAE,eAAe"}

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

@@ -19,8 +19,7 @@ import { ShadeDrawSide } from "../../renderer/material/ShadeDrawSide.js";
 import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
 import { TransparencyMode } from "../../renderer/material/TransparencyMode.js";
 import { shader_avboit_build_warp } from "../../renderer/rasterize/native/avboit/shader_avboit_build_warp.js";
-import { shader_avboit_draw_brick4 } from "../../renderer/rasterize/native/avboit/shader_avboit_draw_brick4.js";
-import { shader_avboit_draw_ibl } from "../../renderer/rasterize/native/avboit/shader_avboit_draw_ibl.js";
+import { shader_avboit_draw } from "../../renderer/rasterize/native/avboit/shader_avboit_draw.js";
 import { shader_avboit_integrate } from "../../renderer/rasterize/native/avboit/shader_avboit_integrate.js";
 import { shader_avboit_occupancy } from "../../renderer/rasterize/native/avboit/shader_avboit_occupancy.js";
 import { shader_avboit_resolve } from "../../renderer/rasterize/native/avboit/shader_avboit_resolve.js";
@@ -30,6 +29,9 @@ import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 import { place_primitive, remove_primitive } from "../../renderer/scene/rows/place_primitive.js";
 import { Scene } from "../../renderer/scene/Scene.js";
 import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";
+import { INDIRECT_LIGHTING } from "../../renderer/INDIRECT_LIGHTING.js";
+import { ShaderSwitchSet } from "../../renderer/shader/compiler/ShaderSwitchSet.js";
+import { STANDARD_MATERIAL_TEMPLATE } from "../../renderer/material/standard/STANDARD_MATERIAL_TEMPLATE.js";
 import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
 import { load_default_environment } from "../load_default_environment.js";
 
@@ -117,10 +119,11 @@ const AVBOIT_MODULES = [
     ["splat / vertex", () => shader_avboit_splat.pipeline.vertex.module.code],
     ["splat / fragment", () => shader_avboit_splat.pipeline.fragment.module.code],
     ["integrate", () => shader_avboit_integrate.descriptor.source],
-    ["draw IBL / vertex", () => shader_avboit_draw_ibl.pipeline.vertex.module.code],
-    ["draw IBL / fragment", () => shader_avboit_draw_ibl.pipeline.fragment.module.code],
-    ["draw Brick4 / vertex", () => shader_avboit_draw_brick4.pipeline.vertex.module.code],
-    ["draw Brick4 / fragment", () => shader_avboit_draw_brick4.pipeline.fragment.module.code],
+    ["draw / vertex", () => shader_avboit_draw.pipeline.vertex.module.code],
+    ["draw IBL / fragment", () => shader_avboit_draw.pipeline.fragment.module.code],
+    ["draw Brick4 / fragment", () => shader_avboit_draw
+        .variant(ShaderSwitchSet.EMPTY.with(INDIRECT_LIGHTING, ShadeIndirectLightingMode.Brick4))
+        .template_pipeline_descriptor(STANDARD_MATERIAL_TEMPLATE).fragment.module.code],
     ["resolve", () => shader_avboit_resolve.descriptor.source],
 ];
 

package/src/shade/playground/particle_ecs/README.md

@@ -127,6 +127,26 @@ Two things to know before editing one:
   same accumulators. Switch the renderer to MBOIT and the particles vanish while everything else
   stays: MBOIT is the legacy path and has no particle channel.
 
+### The wind
+
+The fire burns in a gusty breeze: the **Wind**, **Gust** and **Heading** sliders (or `?wind=`,
+`?gust=`, `?heading=` — m/s, m/s, degrees; `?wind=0&gust=0` is the still night). `bonfire_wind.js`
+writes them onto the scene's published wind field every frame as its far field, through
+`GPUSceneWind#set_far_velocity`, with the gust from `GlobalFluidEffector`'s model. There is no fluid
+on this page: with no cascades every read of the field is that far field, exactly.
+
+The effects read it with the node library's `wind` (`SAMPLE_WIND`), each the way it should:
+
+- **the flame leans**: its position integrates the wind at half strength on top of its own velocity,
+  so the tongues bend over without being blown off the logs;
+- **the embers and the soot are carried**: the wind at full strength, so they stream downwind and
+  scatter as the gust turns;
+- **the smoke's plume bends over as it rises**: its drag, which relaxed it toward still air, relaxes
+  it toward the wind at the particle instead — slowly, so the column leaves the fire upright and
+  goes over further up.
+
+`globalThis.weather` is the `BonfireWind`; `weather.far_velocity` is what was last written.
+
 ### Profiling
 
 <kbd>T</kbd> starts a GPU capture, <kbd>T</kbd> again stops it and saves an `.sgpt`. The status line

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

@@ -108,6 +108,16 @@ export function bonfire_sprite_urls(textures?: object): {
  *   variants *for the whole system* — so an effect that grows past it slows down every effect in the
  *   scene rather than itself. `bonfire.spec.js` pins it.
  *
+ * ## Wind
+ *
+ * All four read the scene's wind at the particle, through the library's `wind` node (`SAMPLE_WIND`).
+ * The flame, the embers and the soot are carried by it: their position integrates
+ * `velocity + gain · wind` while the velocity they store stays their own, with a gain of one for the
+ * embers and the soot and a half for the flame, whose tongues lean rather than blow away. The smoke
+ * already had a drag, and its target was still air; it is the wind now, so the plume bends over as
+ * it rises. In still air every one of them is the effect it was before. The page writes the wind —
+ * see `bonfire_wind.js`.
+ *
  * The turbulence in all four is three decorrelated `simplex3` samples read as a vector, at a point
  * that drifts with time so the field scrolls through the rising column. Deliberately not the
  * library's `curl3`, which is twelve samples for a divergence-free field: over a metre of flame

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

@@ -1 +1 @@
-{"version":3,"file":"bonfire_effects.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_ecs/bonfire_effects.js"],"names":[],"mappings":"AAyGA;;GAEG;AACH,yCAFa,6BAA6B,CAUzC;AAED;;;;;;;GAOG;AACH,8CALW,MAAM,SACN,MAAM,GAEJ,sBAAsB,CAIlC;AAED;;;;GAIG;AACH;QAFoB,MAAM,GAAE,sBAAsB;EAIjD;AAED;;;;;;;;;;;GAWG;AACH,mDALW,sBAAsB,YACtB,MAAM,GAAC,IAAI,GAET,cAAc,GAAC,IAAI,CAY/B;AAED;;;;;;;;;GASG;AACH;IANkC,KAAK,GAA5B,MAAM,GAAC,IAAI;IACY,KAAK,GAA5B,MAAM,GAAC,IAAI;IACY,KAAK,GAA5B,MAAM,GAAC,IAAI;IACY,IAAI,GAA3B,MAAM,GAAC,IAAI;IACT;IAAC,KAAK,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAC,CAcxG;AAED;;;;;;GAMG;AACH,+CAHW,MAAM;QACG,MAAM,GAAE,MAAM,GAAC,IAAI;EAStC;AA7LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH;;;;;;;GAOG;AACH;QAFiB,MAAM,GAAE,MAAM;EAO5B;AAEH;;;;;GAKG;AACH,mCAFU,MAAM,EAAE,CAEsE;8CA1FjF,wEAAwE;uCAExC,+DAA+D;+BADvE,0DAA0D"}
+{"version":3,"file":"bonfire_effects.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_ecs/bonfire_effects.js"],"names":[],"mappings":"AAmHA;;GAEG;AACH,yCAFa,6BAA6B,CAUzC;AAED;;;;;;;GAOG;AACH,8CALW,MAAM,SACN,MAAM,GAEJ,sBAAsB,CAIlC;AAED;;;;GAIG;AACH;QAFoB,MAAM,GAAE,sBAAsB;EAIjD;AAED;;;;;;;;;;;GAWG;AACH,mDALW,sBAAsB,YACtB,MAAM,GAAC,IAAI,GAET,cAAc,GAAC,IAAI,CAY/B;AAED;;;;;;;;;GASG;AACH;IANkC,KAAK,GAA5B,MAAM,GAAC,IAAI;IACY,KAAK,GAA5B,MAAM,GAAC,IAAI;IACY,KAAK,GAA5B,MAAM,GAAC,IAAI;IACY,IAAI,GAA3B,MAAM,GAAC,IAAI;IACT;IAAC,KAAK,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAC,CAcxG;AAED;;;;;;GAMG;AACH,+CAHW,MAAM;QACG,MAAM,GAAE,MAAM,GAAC,IAAI;EAStC;AAvMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH;;;;;;;GAOG;AACH;QAFiB,MAAM,GAAE,MAAM;EAO5B;AAEH;;;;;GAKG;AACH,mCAFU,MAAM,EAAE,CAEsE;8CApGjF,wEAAwE;uCAExC,+DAA+D;+BADvE,0DAA0D"}

package/src/shade/playground/particle_ecs/bonfire_effects.js

@@ -55,6 +55,16 @@ import soot_json from "./effects/soot.json";
  *   variants *for the whole system* — so an effect that grows past it slows down every effect in the
  *   scene rather than itself. `bonfire.spec.js` pins it.
  *
+ * ## Wind
+ *
+ * All four read the scene's wind at the particle, through the library's `wind` node (`SAMPLE_WIND`).
+ * The flame, the embers and the soot are carried by it: their position integrates
+ * `velocity + gain · wind` while the velocity they store stays their own, with a gain of one for the
+ * embers and the soot and a half for the flame, whose tongues lean rather than blow away. The smoke
+ * already had a drag, and its target was still air; it is the wind now, so the plume bends over as
+ * it rises. In still air every one of them is the effect it was before. The page writes the wind —
+ * see `bonfire_wind.js`.
+ *
  * The turbulence in all four is three decorrelated `simplex3` samples read as a vector, at a point
  * that drifts with time so the field scrolls through the rising column. Deliberately not the
  * library's `curl3`, which is twelve samples for a divergence-free field: over a metre of flame

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

@@ -0,0 +1,48 @@
+/**
+ * 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)`.
+ *
+ * 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.
+ *
+ * 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
+ * flame's at half strength — and the smoke's drag relaxes it toward the wind instead of still air.
+ */
+export class BonfireWind {
+    /**
+     * Steady wind speed, m/s.
+     * @type {number}
+     */
+    speed: number;
+    /**
+     * Which way the steady wind blows, degrees about +Y from +X toward +Z. The default blows across
+     * the page's opening view, from left to right.
+     * @type {number}
+     */
+    heading_degrees: number;
+    /**
+     * Peak gust on top of the wind, m/s per axis — `GlobalFluidEffector#gust`'s meaning.
+     * @type {number}
+     */
+    gust: number;
+    /**
+     * `v_far(t)` as last written.
+     * @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.
+     *
+     * @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

@@ -0,0 +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"}

package/src/shade/playground/particle_ecs/bonfire_wind.js

@@ -0,0 +1,83 @@
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { GlobalFluidEffector } from "../../../engine/physics/fluid/effector/GlobalFluidEffector.js";
+
+/**
+ * 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)`.
+ *
+ * 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.
+ *
+ * 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
+ * flame's at half strength — and the smoke's drag relaxes it toward the wind instead of still air.
+ */
+export class BonfireWind {
+    /**
+     * Steady wind speed, m/s.
+     * @type {number}
+     */
+    speed = 2;
+
+    /**
+     * Which way the steady wind blows, degrees about +Y from +X toward +Z. The default blows across
+     * the page's opening view, from left to right.
+     * @type {number}
+     */
+    heading_degrees = -38;
+
+    /**
+     * Peak gust on top of the wind, m/s per axis — `GlobalFluidEffector#gust`'s meaning.
+     * @type {number}
+     */
+    gust = 1.5;
+
+    /**
+     * The gust model, used for nothing else.
+     * @type {GlobalFluidEffector}
+     */
+    #weather = new GlobalFluidEffector();
+
+    /** @type {Float64Array} */
+    #gust_now = new Float64Array(3);
+
+    /**
+     * `v_far(t)` as last written.
+     * @type {Float64Array}
+     */
+    far_velocity = new Float64Array(3);
+
+    constructor() {
+        // quicker than a cloth's breeze: a fire in a gusty night
+        this.#weather.gust_period = 3;
+    }
+
+    /**
+     * 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.
+     *
+     * @param {number} dt seconds
+     * @param {import("../../renderer/wind/GPUSceneWind.js").GPUSceneWind} wind_field
+     */
+    blow(dt, wind_field) {
+        const weather = this.#weather;
+        const gust = this.#gust_now;
+
+        weather.gust = this.gust;
+        weather.advance(dt);
+        weather.compute_gust(gust);
+
+        const heading = this.heading_degrees * DEG_TO_RAD;
+        const far = this.far_velocity;
+
+        far[0] = this.speed * Math.cos(heading) + gust[0];
+        far[1] = gust[1];
+        far[2] = this.speed * Math.sin(heading) + gust[2];
+
+        wind_field.set_far_velocity(far);
+    }
+}