@woosh/meep-engine 3.45.0 → 3.47.0

package/src/shade/renderer/shader/ImageShader.js

@@ -1,219 +1,231 @@
-import { assert } from "../../../core/assert.js";
-import {
-    rp_validate_and_rewrite_for_color_attachments
-} from "../../device/pipeline/rp_validate_and_rewrite_for_color_attachments.js";
-import { create_full_quad_pipeline_descriptor } from "./fullscreen/create_full_quad_pipeline_descriptor.js";
-
-const VALIDATION_ENABLED = true;
-
-/**
- * Full-screen render shader
- */
-export class ImageShader {
-    /**
-     * @type {ShaderDescriptor}
-     */
-    #descriptor
-
-    /**
-     *
-     * @returns {ShaderDescriptor}
-     */
-    get descriptor() {
-        return this.#descriptor;
-    }
-
-    /**
-     * Optional clear values for each target
-     * @type {number[][]}
-     */
-    clear_values = [];
-
-    /**
-     * @type {RenderPipelineDescriptor}
-     */
-    #pipeline;
-
-    /**
-     *
-     * @returns {RenderPipelineDescriptor}
-     */
-    get pipeline() {
-        return this.#pipeline
-    }
-
-    /**
-     *
-     * @returns {boolean}
-     */
-    get isImageShader() {
-        return true;
-    }
-
-    /**
-     *
-     * @param {ShaderDescriptor} descriptor
-     * @param {(ColorTargetState|{clearValue?:number[]})[]} [targets]
-     * @param {DepthStencilState} [depthStencil]
-     */
-    constructor({
-                    descriptor,
-                    targets = [],
-                    depthStencil,
-                }) {
-
-        this.#descriptor = descriptor;
-
-        // process optional clearValue parameter
-        for (let i = 0; i < targets.length; i++) {
-            const target = targets[i];
-
-            const clearValue = target.clearValue;
-            if (clearValue !== undefined) {
-                assert.isArrayLike(clearValue, 'clearValue');
-
-                let sanitizedClearValue = clearValue;
-
-                // we need exactly 4 values according to spec
-
-                const value_count = sanitizedClearValue.length;
-
-                // TODO validate count against number of channels in the target
-
-                if (value_count === 4) {
-                    // correct length
-
-                } else if (value_count < 4) {
-                    // too few
-
-                    sanitizedClearValue = sanitizedClearValue.slice();
-
-                    for (let j = value_count; j < 4; j++) {
-                        // pad with 0
-                        sanitizedClearValue[j] = 0;
-                    }
-                } else if (value_count > 4) {
-                    // too many, drop the remainder
-
-                    sanitizedClearValue = sanitizedClearValue.slice(0, 4);
-
-                }
-
-                this.clear_values[i] = sanitizedClearValue;
-            }
-
-        }
-
-        this.#pipeline = create_full_quad_pipeline_descriptor({
-            label: descriptor.label,
-            fragment_code: descriptor.source,
-            layout: descriptor.resources.generatePipelineLayout(GPUShaderStage.FRAGMENT),
-            targets,
-            depthStencil,
-        });
-    }
-
-    // TODO simplify constructor
-    /**
-     * Utility constructor, matching general Shade API
-     * @param {Object} options
-     * @param {ShaderDescriptor} options.descriptor
-     * @param {ColorTargetState[]} options.targets
-     * @param {DepthStencilState} [options.depthStencil]
-     * @returns {ImageShader}
-     */
-    static from({
-                    descriptor,
-                    targets,
-                    depthStencil,
-                }) {
-
-        return new ImageShader({
-            descriptor,
-            depthStencil,
-            targets
-        });
-    }
-
-    /**
-     * Note the absence of depth target, image shader is a full-screen pass, so depth is not used.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} [bindings] data bindings. It's optional, but in 99.99% of use cases you will want to specify this.
-     * @param {GPURenderPassColorAttachment[]} [colorAttachments] where to draw, these are fragment shader outputs.
-     * @param {GPURenderPassDepthStencilAttachment} [depthStencilAttachment]
-     * @param {GPUTextureFormat[]} [color_formats] optional, if specified will be used to rewrite the pipeline for compatibility
-     * @param {number[]} [viewport] [x0, y0, width, height ]
-     */
-    draw({
-             encoder,
-             bindings = {},
-             colorAttachments = [],
-             depthStencilAttachment,
-             color_formats,
-             viewport
-         }) {
-
-        assert.defined(encoder, 'encoder');
-
-        // TODO I hate the separate color_formats parameter. Make a wrapper around GPURenderPassColorAttachment instead, and have a pointer to the GPUTextureContext in there so we can access the texture format
-
-        const shader_descriptor = this.#descriptor;
-
-        if (VALIDATION_ENABLED) {
-            shader_descriptor.validate_against_device(encoder.device);
-        }
-
-        const resolved_bindings = shader_descriptor.resources.generateBindings(bindings, encoder);
-
-        const immediate = encoder.writeImmediate(shader_descriptor.resources, bindings);
-
-        encoder.pushDebugGroup(shader_descriptor.label);
-
-        let pipeline = this.#pipeline;
-
-        if (color_formats !== undefined) {
-            // potentially rewrite the pipeline to be compatible with output formats
-            // example: rgba8unorm -> rgba16float
-            pipeline = rp_validate_and_rewrite_for_color_attachments(pipeline, color_formats);
-        }
-
-        const pass = encoder.constructRenderPass({
-            pipeline,
-            bindings: resolved_bindings,
-            colorAttachments,
-            depthStencilAttachment,
-            immediate
-        });
-
-        if (viewport !== undefined) {
-            const _x = viewport[0];
-            const _y = viewport[1];
-            const _width = viewport[2];
-            const _height = viewport[3];
-
-            assert.greaterThanOrEqual(_width, 0, 'viewport width must be positive');
-            assert.greaterThanOrEqual(_height, 0, 'viewport width must be positive');
-
-            assert.notNaN(_x, '_x');
-            assert.notNaN(_y, '_y');
-
-
-            pass.setViewport(
-                _x,
-                _y,
-                _width,
-                _height,
-                0,
-                1
-            );
-        }
-
-        pass.draw(3);
-
-        pass.end();
-
-        encoder.popDebugGroup();
-
-    }
+import { assert } from "../../../core/assert.js";
+import {
+    rp_validate_and_rewrite_for_color_attachments
+} from "../../device/pipeline/rp_validate_and_rewrite_for_color_attachments.js";
+import { create_full_quad_pipeline_descriptor } from "./fullscreen/create_full_quad_pipeline_descriptor.js";
+
+const VALIDATION_ENABLED = true;
+
+/**
+ * Full-screen render shader
+ */
+export class ImageShader {
+    /**
+     * @type {ShaderDescriptor}
+     */
+    #descriptor
+
+    /**
+     *
+     * @returns {ShaderDescriptor}
+     */
+    get descriptor() {
+        return this.#descriptor;
+    }
+
+    /**
+     * Optional clear values for each target
+     * @type {number[][]}
+     */
+    clear_values = [];
+
+    /**
+     * @type {RenderPipelineDescriptor}
+     */
+    #pipeline;
+
+    /**
+     * The device this shader last passed {@link ShaderDescriptor#validate_against_device} on, or null:
+     * one check per device rather than one per draw. See `ComputeShader`'s field of the same name.
+     *
+     * @type {GPUDevice|null}
+     */
+    #validated_device = null;
+
+    /**
+     *
+     * @returns {RenderPipelineDescriptor}
+     */
+    get pipeline() {
+        return this.#pipeline
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isImageShader() {
+        return true;
+    }
+
+    /**
+     *
+     * @param {ShaderDescriptor} descriptor
+     * @param {(ColorTargetState|{clearValue?:number[]})[]} [targets]
+     * @param {DepthStencilState} [depthStencil]
+     */
+    constructor({
+                    descriptor,
+                    targets = [],
+                    depthStencil,
+                }) {
+
+        this.#descriptor = descriptor;
+
+        // process optional clearValue parameter
+        for (let i = 0; i < targets.length; i++) {
+            const target = targets[i];
+
+            const clearValue = target.clearValue;
+            if (clearValue !== undefined) {
+                assert.isArrayLike(clearValue, 'clearValue');
+
+                let sanitizedClearValue = clearValue;
+
+                // we need exactly 4 values according to spec
+
+                const value_count = sanitizedClearValue.length;
+
+                // TODO validate count against number of channels in the target
+
+                if (value_count === 4) {
+                    // correct length
+
+                } else if (value_count < 4) {
+                    // too few
+
+                    sanitizedClearValue = sanitizedClearValue.slice();
+
+                    for (let j = value_count; j < 4; j++) {
+                        // pad with 0
+                        sanitizedClearValue[j] = 0;
+                    }
+                } else if (value_count > 4) {
+                    // too many, drop the remainder
+
+                    sanitizedClearValue = sanitizedClearValue.slice(0, 4);
+
+                }
+
+                this.clear_values[i] = sanitizedClearValue;
+            }
+
+        }
+
+        this.#pipeline = create_full_quad_pipeline_descriptor({
+            label: descriptor.label,
+            fragment_code: descriptor.source,
+            layout: descriptor.resources.generatePipelineLayout(GPUShaderStage.FRAGMENT),
+            targets,
+            depthStencil,
+        });
+    }
+
+    // TODO simplify constructor
+    /**
+     * Utility constructor, matching general Shade API
+     * @param {Object} options
+     * @param {ShaderDescriptor} options.descriptor
+     * @param {ColorTargetState[]} options.targets
+     * @param {DepthStencilState} [options.depthStencil]
+     * @returns {ImageShader}
+     */
+    static from({
+                    descriptor,
+                    targets,
+                    depthStencil,
+                }) {
+
+        return new ImageShader({
+            descriptor,
+            depthStencil,
+            targets
+        });
+    }
+
+    /**
+     * Note the absence of depth target, image shader is a full-screen pass, so depth is not used.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {Object} [bindings] data bindings. It's optional, but in 99.99% of use cases you will want to specify this.
+     * @param {GPURenderPassColorAttachment[]} [colorAttachments] where to draw, these are fragment shader outputs.
+     * @param {GPURenderPassDepthStencilAttachment} [depthStencilAttachment]
+     * @param {GPUTextureFormat[]} [color_formats] optional, if specified will be used to rewrite the pipeline for compatibility
+     * @param {number[]} [viewport] [x0, y0, width, height ]
+     */
+    draw({
+             encoder,
+             bindings = {},
+             colorAttachments = [],
+             depthStencilAttachment,
+             color_formats,
+             viewport
+         }) {
+
+        assert.defined(encoder, 'encoder');
+
+        // TODO I hate the separate color_formats parameter. Make a wrapper around GPURenderPassColorAttachment instead, and have a pointer to the GPUTextureContext in there so we can access the texture format
+
+        const shader_descriptor = this.#descriptor;
+
+        const device = encoder.device;
+
+        if (VALIDATION_ENABLED && device !== this.#validated_device) {
+            shader_descriptor.validate_against_device(device);
+
+            this.#validated_device = device;
+        }
+
+        const resolved_bindings = shader_descriptor.resources.generateBindings(bindings, encoder);
+
+        const immediate = encoder.writeImmediate(shader_descriptor.resources, bindings);
+
+        encoder.pushDebugGroup(shader_descriptor.label);
+
+        let pipeline = this.#pipeline;
+
+        if (color_formats !== undefined) {
+            // potentially rewrite the pipeline to be compatible with output formats
+            // example: rgba8unorm -> rgba16float
+            pipeline = rp_validate_and_rewrite_for_color_attachments(pipeline, color_formats);
+        }
+
+        const pass = encoder.constructRenderPass({
+            pipeline,
+            bindings: resolved_bindings,
+            colorAttachments,
+            depthStencilAttachment,
+            immediate
+        });
+
+        if (viewport !== undefined) {
+            const _x = viewport[0];
+            const _y = viewport[1];
+            const _width = viewport[2];
+            const _height = viewport[3];
+
+            assert.greaterThanOrEqual(_width, 0, 'viewport width must be positive');
+            assert.greaterThanOrEqual(_height, 0, 'viewport width must be positive');
+
+            assert.notNaN(_x, '_x');
+            assert.notNaN(_y, '_y');
+
+
+            pass.setViewport(
+                _x,
+                _y,
+                _width,
+                _height,
+                0,
+                1
+            );
+        }
+
+        pass.draw(3);
+
+        pass.end();
+
+        encoder.popDebugGroup();
+
+    }
 }

