@driftengine/core 4.13.3 → 4.13.5

package/dist/render/backend/webgpu/renderer.js

@@ -24,7 +24,9 @@ import { Camera } from '../../camera.js';
 import { PickableSet } from '../../pickable.js';
 import { GpuTimestamps } from './gpuTimestamps.js';
 import { isWeakGpuFamily } from '../../gpuCapability.js';
-import { resolveAtmosphere } from '../../atmosphere.js';
+import { writeMediumFields, writeMediumSlot } from './mediumFields.js';
+import { noEnvironmentMixing, resolveEnvironmentMixing } from '../../environmentMixing.js';
+import { createResolvedAtmosphere, resolveAtmosphere, } from '../../atmosphere.js';
 import { AMBIENT_SH_FLOATS, packAmbientSH } from '../../ambientHarmonics.js';
 import { lightmapTexels, warnRegionsWithoutPage, warnUnpagedLightmap, withLightmapUvs, } from '../../lightmap.js';
 import { BLOOM_FILTER_RADIUS_UV, BLOOM_LEVELS, bloomLevelSizes, bloomThresholdOf, bloomProfileWarning, defaultBloomResponse, resolveBloomResponse, } from '../../bloomChain.js';
@@ -88,7 +90,7 @@ import { DEFAULT_FILMIC_CURVE, FILMIC_CLAMPED, FILMIC_CONSTANTS, FILMIC_WITHOUT_
 import { ExposurePass } from './exposurePass.js';
 import { AO_STORE } from '../../shaders/ambientOcclusion.js';
 import { clampAutoExposure } from '../../shaders/exposure.js';
-import { clampLocalExposure } from '../../shaders/localExposure.js';
+import { LOCAL_EXPOSURE_FLOATS, resolveLocalExposure } from '../../shaders/localExposure.js';
 import { createDepthResolveLayout, createPostStageLayout, depthResolvePipeline, postPipeline, postPipelineTargets, sceneColorFormat, AO_BLUR_FIELDS, AO_BLUR_FRAG_WGSL, AO_BLUR_SIZE, AO_BLUR_TEXTURES, AO_BLUR_UNIFORMS, AO_FRAG_FIELDS, AO_FRAG_SIZE, AO_FRAG_WGSL, AO_TEXTURES, AO_UNIFORMS, BLOOM_DOWNSAMPLE_FIELDS, BLOOM_DOWNSAMPLE_FRAG_WGSL, BLOOM_PREFILTER_FIELDS, BLOOM_PREFILTER_FRAG_WGSL, BLOOM_STAGE_SIZE, BLOOM_TEXTURES, BLOOM_UNIFORMS, BLOOM_UPSAMPLE_FIELDS, TINTED_ADD_BLEND, BLOOM_UPSAMPLE_FRAG_WGSL, RESOLVED_DEPTH_FORMAT, RUSH_FRAG_FIELDS, RUSH_FRAG_SIZE, RUSH_FRAG_WGSL, RUSH_TEXTURES, RUSH_UNIFORMS, TAA_FRAG_FIELDS, TAA_FRAG_SIZE, TAA_TEXTURES, TAA_UNIFORMS, TEMPORAL_RESOLVE_FRAG_WGSL, MEDIUM_FRAG_FIELDS, MEDIUM_FRAG_SIZE, MEDIUM_FRAG_WGSL, MEDIUM_TEXTURES, MEDIUM_TRANSMIT_BLEND, MEDIUM_UNIFORMS, MEDIUM_UPSAMPLE_FIELDS, MEDIUM_UPSAMPLE_FRAG_WGSL, MEDIUM_UPSAMPLE_SIZE, MEDIUM_UPSAMPLE_TEXTURES, MEDIUM_UPSAMPLE_UNIFORMS, OIT_COMPOSITE_BLEND, OIT_RESOLVE_FRAG_WGSL, OIT_TEXTURES, DECAL_FRAG_FIELDS, DECAL_FRAG_SIZE, DECAL_MULTIPLY_BLEND, DECAL_PROJECT_FRAG_WGSL, DECAL_TEXTURES, DECAL_UNIFORMS, PREMULTIPLIED_OVER_BLEND, FRAME_REFLECTION_BLEND, REFLECTION_OVER_BLEND, SSR_FRAG_FIELDS, SSR_FRAG_SIZE, SSR_MATERIAL_FIELDS, SSR_MATERIAL_RESOLVE_FRAG_WGSL, SSR_MATERIAL_SIZE, SSR_MATERIAL_TEXTURES, SSR_MATERIAL_UNIFORMS, SSR_RESOLVE_FRAG_WGSL, SSR_RESOLVE_TEXTURES, SSR_TEXTURES, SSR_TRACE_FRAG_WGSL, SSR_UNIFORMS, createOitResolveLayout, createSsrResolveLayout, } from './postPass.js';
 import { GRADE_PLACEHOLDER_SIZE, identityGradeLut, validateGradeLut, } from '../../colourGrade.js';
 import { FILM_LOOK_WITHOUT_COMPOSITE, clampGrain, clampVignette, grainSeed, } from '../../shaders/filmLook.js';
@@ -102,9 +104,9 @@ import { buildPlumeGeometry } from '../../plumeGeometry.js';
 import { facingCode } from '../../particleBatch.js';
 import { PARTICLE_INDICES } from '../../shaders/particle.js';
 import { createScatterDeform, resolveScatterDeform, } from '../../scatterDeform.js';
-import { resolvePointLights } from '../../lightBudget.js';
+import { createResolvedPointLights, resolvePointLights, } from '../../lightBudget.js';
 import { resolveRenderQuality } from '../../renderQuality.js';
-import { DEFAULT_GLOBAL_MEDIUM, mediumActive, mediumTargetSize, WEAK_GPU_MEDIUM_STEPS, resolveGlobalMedium, } from '../../globalMedium.js';
+import { DEFAULT_GLOBAL_MEDIUM, WEAK_GPU_MEDIUM_STEPS, createResolvedMediumLamps, mediumActive, mediumTargetSize, resolveGlobalMedium, resolveGlobalMediumSettings, resolveMediumLamps, } from '../../globalMedium.js';
 import { castsDepth, glassOf } from '../../shadowCasters.js';
 import { materialHasMaps, noteMapsWithoutUvs } from '../../mapsWithoutUvs.js';
 import { VIEW_MODEL_DEPTH_SHARE, viewModelDepthRange } from '../../viewModel.js';
@@ -1532,7 +1534,10 @@ export class WebGPURenderer {
     /** The inverse projection the composite linearises a depth with, built once per frame. */
     mediumInvProjection = mat4.create();
     /** This frame's medium. Off until a caller says otherwise. See `setGlobalMedium`. */
-    mediumOptions = DEFAULT_GLOBAL_MEDIUM;
+    mediumOptions = resolveGlobalMedium(DEFAULT_GLOBAL_MEDIUM);
+    /** The lamps the medium is lit by, and the lit stage's lamps they come from, refilled a frame. */
+    mediumLamps = createResolvedMediumLamps();
+    mediumLights = createResolvedPointLights();
     /**
      * The temporal resolve: its block, its ping-pong pair, and the jitter state.
      *
@@ -2194,16 +2199,7 @@ export class WebGPURenderer {
         f[atF('uFilmRoughness')] = Math.min(1, Math.max(0, options.roughness ?? 0));
         f[atF('uFilmRoughnessCycles')] = Math.max(0.01, options.roughnessCyclesPerMetre ?? 60);
         const medium = resolveAtmosphere(env, this.atmosphereHeight(camera), this.quality.underwaterAtmosphere, this.medium);
-        f.set(medium.fogColor, atF('uFogColor'));
-        f[atF('uFogDensity')] = medium.fogDensity;
-        f[atF('uFogHeightFalloff')] = medium.fogHeightFalloff;
-        f[atF('uFogEyeY')] = medium.fogEyeY;
-        f.set(medium.underwaterColor, atF('uUnderwaterColor'));
-        f[atF('uUnderwaterFogDensity')] = medium.underwaterFogDensity;
-        f[atF('uUnderwaterFactor')] = medium.underwaterFactor;
-        i[atF('uFogMode')] = medium.fogMode;
-        f[atF('uFogNear')] = medium.fogNear;
-        f[atF('uFogFar')] = medium.fogFar;
+        writeMediumFields(FILM_FRAG_FIELDS, f, medium);
         this.filmFrags.writeBlock(fragmentSlot, this.filmFragInts);
         const filmPipe = filmPipeline(this.blendedPipelines(), this.surface.device, this.filmLayout, `film|${geometry.key ?? ''}`, this.presentOf(geometry));
         /* The mirror is an attachment right now, so the group that does not hold it. */
@@ -2931,6 +2927,15 @@ export class WebGPURenderer {
         this.passEnvironmentGain = Math.max(0, gain);
         this.writeEnvironmentDials();
     }
+    /** The environment brought to the light where a surface stands. See `renderer.ts`. */
+    setEnvironmentMixing(weight, roughnessLow = 0.1, roughnessHigh = 0.3) {
+        resolveEnvironmentMixing(weight, roughnessLow, roughnessHigh, this.environmentMixing);
+        this.material((f) => {
+            f.set(this.environmentMixing, this.materialField('uEnvironmentMixing'));
+        });
+    }
+    /** `uEnvironmentMixing` as it stands; none until a draw asks. See `setEnvironmentMixing`. */
+    environmentMixing = noEnvironmentMixing(new Float32Array(4));
     /**
      * The reflectivity and environment gain the setters gave the pass, and the ones the material
      * set now states, or null where it states none (`SurfaceMaterial.reflectivity`). A draw wears the
@@ -3716,16 +3721,7 @@ export class WebGPURenderer {
             scatterInto(f, fields['uLightWeight'], lights.weights, 1);
         }
         const medium = resolveAtmosphere(env, camera.position[1] ?? 0, this.quality.underwaterAtmosphere, this.medium);
-        f.set(medium.fogColor, atF('uFogColor'));
-        f[atF('uFogDensity')] = medium.fogDensity;
-        f[atF('uFogHeightFalloff')] = medium.fogHeightFalloff;
-        f[atF('uFogEyeY')] = medium.fogEyeY;
-        f.set(medium.underwaterColor, atF('uUnderwaterColor'));
-        f[atF('uUnderwaterFogDensity')] = medium.underwaterFogDensity;
-        f[atF('uUnderwaterFactor')] = medium.underwaterFactor;
-        i[atF('uFogMode')] = medium.fogMode;
-        f[atF('uFogNear')] = medium.fogNear;
-        f[atF('uFogFar')] = medium.fogFar;
+        writeMediumFields(fields, f, medium);
         /* Only the mote fragment declares this — spark and smoke stay unconditionally fogged and
            have no such field. See ParticleBatchOptions.fog. */
         if (has('uFogEnabled'))
@@ -3929,16 +3925,7 @@ export class WebGPURenderer {
         frags.writeInt(fragmentSlot, atF('uClipEnabled'), this.reflectionPassActive ? 1 : 0);
         frags.writeFloats(fragmentSlot, atF('uClipPlane'), this.reflection?.clipPlane ?? NO_CLIP_PLANE);
         const medium = resolveAtmosphere(env, this.atmosphereHeight(camera), this.quality.underwaterAtmosphere, this.medium);
-        frags.writeFloats(fragmentSlot, atF('uFogColor'), medium.fogColor);
-        frags.writeFloat(fragmentSlot, atF('uFogDensity'), medium.fogDensity);
-        frags.writeFloat(fragmentSlot, atF('uFogHeightFalloff'), medium.fogHeightFalloff);
-        frags.writeFloat(fragmentSlot, atF('uFogEyeY'), medium.fogEyeY);
-        frags.writeFloats(fragmentSlot, atF('uUnderwaterColor'), medium.underwaterColor);
-        frags.writeFloat(fragmentSlot, atF('uUnderwaterFogDensity'), medium.underwaterFogDensity);
-        frags.writeFloat(fragmentSlot, atF('uUnderwaterFactor'), medium.underwaterFactor);
-        frags.writeInt(fragmentSlot, atF('uFogMode'), medium.fogMode);
-        frags.writeFloat(fragmentSlot, atF('uFogNear'), medium.fogNear);
-        frags.writeFloat(fragmentSlot, atF('uFogFar'), medium.fogFar);
+        writeMediumSlot(frags, fragmentSlot, PLUME_FRAG_FIELDS, medium);
         frags.writeInt(fragmentSlot, atF('uOutputTransform'), this.passGrade());
         frags.writeFloat(fragmentSlot, atF('uOutputExposure'), this.passGradeExposure());
         /*
@@ -4079,16 +4066,7 @@ export class WebGPURenderer {
         scatterInto(f, WATER_FRAG_FIELDS['uLightWeight'], lights.weights, 1);
         scatterInto(f, WATER_FRAG_FIELDS['uLightCone'], lights.conesAndFalloffs, 4);
         const medium = resolveAtmosphere(env, camera.position[1] ?? 0, this.quality.underwaterAtmosphere, this.medium);
-        f.set(medium.fogColor, atF('uFogColor'));
-        f[atF('uFogDensity')] = medium.fogDensity;
-        f[atF('uFogHeightFalloff')] = medium.fogHeightFalloff;
-        f[atF('uFogEyeY')] = medium.fogEyeY;
-        f.set(medium.underwaterColor, atF('uUnderwaterColor'));
-        f[atF('uUnderwaterFogDensity')] = medium.underwaterFogDensity;
-        f[atF('uUnderwaterFactor')] = medium.underwaterFactor;
-        i[atF('uFogMode')] = medium.fogMode;
-        f[atF('uFogNear')] = medium.fogNear;
-        f[atF('uFogFar')] = medium.fogFar;
+        writeMediumFields(WATER_FRAG_FIELDS, f, medium);
         /* No reflection pass yet: the shader's own "off" path, not an improvised one. */
         i[atF('uReflectionEnabled')] = mirror === null ? 0 : 1;
         i[atF('uReflectionFilterTaps')] = water.reflectionFilterTaps;
@@ -4587,16 +4565,7 @@ export class WebGPURenderer {
         f.set(camera.position, atF('uCameraPos'));
         /* The medium, through the same resolver every other pass here binds from. */
         const medium = resolveAtmosphere(env, camera.position[1] ?? 0, this.quality.underwaterAtmosphere, this.medium);
-        f.set(medium.fogColor, atF('uFogColor'));
-        f[atF('uFogDensity')] = medium.fogDensity;
-        f[atF('uFogHeightFalloff')] = medium.fogHeightFalloff;
-        f[atF('uFogEyeY')] = medium.fogEyeY;
-        f.set(medium.underwaterColor, atF('uUnderwaterColor'));
-        f[atF('uUnderwaterFogDensity')] = medium.underwaterFogDensity;
-        f[atF('uUnderwaterFactor')] = medium.underwaterFactor;
-        i[atF('uFogMode')] = medium.fogMode;
-        f[atF('uFogNear')] = medium.fogNear;
-        f[atF('uFogFar')] = medium.fogFar;
+        writeMediumFields(BOLT_FRAG_FIELDS, f, medium);
         this.boltVerts.writeBlock(vertexSlot, this.boltVertBlock);
         this.boltFrags.writeBlock(fragmentSlot, this.boltFragInts);
         const boltPipe = boltPipeline(this.blendedPipelines(), this.surface.device, this.boltLayout);
@@ -4699,16 +4668,7 @@ export class WebGPURenderer {
         this.lineFrags.writeFloat(fragmentSlot, atF('uOutputExposure'), this.passGradeExposure());
         /* The medium, through the same resolver every other pass here binds from. */
         const medium = resolveAtmosphere(env, camera.position[1] ?? 0, this.quality.underwaterAtmosphere, this.medium);
-        this.lineFrags.writeFloats(fragmentSlot, atF('uFogColor'), medium.fogColor);
-        this.lineFrags.writeFloat(fragmentSlot, atF('uFogDensity'), medium.fogDensity);
-        this.lineFrags.writeFloat(fragmentSlot, atF('uFogHeightFalloff'), medium.fogHeightFalloff);
-        this.lineFrags.writeFloat(fragmentSlot, atF('uFogEyeY'), medium.fogEyeY);
-        this.lineFrags.writeFloats(fragmentSlot, atF('uUnderwaterColor'), medium.underwaterColor);
-        this.lineFrags.writeFloat(fragmentSlot, atF('uUnderwaterFogDensity'), medium.underwaterFogDensity);
-        this.lineFrags.writeFloat(fragmentSlot, atF('uUnderwaterFactor'), medium.underwaterFactor);
-        this.lineFrags.writeInt(fragmentSlot, atF('uFogMode'), medium.fogMode);
-        this.lineFrags.writeFloat(fragmentSlot, atF('uFogNear'), medium.fogNear);
-        this.lineFrags.writeFloat(fragmentSlot, atF('uFogFar'), medium.fogFar);
+        writeMediumSlot(this.lineFrags, fragmentSlot, LINE_FRAG_FIELDS, medium);
         const linePipe = linePipeline(this.blendedPipelines(), this.surface.device, this.lineLayout, additive);
         /* Two uniform blocks and three vertex buffers, and no attachment among them. */
         const lineCommand = this.recordBlended(0);
@@ -4855,39 +4815,11 @@ export class WebGPURenderer {
         this.shadowDraws.writeFloats(slot, DEPTH_VERT_FIELDS.uWindSpatialPhase.offset, d.spatialPhase);
     }
     /** Refilled per frame rather than allocated; see `resolvePointLights`. */
-    lights = {
-        count: 0,
-        falloff: 0,
-        positions: new Float32Array(0),
-        colors: new Float32Array(0),
-        radii: new Float32Array(0),
-        sourceRadii: new Float32Array(0),
-        weights: new Float32Array(0),
-        directions: new Float32Array(0),
-        coneCos: new Float32Array(0),
-        iesProfiles: new Float32Array(0),
-        iesAxes: new Float32Array(0),
-        cookies: new Float32Array(0),
-        heldSourceRadii: new Float32Array(MAX_POINT_LIGHTS),
-        axesAndChannels: new Float32Array(MAX_POINT_LIGHTS * 4),
-        conesAndFalloffs: new Float32Array(MAX_POINT_LIGHTS * 4),
-        heldWeights: new Float32Array(MAX_POINT_LIGHTS),
-    };
+    lights = createResolvedPointLights();
     /** The fixed arm's rectangles as `uAreaLightSize` holds them. See `packAreaSizesAndDoors`. */
     areaSizesAndDoors = new Float32Array(MAX_AREA_LIGHTS * 4);
     /** Refilled per frame rather than allocated; see `resolveAtmosphere`. */
-    medium = {
-        fogColor: new Float32Array(3),
-        underwaterColor: new Float32Array(3),
-        fogDensity: 0,
-        fogHeightFalloff: 0,
-        fogEyeY: 0,
-        fogMode: 0,
-        fogNear: 0,
-        fogFar: 1,
-        underwaterFogDensity: 0,
-        underwaterFactor: 0,
-    };
+    medium = createResolvedAtmosphere();
     /* -- Overlays: panels and text ------------------------------------------------------ */
     panelLayout;
     panelCorners;
@@ -6313,6 +6245,7 @@ export class WebGPURenderer {
         this.mediumLayout = createPostStageLayout(device, MEDIUM_UNIFORMS, MEDIUM_FRAG_SIZE, [
             { binding: MEDIUM_TEXTURES.uDepth, filterable: false },
             { binding: MEDIUM_TEXTURES.uSunShadows, filterable: false, dimension: '2d-array' },
+            { binding: MEDIUM_TEXTURES.uPointShadows, filterable: false, dimension: '2d-array' },
         ]);
         this.mediumUniforms = device.createBuffer({
             label: 'post.mediumUniforms',
@@ -7365,16 +7298,7 @@ export class WebGPURenderer {
          * Found by a voxel scene that is the first in the tree to use `fogMode: 'linear'` on WebGPU.
          */
         const meshMedium = resolveAtmosphere(env, this.atmosphereHeight(camera), this.quality.underwaterAtmosphere, this.medium);
-        f.set(meshMedium.fogColor, at('uFogColor'));
-        f[at('uFogDensity')] = meshMedium.fogDensity;
-        f[at('uFogHeightFalloff')] = meshMedium.fogHeightFalloff;
-        f[at('uFogEyeY')] = meshMedium.fogEyeY;
-        i[at('uFogMode')] = meshMedium.fogMode;
-        f[at('uFogNear')] = meshMedium.fogNear;
-        f[at('uFogFar')] = meshMedium.fogFar;
-        f.set(meshMedium.underwaterColor, at('uUnderwaterColor'));
-        f[at('uUnderwaterFogDensity')] = meshMedium.underwaterFogDensity;
-        f[at('uUnderwaterFactor')] = meshMedium.underwaterFactor;
+        writeMediumFields(this.fragment.fields, f, meshMedium);
         /*
          * The mirror's half-space, and only while the mirror is being drawn.
          *
@@ -7419,6 +7343,8 @@ export class WebGPURenderer {
         f[at('uWriteMode') + 2] = 0;
         /* 1, not 0: a multiplier's identity is one. See `setEnvironmentGain`. */
         f[at('uEnvironmentDials') + 2] = 1;
+        /* And no mixing, which is stored less one. See `setEnvironmentMixing`. */
+        f.set(noEnvironmentMixing(this.environmentMixing), at('uEnvironmentMixing'));
         /* No overlay until a draw sets one. See `setSurfaceOverlay`. */
         this.overlayFloats.fill(0);
         f.fill(0, at('uOverlay'), at('uOverlay') + OVERLAY_FLOATS);
@@ -7662,16 +7588,7 @@ export class WebGPURenderer {
          * drift `bindAtmosphere` was written to prevent.
          */
         const medium = resolveAtmosphere(env, this.atmosphereHeight(camera), this.quality.underwaterAtmosphere, this.medium);
-        f.set(medium.fogColor, at('uFogColor'));
-        f[at('uFogDensity')] = medium.fogDensity;
-        f[at('uFogHeightFalloff')] = medium.fogHeightFalloff;
-        f[at('uFogEyeY')] = medium.fogEyeY;
-        i[at('uFogMode')] = medium.fogMode;
-        f[at('uFogNear')] = medium.fogNear;
-        f[at('uFogFar')] = medium.fogFar;
-        f.set(medium.underwaterColor, at('uUnderwaterColor'));
-        f[at('uUnderwaterFogDensity')] = medium.underwaterFogDensity;
-        f[at('uUnderwaterFactor')] = medium.underwaterFactor;
+        writeMediumFields(this.fragment.fields, f, medium);
         /*
          * The shadow terms, matching what `renderer.ts` binds at default quality.
          *
@@ -8976,16 +8893,7 @@ export class WebGPURenderer {
         f.set(env.ambient, atF('uAmbient'));
         f.set(camera.position, atF('uCameraPos'));
         const medium = resolveAtmosphere(env, camera.position[1] ?? 0, this.quality.underwaterAtmosphere, this.medium);
-        f.set(medium.fogColor, atF('uFogColor'));
-        f[atF('uFogDensity')] = medium.fogDensity;
-        f[atF('uFogHeightFalloff')] = medium.fogHeightFalloff;
-        f[atF('uFogEyeY')] = medium.fogEyeY;
-        f.set(medium.underwaterColor, atF('uUnderwaterColor'));
-        f[atF('uUnderwaterFogDensity')] = medium.underwaterFogDensity;
-        f[atF('uUnderwaterFactor')] = medium.underwaterFactor;
-        i[atF('uFogMode')] = medium.fogMode;
-        f[atF('uFogNear')] = medium.fogNear;
-        f[atF('uFogFar')] = medium.fogFar;
+        writeMediumFields(SCATTER_FRAG_FIELDS, f, medium);
         i[atF('uOutputTransform')] = this.passGrade();
         f[atF('uOutputExposure')] = this.passGradeExposure();
         const fragmentSlot = this.scatterFrags.allocate();
@@ -9799,6 +9707,8 @@ export class WebGPURenderer {
              * resolve, which is what sampling a stand-in does.
              */
             this.rebuildFlatBindGroup();
+            /* The medium reads the same array: see `buildMediumBindGroup`. */
+            this.mediumBindGroup = this.buildMediumBindGroup();
         }
         this.pointShadows.prepareStaticMaps(lights.length);
         this.preparedPointLightCount = lights.length;
@@ -10041,6 +9951,8 @@ export class WebGPURenderer {
             if (old !== null) {
                 this.retiredPointTexture = old;
                 this.rebuildFlatBindGroup();
+                /* The medium reads the same array: see `buildMediumBindGroup`. */
+                this.mediumBindGroup = this.buildMediumBindGroup();
             }
         }
     }
@@ -10523,7 +10435,7 @@ export class WebGPURenderer {
          * it. The held brightness is kept for either, since local exposure moves regions relative to it.
          * See `setAutoExposure` and `setLocalExposure`.
          */
-        const localising = this.localExposure > 0;
+        const localising = this.localExposure;
         const measuring = (this.autoExposure > 0 || localising) && this.exposurePass !== null;
         const adapting = measuring && this.autoExposure > 0;
         const shownScene = this.reconstructing ? this.reconShownView : this.sceneColorView;
@@ -10596,7 +10508,13 @@ export class WebGPURenderer {
         f[at('uVignette')] = this.vignette;
         f.set(this.fringe, at('uFringe'));
         f[at('uAutoExposure')] = adapting ? this.autoExposure : 0;
-        f[at('uLocalExposure')] = measuring && localising ? this.localExposure : 0;
+        f[at('uLocalExposure')] = measuring && localising ? 1 : 0;
+        const shapeAt = at('uLocalShape');
+        const pivotAt = at('uLocalPivot');
+        for (let k = 0; k < 4; k++) {
+            f[shapeAt + k] = this.localExposureShape[k];
+            f[pivotAt + k] = this.localExposureShape[4 + k];
+        }
         f[at('uGrain')] = this.grain;
         f[at('uGrain') + 1] = this.grainSeed;
         device.queue.writeBuffer(this.rushUniforms, 0, this.rushStaging);
@@ -11810,7 +11728,17 @@ export class WebGPURenderer {
         f.set(env?.directionalColor ?? [0, 0, 0], at('uSunColor'));
         f.set(env?.ambient ?? [0, 0, 0], at('uAmbient'));
         f[at('uDensity')] = options.density;
-        f[at('uAlbedo')] = options.albedo;
+        const height = at('uHeight');
+        f[height] = options.heightFalloff;
+        f[height + 1] = options.baseY;
+        const layer2 = at('uLayer2');
+        f[layer2] = options.density2;
+        f[layer2 + 1] = options.heightFalloff2;
+        f[layer2 + 2] = options.baseY2;
+        f.set(options.albedo, at('uAlbedo'));
+        const scatter = at('uScatter');
+        f[scatter] = options.sunScatter;
+        f[scatter + 1] = options.skyScatter;
         f[at('uAnisotropy')] = options.anisotropy;
         f[at('uMaxDistance')] = options.maxDistance;
         ints[at('uSteps')] = this.quality.globalMediumSteps;
@@ -11828,6 +11756,20 @@ export class WebGPURenderer {
         f.set(env?.lightViewProj ?? this.mediumIdentity, at('uLightViewProj'));
         f.set((env === null ? this.mediumIdentity : this.movingLightFor(env)), at('uMovingLightViewProj'));
         ints[at('uPeeledShadowEnabled')] = this.peelView === null || !this.peelFilled ? 0 : 1;
+        /* The lit stage's lamps and the shadows it resolved for them, this frame's. */
+        const lamps = resolveMediumLamps(options, resolvePointLights(env, this.quality.pointLightFalloff, this.mediumLights), this.pointShadows === null ? null : this.resolvedPointShadows, env?.lightMediumScatter, this.mediumLamps);
+        ints[at('uLampCount')] = lamps.count;
+        ints[at('uLampFalloff')] = lamps.falloff;
+        if (lamps.count > 0) {
+            f.set(lamps.position, at('uLampPosition'));
+            f.set(lamps.color, at('uLampColor'));
+            f.set(lamps.aim, at('uLampAim'));
+            f.set(lamps.cone, at('uLampCone'));
+            f.set(lamps.shadow, at('uLampShadow'));
+            f.set(lamps.shadowAt, at('uLampShadowAt'));
+            f.set(lamps.live, at('uLampLive'));
+            f.set(lamps.liveAt, at('uLampLiveAt'));
+        }
         device.queue.writeBuffer(this.mediumUniforms, 0, this.mediumStaging);
         const g = this.mediumUpsampleFloats;
         const upsampleAt = (name) => this.postField(MEDIUM_UPSAMPLE_FIELDS, name);
@@ -14236,8 +14178,9 @@ export class WebGPURenderer {
     /** Eye adaptation: how far, this frame's time step, and the pass once asked for. */
     autoExposure = 0;
     autoExposureDt = 0;
-    /** How far each region is brought toward the frame. See `setLocalExposure`. */
-    localExposure = 0;
+    /** Whether regions move, and how, as `resolveLocalExposure` packs it. See `setLocalExposure`. */
+    localExposure = false;
+    localExposureShape = new Float32Array(LOCAL_EXPOSURE_FLOATS);
     exposurePass = null;
     /**
      * How strongly the lens darkens the frame's corners, held until changed: 0 is none, 0.5 is about
@@ -14387,12 +14330,7 @@ export class WebGPURenderer {
      * draws nothing, and the three optional arguments are held until changed.
      */
     setGlobalMedium(density, albedo, anisotropy, maxDistance) {
-        this.mediumOptions = resolveGlobalMedium({
-            density: Number.isFinite(density) ? density : 0,
-            albedo,
-            anisotropy,
-            maxDistance,
-        });
+        this.mediumOptions = resolveGlobalMediumSettings(density, albedo, anisotropy, maxDistance);
     }
     /** How much speed blur the frame should resolve with, 0 to 1. */
     setSpeedRush(strength) {
@@ -14463,13 +14401,13 @@ export class WebGPURenderer {
      * the same setter over the same state, sharing eye adaptation's pass, which is built the first
      * time either is asked for.
      */
-    setLocalExposure(strength) {
+    setLocalExposure(setting) {
         if (!this.hasComposite || !this.quality.hdrScene) {
-            this.warnLookWithoutComposite(strength);
+            this.warnLookWithoutComposite(typeof setting === 'number' ? setting : 1);
             return;
         }
-        this.localExposure = clampLocalExposure(strength);
-        if (this.localExposure > 0)
+        this.localExposure = resolveLocalExposure(setting, this.localExposureShape);
+        if (this.localExposure)
             this.ensureExposurePass();
     }
     /** The exposure pass, built once; the composite's group holds placeholders until it exists. */
@@ -14606,16 +14544,7 @@ export class WebGPURenderer {
         f[atF('uWindDir') + 1] = inv === 0 ? 0 : windZ * inv;
         f[atF('uWaveGain')] = sea.steepness;
         const medium = resolveAtmosphere(env, this.atmosphereHeight(camera), this.quality.underwaterAtmosphere, this.medium);
-        f.set(medium.fogColor, atF('uFogColor'));
-        f[atF('uFogDensity')] = medium.fogDensity;
-        f[atF('uFogHeightFalloff')] = medium.fogHeightFalloff;
-        f[atF('uFogEyeY')] = medium.fogEyeY;
-        f.set(medium.underwaterColor, atF('uUnderwaterColor'));
-        f[atF('uUnderwaterFogDensity')] = medium.underwaterFogDensity;
-        f[atF('uUnderwaterFactor')] = medium.underwaterFactor;
-        i[atF('uFogMode')] = medium.fogMode;
-        f[atF('uFogNear')] = medium.fogNear;
-        f[atF('uFogFar')] = medium.fogFar;
+        writeMediumFields(CAUSTICS_FRAG_FIELDS, f, medium);
         this.causticsVerts.writeBlock(vertexSlot, this.causticsVertBlock);
         this.causticsFrags.writeBlock(fragmentSlot, this.causticsFragInts);
         const causticsPipe = causticsPipeline(this.blendedPipelines(), this.surface.device, this.causticsLayout);
@@ -15556,6 +15485,13 @@ export class WebGPURenderer {
                 { binding: MEDIUM_TEXTURES.uDepth.sampler, resource: this.postDepthSampler },
                 { binding: MEDIUM_TEXTURES.uSunShadows.texture, resource: this.sunArrayView },
                 { binding: MEDIUM_TEXTURES.uSunShadows.sampler, resource: this.volumeShadowSampler },
+                /* The lamps' maps, the lit stage's own array, rebuilt here whenever that array is
+                   replaced; the white stand-in reads as nothing in the way, and no lamp reads it. */
+                {
+                    binding: MEDIUM_TEXTURES.uPointShadows.texture,
+                    resource: this.pointShadowArray?.view ?? this.shadowBlankView,
+                },
+                { binding: MEDIUM_TEXTURES.uPointShadows.sampler, resource: this.volumeShadowSampler },
             ],
         });
     }

package/dist/render/backend/webgpu/scatterPass.d.ts

@@ -21,7 +21,7 @@ export declare const SCATTER_DEPTH_SIZE: 240;
 export declare const SCATTER_VERT_FIELDS: UniformFields;
 export declare const SCATTER_VERT_SIZE: 240;
 export declare const SCATTER_FRAG_FIELDS: UniformFields;
-export declare const SCATTER_FRAG_SIZE: 144;
+export declare const SCATTER_FRAG_SIZE: 192;
 export declare function scatterVertexLayouts(): GPUVertexBufferLayout[];
 /** Geometry and placement on the device, behind the opaque handle the surface hands out. */
 export interface GpuScatter {

package/dist/render/backend/webgpu/shaders/clothSolve.wgsl.d.ts

@@ -37,4 +37,4 @@
  * a reset, sits the round out while the rest of the set runs it.
  */
 export declare const CLOTH_WORKGROUP = 64;
-export declare const CLOTH_SOLVE_WGSL = "\n/* The set's: every garment's particles, records, skin matrices and colliders, and the step length\n   they all share. */\nstruct Constants {\n  count: u32,\n  distances: u32,\n  bendings: u32,\n  joints: u32,\n  colliders: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n  h: f32,\n  invH: f32,\n  invH2: f32,\n  pad3: f32,\n}\n\n/* Where this dispatch's round of records starts in paces, at a dynamic offset. */\nstruct Round {\n  at: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n}\n\n/* One garment's numbers for one round: its step's, and its own that never change. */\nstruct Pace {\n  fraction: f32,\n  blend: f32,\n  alpha: f32,\n  carry: u32,\n  /* Where the pose a step starts from and the one it moves toward sit in pose, in floats. */\n  fromAt: u32,\n  toAt: u32,\n  /* 0 where the garment sits this round out. Not active, which WGSL reserves. */\n  live: u32,\n  /* 1 a max distance, 2 a backstop, 4 a frontstop: which limits the garment has at all. */\n  limits: u32,\n  /* The character's turn since the last step, by columns; origin.w is the share carried. */\n  turn0: vec4<f32>,\n  turn1: vec4<f32>,\n  turn2: vec4<f32>,\n  origin: vec4<f32>,\n  shift: vec4<f32>,\n  /* The frame's wind: one wind, sampled once a frame, so a step's rather than the set-up's. */\n  wind: vec4<f32>,\n  colliderBase: u32,\n  colliders: u32,\n  width: u32,\n  /* The share of its offset from its skinned position a particle keeps a substep: the pull's. */\n  pullKeep: f32,\n  keep: f32,\n  dragKeep: f32,\n  maxDistanceScale: f32,\n  margin: f32,\n  gravity: vec4<f32>,\n}\n\n/* One colour of one kind of constraint across the set, at a dynamic offset; first resets the\n   multipliers. Publishing reads one garment's particles as begin to end, and first is the garment. */\nstruct Batch {\n  begin: u32,\n  end: u32,\n  first: u32,\n  pad: u32,\n}\n\n@group(0) @binding(0) var<uniform> c: Constants;\n@group(0) @binding(1) var<uniform> round: Round;\n@group(0) @binding(2) var<uniform> batch: Batch;\n@group(0) @binding(3) var<storage, read_write> state: array<f32>;\n@group(0) @binding(4) var<storage, read_write> pose: array<f32>;\n@group(0) @binding(5) var<storage, read> statics: array<f32>;\n@group(0) @binding(6) var<storage, read> constraints: array<u32>;\n@group(0) @binding(7) var<storage, read_write> lambda: array<f32>;\n@group(0) @binding(8) var<storage, read> frame: array<f32>;\n@group(0) @binding(9) var<storage, read> paces: array<Pace>;\n\n/* The record of particle i's garment this round: which garment a particle is, in statics. */\nfn paceAt(i: u32) -> u32 {\n  return round.at + u32(statics[29u * c.count + i]);\n}\n\nfn stateAt(section: u32, i: u32) -> u32 {\n  return section * 3u * c.count + i * 3u;\n}\n\nfn load(at: u32) -> vec3<f32> {\n  return vec3<f32>(state[at], state[at + 1u], state[at + 2u]);\n}\n\nfn store(at: u32, v: vec3<f32>) {\n  state[at] = v.x;\n  state[at + 1u] = v.y;\n  state[at + 2u] = v.z;\n}\n\nfn poseOf(at: u32) -> vec3<f32> {\n  return vec3<f32>(pose[at], pose[at + 1u], pose[at + 2u]);\n}\n\n/* Sections of state. */\nconst POSITION = 0u;\nconst PREVIOUS = 1u;\nconst VELOCITY = 2u;\nconst START = 3u;\n\nfn inverseMass(i: u32) -> f32 {\n  return statics[i];\n}\n\n/* Where skinning puts particle i, fraction of the way from the last pose to the latest. */\nfn skinnedAt(i: u32, g: u32) -> vec3<f32> {\n  let a = poseOf(paces[g].fromAt + i * 3u);\n  let b = poseOf(paces[g].toAt + i * 3u);\n  return a + (b - a) * paces[g].fraction;\n}\n\nfn skinMatrix(j: u32) -> mat4x4<f32> {\n  let at = j * 16u;\n  return mat4x4<f32>(\n    vec4<f32>(frame[at], frame[at + 1u], frame[at + 2u], frame[at + 3u]),\n    vec4<f32>(frame[at + 4u], frame[at + 5u], frame[at + 6u], frame[at + 7u]),\n    vec4<f32>(frame[at + 8u], frame[at + 9u], frame[at + 10u], frame[at + 11u]),\n    vec4<f32>(frame[at + 12u], frame[at + 13u], frame[at + 14u], frame[at + 15u]));\n}\n\n/* skinParticles: each particle's skinned position and normal by up to eight influences. */\n@compute @workgroup_size(64)\nfn clothPose(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let n = c.count;\n  let restAt = 7u * n + i * 3u;\n  let normalAt = 10u * n + i * 3u;\n  let x = vec4<f32>(statics[restAt], statics[restAt + 1u], statics[restAt + 2u], 1.0);\n  let q0 = vec3<f32>(statics[normalAt], statics[normalAt + 1u], statics[normalAt + 2u]);\n  var p = vec3<f32>(0.0);\n  var q = vec3<f32>(0.0);\n  for (var half = 0u; half < 2u; half++) {\n    for (var k = 0u; k < 4u; k++) {\n      let at = 13u * n + i * 16u + half * 8u;\n      let w = statics[at + 4u + k];\n      if (w == 0.0) {\n        continue;\n      }\n      let m = skinMatrix(u32(statics[at + k]));\n      p += w * (m * x).xyz;\n      q += w * (mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz) * q0);\n    }\n  }\n  let to = paces[g].toAt + i * 3u;\n  pose[to] = p.x;\n  pose[to + 1u] = p.y;\n  pose[to + 2u] = p.z;\n  let len = sqrt(dot(q, q));\n  let inv = select(0.0, 1.0 / len, len > 1e-12);\n  let normal = 6u * n + i * 3u;\n  pose[normal] = q.x * inv;\n  pose[normal + 1u] = q.y * inv;\n  pose[normal + 2u] = q.z * inv;\n}\n\n/* SkinnedCloth.rest: every particle at the latest skinned position, at rest. */\n@compute @workgroup_size(64)\nfn clothRest(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let p = poseOf(paces[g].toAt + i * 3u);\n  store(stateAt(POSITION, i), p);\n  store(stateAt(START, i), p);\n  store(stateAt(VELOCITY, i), vec3<f32>(0.0));\n}\n\n/* The step's start: the step start kept, a free particle carried, a kinematic one placed. */\n@compute @workgroup_size(64)\nfn clothBegin(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(START, i), p);\n  if (inverseMass(i) == 0.0) {\n    store(at, skinnedAt(i, g));\n    return;\n  }\n  if (paces[g].carry == 0u) {\n    return;\n  }\n  /* carryParticles: the share of the character's turn about its old origin, and of its move. */\n  let turn = mat3x3<f32>(paces[g].turn0.xyz, paces[g].turn1.xyz, paces[g].turn2.xyz);\n  let share = paces[g].origin.w;\n  let x = p - paces[g].origin.xyz;\n  store(at, p + (turn * x - x) * share + paces[g].shift.xyz);\n  let vAt = stateAt(VELOCITY, i);\n  let v = load(vAt);\n  store(vAt, v + (turn * v - v) * share);\n}\n\n/* predictParticles. */\n@compute @workgroup_size(64)\nfn clothPredict(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(PREVIOUS, i), p);\n  if (inverseMass(i) == 0.0) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  let air = paces[g].wind.xyz;\n  let v = air + (load(vAt) * paces[g].keep - air) * paces[g].dragKeep + paces[g].gravity.xyz * c.h;\n  store(vAt, v);\n  store(at, p + v * c.h);\n}\n\n/* solveDistanceBatch: one invocation a constraint of the batch, constraints sorted by batch. */\n@compute @workgroup_size(64)\nfn clothDistance(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let a = constraints[k * 4u];\n  let b = constraints[k * 4u + 1u];\n  /* A garment sitting the round out solves nothing, and its next step's first pass resets. */\n  if (paces[paceAt(a)].live == 0u) {\n    return;\n  }\n  /* The first pass of a substep starts the multiplier at nothing, as the CPU's fill(0) does \u2014\n     written before any early return, so a skipped constraint does not carry the last one. */\n  if (batch.first == 1u) {\n    lambda[k] = 0.0;\n  }\n  let wa = inverseMass(a);\n  let wb = inverseMass(b);\n  let w = wa + wb;\n  if (w == 0.0) {\n    return;\n  }\n  let aAt = stateAt(POSITION, a);\n  let bAt = stateAt(POSITION, b);\n  let d = load(bAt) - load(aAt);\n  let len = sqrt(dot(d, d));\n  if (len < 1e-9) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[k * 4u + 3u]) * c.invH2;\n  let old = lambda[k];\n  let delta = (-(len - bitcast<f32>(constraints[k * 4u + 2u])) - alpha * old) / (w + alpha);\n  lambda[k] = old + delta;\n  let s = delta / len;\n  /* A pinned particle is shared across a batch, so it is never written, even with itself. */\n  if (wa > 0.0) {\n    store(aAt, load(aAt) - d * s * wa);\n  }\n  if (wb > 0.0) {\n    store(bAt, load(bAt) + d * s * wb);\n  }\n}\n\n/* solveBendingBatch, with the angle from atan2 (see the header). */\n@compute @workgroup_size(64)\nfn clothBending(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + k * 6u;\n  let slot = c.distances + k;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  if (batch.first == 1u) {\n    lambda[slot] = 0.0;\n  }\n  let ids = vec4<u32>(constraints[at], constraints[at + 1u], constraints[at + 2u], constraints[at + 3u]);\n  let w = vec4<f32>(inverseMass(ids.x), inverseMass(ids.y), inverseMass(ids.z), inverseMass(ids.w));\n  if (w.x + w.y + w.z + w.w == 0.0) {\n    return;\n  }\n  let origin = load(stateAt(POSITION, ids.x));\n  let e = load(stateAt(POSITION, ids.y)) - origin;\n  let p3 = load(stateAt(POSITION, ids.z)) - origin;\n  let p4 = load(stateAt(POSITION, ids.w)) - origin;\n  var n1 = cross(e, p3);\n  var n2 = cross(e, p4);\n  let l1 = sqrt(dot(n1, n1));\n  let l2 = sqrt(dot(n2, n2));\n  if (l1 < 1e-12 || l2 < 1e-12) {\n    return;\n  }\n  n1 = n1 / l1;\n  n2 = n2 / l2;\n  let d = clamp(dot(n1, n2), -1.0, 1.0);\n  let sine = sqrt(dot(cross(n1, n2), cross(n1, n2)));\n  if (sine < 1e-6) {\n    return;\n  }\n  /* The q vectors: the negative of the derivative of n1 \u00B7 n2. See solveBendingBatch. */\n  let q3 = (cross(e, n2) + cross(n1, e) * d) / l1;\n  let q4 = (cross(e, n1) + cross(n2, e) * d) / l2;\n  let q2 = -((cross(p3, n2) + cross(n1, p3) * d) / l1 + (cross(p4, n1) + cross(n2, p4) * d) / l2);\n  let q1 = -(q2 + q3 + q4);\n  var sum = w.x * dot(q1, q1) + w.y * dot(q2, q2) + w.z * dot(q3, q3) + w.w * dot(q4, q4);\n  sum = sum / (sine * sine);\n  if (sum < 1e-12) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[at + 5u]) * c.invH2;\n  let old = lambda[slot];\n  let angle = atan2(sine, d);\n  let delta = (-(angle - bitcast<f32>(constraints[at + 4u])) - alpha * old) / (sum + alpha);\n  lambda[slot] = old + delta;\n  let scale = delta / sine;\n  if (w.x > 0.0) {\n    let p = stateAt(POSITION, ids.x);\n    store(p, load(p) + w.x * scale * q1);\n  }\n  if (w.y > 0.0) {\n    let p = stateAt(POSITION, ids.y);\n    store(p, load(p) + w.y * scale * q2);\n  }\n  if (w.z > 0.0) {\n    let p = stateAt(POSITION, ids.z);\n    store(p, load(p) + w.z * scale * q3);\n  }\n  if (w.w > 0.0) {\n    let p = stateAt(POSITION, ids.w);\n    store(p, load(p) + w.w * scale * q4);\n  }\n}\n\n/* solveTethers, one invocation a tether of the batch: a batch holds a particle once. */\n@compute @workgroup_size(64)\nfn clothTether(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + c.bendings * 6u + k * 3u;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  let pAt = stateAt(POSITION, constraints[at]);\n  let anchor = load(stateAt(POSITION, constraints[at + 1u]));\n  let d = load(pAt) - anchor;\n  let dist = sqrt(dot(d, d));\n  let reach = bitcast<f32>(constraints[at + 2u]);\n  if (dist <= reach || dist < 1e-9) {\n    return;\n  }\n  store(pAt, anchor + d * (reach / dist));\n}\n\n/* pushOut: the point onto the sphere's surface if it is inside. A point at the centre stays. */\nfn pushOut(p: vec3<f32>, centre: vec3<f32>, radius: f32) -> vec3<f32> {\n  let d = p - centre;\n  let d2 = dot(d, d);\n  if (d2 >= radius * radius || d2 < 1e-18) {\n    return p;\n  }\n  return centre + d * (radius / sqrt(d2));\n}\n\n/* applyPull, applyMaxDistance, applyStops (back, then front) and applyColliders, in that order. */\n@compute @workgroup_size(64)\nfn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count || inverseMass(i) == 0.0) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let limits = paces[g].limits;\n  let n = c.count;\n  let at = stateAt(POSITION, i);\n  var p = load(at);\n  let t = skinnedAt(i, g);\n  /* Only where there is a pull, as on the CPU: t + (p - t) is not p in floats. */\n  if (paces[g].pullKeep < 1.0) {\n    p = t + (p - t) * paces[g].pullKeep;\n  }\n  /* A max distance below zero is none: the CPU's Infinity, which a device may not be handed. */\n  let maxDistance = statics[n + i];\n  if ((limits & 1u) != 0u && maxDistance >= 0.0) {\n    let limit = maxDistance * paces[g].maxDistanceScale;\n    let d = p - t;\n    let d2 = dot(d, d);\n    if (d2 > limit * limit) {\n      p = t + d * (limit / sqrt(d2));\n    }\n  }\n  let normal = poseOf(6u * n + i * 3u);\n  if ((limits & 2u) != 0u) {\n    let radius = statics[2u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t - normal * (statics[2u * n + i * 2u] + radius), radius);\n    }\n  }\n  if ((limits & 4u) != 0u) {\n    let radius = statics[4u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t + normal * (statics[4u * n + i * 2u] + radius), radius);\n    }\n  }\n  let pad = statics[6u * n + i] + paces[g].margin;\n  let ends = c.joints * 16u;\n  let radii = ends + c.colliders * 6u;\n  let first = paces[g].colliderBase;\n  for (var k = first; k < first + paces[g].colliders; k++) {\n    let a = vec3<f32>(frame[ends + k * 6u], frame[ends + k * 6u + 1u], frame[ends + k * 6u + 2u]);\n    let e = vec3<f32>(frame[ends + k * 6u + 3u], frame[ends + k * 6u + 4u], frame[ends + k * 6u + 5u]) - a;\n    let e2 = dot(e, e);\n    var s = 0.0;\n    if (e2 > 1e-18) {\n      s = clamp(dot(p - a, e) / e2, 0.0, 1.0);\n    }\n    let r0 = frame[radii + k * 2u];\n    let r1 = frame[radii + k * 2u + 1u];\n    p = pushOut(p, a + e * s, r0 + (r1 - r0) * s + pad);\n  }\n  store(at, p);\n}\n\n/* finishParticles. */\n@compute @workgroup_size(64)\nfn clothFinish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  if (paces[paceAt(i)].live == 0u) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  if (inverseMass(i) == 0.0) {\n    store(vAt, vec3<f32>(0.0));\n    return;\n  }\n  store(vAt, (load(stateAt(POSITION, i)) - load(stateAt(PREVIOUS, i))) * c.invH);\n}\n\n/* SkinnedCloth.blend: after a reset, the simulation's share grows over the blend's steps. */\n@compute @workgroup_size(64)\nfn clothBlend(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  /* A blend of 0 is none, not a last step of one: see ClothDevice.step. */\n  let g = paceAt(i);\n  let blend = paces[g].blend;\n  if (paces[g].live == 0u || blend <= 0.0) {\n    return;\n  }\n  let t = skinnedAt(i, g);\n  let at = stateAt(POSITION, i);\n  store(at, t + (load(at) - t) * blend);\n  let vAt = stateAt(VELOCITY, i);\n  store(vAt, load(vAt) * blend);\n}\n\n@group(1) @binding(0) var output: texture_storage_2d<rgba32float, write>;\n\n/* SkinnedCloth.interpolate, into the particle texture the vertex stage reads: one garment's, whose\n   particles are batch.begin to batch.end and whose record is batch.first's. */\n@compute @workgroup_size(64)\nfn clothPublish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = batch.begin + id.x;\n  if (i >= batch.end) {\n    return;\n  }\n  let g = round.at + batch.first;\n  let a = load(stateAt(START, i));\n  let p = a + (load(stateAt(POSITION, i)) - a) * paces[g].alpha;\n  let local = id.x;\n  let width = paces[g].width;\n  textureStore(output, vec2<u32>(local % width, local / width), vec4<f32>(p, 0.0));\n}\n";
+export declare const CLOTH_SOLVE_WGSL = "\n/* The set's: every garment's particles, records, skin matrices and colliders, and the step length\n   they all share. */\nstruct Constants {\n  count: u32,\n  distances: u32,\n  bendings: u32,\n  joints: u32,\n  colliders: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n  h: f32,\n  invH: f32,\n  invH2: f32,\n  pad3: f32,\n}\n\n/* Where this dispatch's round of records starts in paces, at a dynamic offset. */\nstruct Round {\n  at: u32,\n  pad0: u32,\n  pad1: u32,\n  pad2: u32,\n}\n\n/* One garment's numbers for one round: its step's, and its own that never change. */\nstruct Pace {\n  fraction: f32,\n  blend: f32,\n  alpha: f32,\n  carry: u32,\n  /* Where the pose a step starts from and the one it moves toward sit in pose, in floats. */\n  fromAt: u32,\n  toAt: u32,\n  /* 0 where the garment sits this round out. Not active, which WGSL reserves. */\n  live: u32,\n  /* 1 a max distance, 2 a backstop, 4 a frontstop: which limits the garment has at all. */\n  limits: u32,\n  /* The character's turn since the last step, by columns; origin.w is the share carried. */\n  turn0: vec4<f32>,\n  turn1: vec4<f32>,\n  turn2: vec4<f32>,\n  origin: vec4<f32>,\n  shift: vec4<f32>,\n  /* The frame's wind: one wind, sampled once a frame, so a step's rather than the set-up's. */\n  wind: vec4<f32>,\n  colliderBase: u32,\n  colliders: u32,\n  width: u32,\n  /* The garment's pull as a substep's stiffness, pull \u00B7 h\u00B2: a particle weighted w keeps\n     1 / (1 + w \u00B7 pullStep) of its offset from its skinned position. */\n  pullStep: f32,\n  keep: f32,\n  dragKeep: f32,\n  maxDistanceScale: f32,\n  margin: f32,\n  gravity: vec4<f32>,\n}\n\n/* One colour of one kind of constraint across the set, at a dynamic offset; first resets the\n   multipliers. Publishing reads one garment's particles as begin to end, and first is the garment. */\nstruct Batch {\n  begin: u32,\n  end: u32,\n  first: u32,\n  pad: u32,\n}\n\n@group(0) @binding(0) var<uniform> c: Constants;\n@group(0) @binding(1) var<uniform> round: Round;\n@group(0) @binding(2) var<uniform> batch: Batch;\n@group(0) @binding(3) var<storage, read_write> state: array<f32>;\n@group(0) @binding(4) var<storage, read_write> pose: array<f32>;\n@group(0) @binding(5) var<storage, read> statics: array<f32>;\n@group(0) @binding(6) var<storage, read> constraints: array<u32>;\n@group(0) @binding(7) var<storage, read_write> lambda: array<f32>;\n@group(0) @binding(8) var<storage, read> frame: array<f32>;\n@group(0) @binding(9) var<storage, read> paces: array<Pace>;\n\n/* The record of particle i's garment this round: which garment a particle is, in statics. */\nfn paceAt(i: u32) -> u32 {\n  return round.at + u32(statics[30u * c.count + i]);\n}\n\nfn stateAt(section: u32, i: u32) -> u32 {\n  return section * 3u * c.count + i * 3u;\n}\n\nfn load(at: u32) -> vec3<f32> {\n  return vec3<f32>(state[at], state[at + 1u], state[at + 2u]);\n}\n\nfn store(at: u32, v: vec3<f32>) {\n  state[at] = v.x;\n  state[at + 1u] = v.y;\n  state[at + 2u] = v.z;\n}\n\nfn poseOf(at: u32) -> vec3<f32> {\n  return vec3<f32>(pose[at], pose[at + 1u], pose[at + 2u]);\n}\n\n/* Sections of state. */\nconst POSITION = 0u;\nconst PREVIOUS = 1u;\nconst VELOCITY = 2u;\nconst START = 3u;\n\nfn inverseMass(i: u32) -> f32 {\n  return statics[i];\n}\n\n/* Where skinning puts particle i, fraction of the way from the last pose to the latest. */\nfn skinnedAt(i: u32, g: u32) -> vec3<f32> {\n  let a = poseOf(paces[g].fromAt + i * 3u);\n  let b = poseOf(paces[g].toAt + i * 3u);\n  return a + (b - a) * paces[g].fraction;\n}\n\nfn skinMatrix(j: u32) -> mat4x4<f32> {\n  let at = j * 16u;\n  return mat4x4<f32>(\n    vec4<f32>(frame[at], frame[at + 1u], frame[at + 2u], frame[at + 3u]),\n    vec4<f32>(frame[at + 4u], frame[at + 5u], frame[at + 6u], frame[at + 7u]),\n    vec4<f32>(frame[at + 8u], frame[at + 9u], frame[at + 10u], frame[at + 11u]),\n    vec4<f32>(frame[at + 12u], frame[at + 13u], frame[at + 14u], frame[at + 15u]));\n}\n\n/* skinParticles: each particle's skinned position and normal by up to eight influences. */\n@compute @workgroup_size(64)\nfn clothPose(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let n = c.count;\n  let restAt = 7u * n + i * 3u;\n  let normalAt = 10u * n + i * 3u;\n  let x = vec4<f32>(statics[restAt], statics[restAt + 1u], statics[restAt + 2u], 1.0);\n  let q0 = vec3<f32>(statics[normalAt], statics[normalAt + 1u], statics[normalAt + 2u]);\n  var p = vec3<f32>(0.0);\n  var q = vec3<f32>(0.0);\n  for (var half = 0u; half < 2u; half++) {\n    for (var k = 0u; k < 4u; k++) {\n      let at = 13u * n + i * 16u + half * 8u;\n      let w = statics[at + 4u + k];\n      if (w == 0.0) {\n        continue;\n      }\n      let m = skinMatrix(u32(statics[at + k]));\n      p += w * (m * x).xyz;\n      q += w * (mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz) * q0);\n    }\n  }\n  let to = paces[g].toAt + i * 3u;\n  pose[to] = p.x;\n  pose[to + 1u] = p.y;\n  pose[to + 2u] = p.z;\n  let len = sqrt(dot(q, q));\n  let inv = select(0.0, 1.0 / len, len > 1e-12);\n  let normal = 6u * n + i * 3u;\n  pose[normal] = q.x * inv;\n  pose[normal + 1u] = q.y * inv;\n  pose[normal + 2u] = q.z * inv;\n}\n\n/* SkinnedCloth.rest: every particle at the latest skinned position, at rest. */\n@compute @workgroup_size(64)\nfn clothRest(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let p = poseOf(paces[g].toAt + i * 3u);\n  store(stateAt(POSITION, i), p);\n  store(stateAt(START, i), p);\n  store(stateAt(VELOCITY, i), vec3<f32>(0.0));\n}\n\n/* The step's start: the step start kept, a free particle carried, a kinematic one placed. */\n@compute @workgroup_size(64)\nfn clothBegin(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(START, i), p);\n  if (inverseMass(i) == 0.0) {\n    store(at, skinnedAt(i, g));\n    return;\n  }\n  if (paces[g].carry == 0u) {\n    return;\n  }\n  /* carryParticles: the share of the character's turn about its old origin, and of its move. */\n  let turn = mat3x3<f32>(paces[g].turn0.xyz, paces[g].turn1.xyz, paces[g].turn2.xyz);\n  let share = paces[g].origin.w;\n  let x = p - paces[g].origin.xyz;\n  store(at, p + (turn * x - x) * share + paces[g].shift.xyz);\n  let vAt = stateAt(VELOCITY, i);\n  let v = load(vAt);\n  store(vAt, v + (turn * v - v) * share);\n}\n\n/* predictParticles. */\n@compute @workgroup_size(64)\nfn clothPredict(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let at = stateAt(POSITION, i);\n  let p = load(at);\n  store(stateAt(PREVIOUS, i), p);\n  if (inverseMass(i) == 0.0) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  let air = paces[g].wind.xyz;\n  let v = air + (load(vAt) * paces[g].keep - air) * paces[g].dragKeep + paces[g].gravity.xyz * c.h;\n  store(vAt, v);\n  store(at, p + v * c.h);\n}\n\n/* solveDistanceBatch: one invocation a constraint of the batch, constraints sorted by batch. */\n@compute @workgroup_size(64)\nfn clothDistance(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let a = constraints[k * 4u];\n  let b = constraints[k * 4u + 1u];\n  /* A garment sitting the round out solves nothing, and its next step's first pass resets. */\n  if (paces[paceAt(a)].live == 0u) {\n    return;\n  }\n  /* The first pass of a substep starts the multiplier at nothing, as the CPU's fill(0) does \u2014\n     written before any early return, so a skipped constraint does not carry the last one. */\n  if (batch.first == 1u) {\n    lambda[k] = 0.0;\n  }\n  let wa = inverseMass(a);\n  let wb = inverseMass(b);\n  let w = wa + wb;\n  if (w == 0.0) {\n    return;\n  }\n  let aAt = stateAt(POSITION, a);\n  let bAt = stateAt(POSITION, b);\n  let d = load(bAt) - load(aAt);\n  let len = sqrt(dot(d, d));\n  if (len < 1e-9) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[k * 4u + 3u]) * c.invH2;\n  let old = lambda[k];\n  let delta = (-(len - bitcast<f32>(constraints[k * 4u + 2u])) - alpha * old) / (w + alpha);\n  lambda[k] = old + delta;\n  let s = delta / len;\n  /* A pinned particle is shared across a batch, so it is never written, even with itself. */\n  if (wa > 0.0) {\n    store(aAt, load(aAt) - d * s * wa);\n  }\n  if (wb > 0.0) {\n    store(bAt, load(bAt) + d * s * wb);\n  }\n}\n\n/* solveBendingBatch, with the angle from atan2 (see the header). */\n@compute @workgroup_size(64)\nfn clothBending(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + k * 6u;\n  let slot = c.distances + k;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  if (batch.first == 1u) {\n    lambda[slot] = 0.0;\n  }\n  let ids = vec4<u32>(constraints[at], constraints[at + 1u], constraints[at + 2u], constraints[at + 3u]);\n  let w = vec4<f32>(inverseMass(ids.x), inverseMass(ids.y), inverseMass(ids.z), inverseMass(ids.w));\n  if (w.x + w.y + w.z + w.w == 0.0) {\n    return;\n  }\n  let origin = load(stateAt(POSITION, ids.x));\n  let e = load(stateAt(POSITION, ids.y)) - origin;\n  let p3 = load(stateAt(POSITION, ids.z)) - origin;\n  let p4 = load(stateAt(POSITION, ids.w)) - origin;\n  var n1 = cross(e, p3);\n  var n2 = cross(e, p4);\n  let l1 = sqrt(dot(n1, n1));\n  let l2 = sqrt(dot(n2, n2));\n  if (l1 < 1e-12 || l2 < 1e-12) {\n    return;\n  }\n  n1 = n1 / l1;\n  n2 = n2 / l2;\n  let d = clamp(dot(n1, n2), -1.0, 1.0);\n  let sine = sqrt(dot(cross(n1, n2), cross(n1, n2)));\n  if (sine < 1e-6) {\n    return;\n  }\n  /* The q vectors: the negative of the derivative of n1 \u00B7 n2. See solveBendingBatch. */\n  let q3 = (cross(e, n2) + cross(n1, e) * d) / l1;\n  let q4 = (cross(e, n1) + cross(n2, e) * d) / l2;\n  let q2 = -((cross(p3, n2) + cross(n1, p3) * d) / l1 + (cross(p4, n1) + cross(n2, p4) * d) / l2);\n  let q1 = -(q2 + q3 + q4);\n  var sum = w.x * dot(q1, q1) + w.y * dot(q2, q2) + w.z * dot(q3, q3) + w.w * dot(q4, q4);\n  sum = sum / (sine * sine);\n  if (sum < 1e-12) {\n    return;\n  }\n  let alpha = bitcast<f32>(constraints[at + 5u]) * c.invH2;\n  let old = lambda[slot];\n  let angle = atan2(sine, d);\n  let delta = (-(angle - bitcast<f32>(constraints[at + 4u])) - alpha * old) / (sum + alpha);\n  lambda[slot] = old + delta;\n  let scale = delta / sine;\n  if (w.x > 0.0) {\n    let p = stateAt(POSITION, ids.x);\n    store(p, load(p) + w.x * scale * q1);\n  }\n  if (w.y > 0.0) {\n    let p = stateAt(POSITION, ids.y);\n    store(p, load(p) + w.y * scale * q2);\n  }\n  if (w.z > 0.0) {\n    let p = stateAt(POSITION, ids.z);\n    store(p, load(p) + w.z * scale * q3);\n  }\n  if (w.w > 0.0) {\n    let p = stateAt(POSITION, ids.w);\n    store(p, load(p) + w.w * scale * q4);\n  }\n}\n\n/* solveTethers, one invocation a tether of the batch: a batch holds a particle once. */\n@compute @workgroup_size(64)\nfn clothTether(@builtin(global_invocation_id) id: vec3<u32>) {\n  let k = batch.begin + id.x;\n  if (k >= batch.end) {\n    return;\n  }\n  let at = c.distances * 4u + c.bendings * 6u + k * 3u;\n  if (paces[paceAt(constraints[at])].live == 0u) {\n    return;\n  }\n  let pAt = stateAt(POSITION, constraints[at]);\n  let anchor = load(stateAt(POSITION, constraints[at + 1u]));\n  let d = load(pAt) - anchor;\n  let dist = sqrt(dot(d, d));\n  let reach = bitcast<f32>(constraints[at + 2u]);\n  if (dist <= reach || dist < 1e-9) {\n    return;\n  }\n  store(pAt, anchor + d * (reach / dist));\n}\n\n/* pushOut: the point onto the sphere's surface if it is inside. A point at the centre stays. */\nfn pushOut(p: vec3<f32>, centre: vec3<f32>, radius: f32) -> vec3<f32> {\n  let d = p - centre;\n  let d2 = dot(d, d);\n  if (d2 >= radius * radius || d2 < 1e-18) {\n    return p;\n  }\n  return centre + d * (radius / sqrt(d2));\n}\n\n/* applyPull, applyMaxDistance, applyStops (back, then front) and applyColliders, in that order. */\n@compute @workgroup_size(64)\nfn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count || inverseMass(i) == 0.0) {\n    return;\n  }\n  let g = paceAt(i);\n  if (paces[g].live == 0u) {\n    return;\n  }\n  let limits = paces[g].limits;\n  let n = c.count;\n  let at = stateAt(POSITION, i);\n  var p = load(at);\n  let t = skinnedAt(i, g);\n  /* Only where there is a pull, as on the CPU: t + (p - t) is not p in floats. */\n  let pull = statics[29u * n + i] * paces[g].pullStep;\n  if (pull > 0.0) {\n    p = t + (p - t) * (1.0 / (1.0 + pull));\n  }\n  /* A max distance below zero is none: the CPU's Infinity, which a device may not be handed. */\n  let maxDistance = statics[n + i];\n  if ((limits & 1u) != 0u && maxDistance >= 0.0) {\n    let limit = maxDistance * paces[g].maxDistanceScale;\n    let d = p - t;\n    let d2 = dot(d, d);\n    if (d2 > limit * limit) {\n      p = t + d * (limit / sqrt(d2));\n    }\n  }\n  let normal = poseOf(6u * n + i * 3u);\n  if ((limits & 2u) != 0u) {\n    let radius = statics[2u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t - normal * (statics[2u * n + i * 2u] + radius), radius);\n    }\n  }\n  if ((limits & 4u) != 0u) {\n    let radius = statics[4u * n + i * 2u + 1u];\n    if (radius > 0.0) {\n      p = pushOut(p, t + normal * (statics[4u * n + i * 2u] + radius), radius);\n    }\n  }\n  let pad = statics[6u * n + i] + paces[g].margin;\n  let ends = c.joints * 16u;\n  let radii = ends + c.colliders * 6u;\n  let first = paces[g].colliderBase;\n  for (var k = first; k < first + paces[g].colliders; k++) {\n    let a = vec3<f32>(frame[ends + k * 6u], frame[ends + k * 6u + 1u], frame[ends + k * 6u + 2u]);\n    let e = vec3<f32>(frame[ends + k * 6u + 3u], frame[ends + k * 6u + 4u], frame[ends + k * 6u + 5u]) - a;\n    let e2 = dot(e, e);\n    var s = 0.0;\n    if (e2 > 1e-18) {\n      s = clamp(dot(p - a, e) / e2, 0.0, 1.0);\n    }\n    let r0 = frame[radii + k * 2u];\n    let r1 = frame[radii + k * 2u + 1u];\n    p = pushOut(p, a + e * s, r0 + (r1 - r0) * s + pad);\n  }\n  store(at, p);\n}\n\n/* finishParticles. */\n@compute @workgroup_size(64)\nfn clothFinish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  if (paces[paceAt(i)].live == 0u) {\n    return;\n  }\n  let vAt = stateAt(VELOCITY, i);\n  if (inverseMass(i) == 0.0) {\n    store(vAt, vec3<f32>(0.0));\n    return;\n  }\n  store(vAt, (load(stateAt(POSITION, i)) - load(stateAt(PREVIOUS, i))) * c.invH);\n}\n\n/* SkinnedCloth.blend: after a reset, the simulation's share grows over the blend's steps. */\n@compute @workgroup_size(64)\nfn clothBlend(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i >= c.count) {\n    return;\n  }\n  /* A blend of 0 is none, not a last step of one: see ClothDevice.step. */\n  let g = paceAt(i);\n  let blend = paces[g].blend;\n  if (paces[g].live == 0u || blend <= 0.0) {\n    return;\n  }\n  let t = skinnedAt(i, g);\n  let at = stateAt(POSITION, i);\n  store(at, t + (load(at) - t) * blend);\n  let vAt = stateAt(VELOCITY, i);\n  store(vAt, load(vAt) * blend);\n}\n\n@group(1) @binding(0) var output: texture_storage_2d<rgba32float, write>;\n\n/* SkinnedCloth.interpolate, into the particle texture the vertex stage reads: one garment's, whose\n   particles are batch.begin to batch.end and whose record is batch.first's. */\n@compute @workgroup_size(64)\nfn clothPublish(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = batch.begin + id.x;\n  if (i >= batch.end) {\n    return;\n  }\n  let g = round.at + batch.first;\n  let a = load(stateAt(START, i));\n  let p = a + (load(stateAt(POSITION, i)) - a) * paces[g].alpha;\n  let local = id.x;\n  let width = paces[g].width;\n  textureStore(output, vec2<u32>(local % width, local / width), vec4<f32>(p, 0.0));\n}\n";

package/dist/render/backend/webgpu/shaders/clothSolve.wgsl.js

@@ -87,8 +87,9 @@ struct Pace {
   colliderBase: u32,
   colliders: u32,
   width: u32,
-  /* The share of its offset from its skinned position a particle keeps a substep: the pull's. */
-  pullKeep: f32,
+  /* The garment's pull as a substep's stiffness, pull · h²: a particle weighted w keeps
+     1 / (1 + w · pullStep) of its offset from its skinned position. */
+  pullStep: f32,
   keep: f32,
   dragKeep: f32,
   maxDistanceScale: f32,
@@ -118,7 +119,7 @@ struct Batch {
 
 /* The record of particle i's garment this round: which garment a particle is, in statics. */
 fn paceAt(i: u32) -> u32 {
-  return round.at + u32(statics[29u * c.count + i]);
+  return round.at + u32(statics[30u * c.count + i]);
 }
 
 fn stateAt(section: u32, i: u32) -> u32 {
@@ -445,8 +446,9 @@ fn clothLimit(@builtin(global_invocation_id) id: vec3<u32>) {
   var p = load(at);
   let t = skinnedAt(i, g);
   /* Only where there is a pull, as on the CPU: t + (p - t) is not p in floats. */
-  if (paces[g].pullKeep < 1.0) {
-    p = t + (p - t) * paces[g].pullKeep;
+  let pull = statics[29u * n + i] * paces[g].pullStep;
+  if (pull > 0.0) {
+    p = t + (p - t) * (1.0 / (1.0 + pull));
   }
   /* A max distance below zero is none: the CPU's Infinity, which a device may not be handed. */
   let maxDistance = statics[n + i];

package/dist/render/backend/webgpu/waterPass.d.ts

@@ -11,7 +11,7 @@ import type { UniformFields } from './scatterPass.ts';
 export declare const WATER_VERT_FIELDS: UniformFields;
 export declare const WATER_VERT_SIZE: 208;
 export declare const WATER_FRAG_FIELDS: UniformFields;
-export declare const WATER_FRAG_SIZE: 1520;
+export declare const WATER_FRAG_SIZE: 1568;
 /** The two meshes and the numbers the grid decided, behind the surface's opaque handle. */
 export interface GpuWater {
     /** The ocean: near sheet and far skirt in one buffer. */

package/dist/render/environmentMixing.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The environment a surface reflects brought to the light where it stands: `setEnvironmentMixing`'s
+ * numbers as the lit stage reads them, `uEnvironmentMixing`. Both backends fill it here and upload
+ * it, so a clamp cannot differ between them.
+ *
+ * **The weight is stored less one**, so a program a binder never wrote, all zeros, reflects exactly
+ * as it did before the field existed; the two roughnesses beside it are where the weight is mixed in
+ * between, smooth to rough.
+ */
+/** `uEnvironmentMixing` mixing nothing: a weight of 1, between the default roughnesses. */
+export declare function noEnvironmentMixing(out: Float32Array): Float32Array;
+/**
+ * A caller's weight and roughnesses, into `out`: a weight that is not a number at or above zero is
+ * 1, the roughnesses are held to 0 to 1, and the upper never below the lower.
+ */
+export declare function resolveEnvironmentMixing(weight: number, roughnessLow: number, roughnessHigh: number, out: Float32Array): Float32Array;
+/** The factor a surface of `roughness` reflects by, as the lit stage computes it. */
+export declare function environmentMixingFactor(mixing: ArrayLike<number>, roughness: number): number;

package/dist/render/environmentMixing.js

@@ -0,0 +1,40 @@
+/**
+ * The environment a surface reflects brought to the light where it stands: `setEnvironmentMixing`'s
+ * numbers as the lit stage reads them, `uEnvironmentMixing`. Both backends fill it here and upload
+ * it, so a clamp cannot differ between them.
+ *
+ * **The weight is stored less one**, so a program a binder never wrote, all zeros, reflects exactly
+ * as it did before the field existed; the two roughnesses beside it are where the weight is mixed in
+ * between, smooth to rough.
+ */
+/** `uEnvironmentMixing` mixing nothing: a weight of 1, between the default roughnesses. */
+export function noEnvironmentMixing(out) {
+    out[0] = 0;
+    out[1] = 0.1;
+    out[2] = 0.3;
+    out[3] = 0;
+    return out;
+}
+/**
+ * A caller's weight and roughnesses, into `out`: a weight that is not a number at or above zero is
+ * 1, the roughnesses are held to 0 to 1, and the upper never below the lower.
+ */
+export function resolveEnvironmentMixing(weight, roughnessLow, roughnessHigh, out) {
+    const unit = (value, fallback) => Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : fallback;
+    out[0] = (Number.isFinite(weight) && weight >= 0 ? weight : 1) - 1;
+    const low = unit(roughnessLow, 0.1);
+    out[1] = low;
+    out[2] = Math.max(low, unit(roughnessHigh, 0.3));
+    out[3] = 0;
+    return out;
+}
+/** The factor a surface of `roughness` reflects by, as the lit stage computes it. */
+export function environmentMixingFactor(mixing, roughness) {
+    const less = mixing[0];
+    if (less === 0)
+        return 1;
+    const low = mixing[1];
+    const span = Math.max(mixing[2] - low, 1e-4);
+    const t = Math.min(1, Math.max(0, (roughness - low) / span));
+    return 1 + less * t * t * (3 - 2 * t);
+}