package/src/shade/renderer/shader/type/WGSLStructField.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { isArrayEqual } from "../../../../core/collection/array/isArrayEqual.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
@@ -181,7 +181,7 @@ export class WGSLStructField {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix3(
             computeStringHash(this.name),
             this.offset,
             this.type.hash()

package/src/shade/renderer/shader/type/WebGPUArray.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { CodeChunk } from "../compiler/CodeChunk.js";
 import { f32, u32, vec4f, vec4u } from "./WEBGPU_WGSL_PRIMITIVE_TYPES.js";
@@ -61,7 +61,7 @@ export class WebGPUArray extends WebGPUType {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.type.hash(),
             this.count
         );

package/src/shade/renderer/shader/type/WebGPUStruct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH;IAiNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA1QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAqGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IA8GL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BArb0B,iBAAiB;gCAEZ,sBAAsB"}
+{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH;IAmNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA5QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAuGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IA8GL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BAvb0B,iBAAiB;gCAEZ,sBAAsB"}

package/src/shade/renderer/shader/type/WebGPUStruct.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import LineBuilder from "../../../../core/codegen/LineBuilder.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { isArrayEqual } from "../../../../core/collection/array/isArrayEqual.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
@@ -210,11 +211,13 @@ export class WebGPUStruct extends WebGPUType {
     }
 
     hash() {
-        return combine_hash(
-            computeStringHash(this.name),
-            this.#size,
-            this.#align,
-            this.fields.length,
+        return hash_mix2(
+            hash_mix3(
+                computeStringHash(this.name),
+                this.#size,
+                this.#align
+            ),
+            this.fields.length
         );
     }
 

package/src/shade/renderer/texture/ShadeTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/ShadeTexture.js"],"names":[],"mappings":"AAcA;IA4GI;;;;OAIG;IACH,oBAHW,UAAU,GACR,YAAY,CAiBxB;IA/HD,cAAW;IAOX;;;OAGG;IACH,8BAEC;IAED;;;;;;;;;;;;;OAaG;IACH,aAFU,UAAU,GAAC,MAAM,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yDAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;IAED,cAAsB;IAEtB,kBAAqC;IACrC,kBAAqC;IAErC;;;OAGG;IACH,cAFU,iBAAiB,CAEa;IAExC,cAA+B;IAC/B,cAA+B;IAC/B,cAA+B;IAE/B;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,wBAFU,iBAAiB,GAAC,MAAM,CAEgB;IAwBlD,eAWC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAYnB;;CACJ;yBArKY,OAAO,wBAAwB,EAAE,UAAU;yBAC3C,OAAO,iBAAiB,EAAE,UAAU;kCANf,wBAAwB;kCACxB,wBAAwB"}
+{"version":3,"file":"ShadeTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/ShadeTexture.js"],"names":[],"mappings":"AAeA;IA4GI;;;;OAIG;IACH,oBAHW,UAAU,GACR,YAAY,CAiBxB;IA/HD,cAAW;IAOX;;;OAGG;IACH,8BAEC;IAED;;;;;;;;;;;;;OAaG;IACH,aAFU,UAAU,GAAC,MAAM,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yDAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;IAED,cAAsB;IAEtB,kBAAqC;IACrC,kBAAqC;IAErC;;;OAGG;IACH,cAFU,iBAAiB,CAEa;IAExC,cAA+B;IAC/B,cAA+B;IAC/B,cAA+B;IAE/B;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,wBAFU,iBAAiB,GAAC,MAAM,CAEgB;IAwBlD,eAiBC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAYnB;;CACJ;yBA3KY,OAAO,wBAAwB,EAAE,UAAU;yBAC3C,OAAO,iBAAiB,EAAE,UAAU;kCANf,wBAAwB;kCACxB,wBAAwB"}

package/src/shade/renderer/texture/ShadeTexture.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { ShadeTextureFlags } from "./ShadeTextureFlags.js";
 import { TextureFilterType } from "./TextureFilterType.js";
@@ -143,15 +144,21 @@ export class ShadeTexture {
     }
 
     hash() {
-        return combine_hash(
-            optional_hash(this.#image),
-            this.flags,
-            this.minFilter,
-            this.magFilter,
-            this.mipmapFilter,
-            this.wrapS,
-            this.wrapT,
-            this.wrapR,
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    hash_mix3(
+                        optional_hash(this.#image),
+                        this.flags,
+                        this.minFilter
+                    ),
+                    this.magFilter,
+                    this.mipmapFilter
+                ),
+                this.wrapS,
+                this.wrapT
+            ),
+            this.wrapR
         );
     }
 

package/src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { platform_compute_endianness } from "../../../../core/binary/platform_compute_endianness.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { HashMap } from "../../../../core/collection/map/HashMap.js";
 import { Deque } from "../../../../core/collection/queue/Deque.js";
 import { round_up } from "../../../../core/math/round_up.js";
@@ -69,7 +69,7 @@ class MipmapShaderKey {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeStringHash(this.format),
             this.filter,
         )

package/src/shade/renderer/water/surface/chunk_water_surface_sample.d.ts

@@ -1,8 +1,8 @@
 /**
- * Most particle entries one point reads, over every level. Where a point would read more than
- * WATER_PARTICLE_CELL_SHARE, the bin pass thins its cells to about that many between them, the same packets in every
- * cell they reach, and where whole fronts would still crowd it past this, its cells keep no more than their part of
- * it. So a point reads all of its cells, short of a cell only one front reaches (~40 entries at most).
+ * Most particle entries one point reads, over every level. A front's run of particles in a cell is one entry, so a
+ * point reads about one a front that reaches it; where it would read more than WATER_PARTICLE_CROWD_KEEP, the keep
+ * pass dooms the flattest runs in its cells, which fade out while what is left of the budget still draws them, and
+ * cuts, whole, the fronts the budget cannot hold.
  */
 export const WATER_PARTICLE_GATHER_BUDGET: 64;
 /**

package/src/shade/renderer/water/surface/chunk_water_surface_sample.js

@@ -5,10 +5,10 @@ import { chunk_water_spectrum } from "./spectrum/chunk_water_spectrum.js";
 import { chunk_water_particle } from "./particles/chunk_water_particle.js";
 
 /**
- * Most particle entries one point reads, over every level. Where a point would read more than
- * WATER_PARTICLE_CELL_SHARE, the bin pass thins its cells to about that many between them, the same packets in every
- * cell they reach, and where whole fronts would still crowd it past this, its cells keep no more than their part of
- * it. So a point reads all of its cells, short of a cell only one front reaches (~40 entries at most).
+ * Most particle entries one point reads, over every level. A front's run of particles in a cell is one entry, so a
+ * point reads about one a front that reaches it; where it would read more than WATER_PARTICLE_CROWD_KEEP, the keep
+ * pass dooms the flattest runs in its cells, which fade out while what is left of the budget still draws them, and
+ * cuts, whole, the fronts the budget cannot hold.
  */
 export const WATER_PARTICLE_GATHER_BUDGET = 64;
 
@@ -133,8 +133,8 @@ fn water_surface_sum(wave: u32, p: vec2<f32>, footprint: f32) -> WaterSurfaceSum
             visited++;
             let entry = water_particle_entries[i];
             if (entry.key != key || any(entry.cell != cell)) { continue; }
-            let field = water_particle_field(p - entry.position, entry.angle, entry.amplitude, entry.radius, entry.half_length,
-                entry.dispersion, entry.distance, entry.phase);
+            let field = water_particle_run_field(p - entry.position, entry.angle, entry.amplitude, entry.radius, entry.half_length,
+                entry.dispersion, entry.distance, entry.phase, entry.run);
             // a packet is geometry while its wavelength spans eight samples, fading out by four
             let f = clamp(log2(entry.radius / (2.0 * footprint)), 0.0, 1.0);
             let rough = sqrt(1.0 - f * f);

package/src/shade/renderer/water/surface/particles/GPUWaterParticles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IA0BI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA6D7G;IAED,gBAgBC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aAmGhB;;CACJ"}
+{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IAwBI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA4D7G;IAED,gBAeC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aA8FhB;;CACJ"}