@driftengine/core 4.13.3 → 4.13.5

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

@@ -278,7 +278,7 @@ export class GpuClothSet {
         u[base + 32] = garment.range.colliderBase;
         u[base + 33] = garment.range.colliders;
         u[base + 34] = garment.particles.width;
-        f[base + 35] = 1 / (1 + p.pull * h * h);
+        f[base + 35] = p.pull * h * h;
         f[base + 36] = exactExp(p.damping * h);
         f[base + 37] = exactExp(p.drag * h);
         f[base + 38] = p.maxDistanceScale;

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

@@ -123,11 +123,11 @@ export const VERTEX_FLOATS = GPU_DRIVEN_VERTEX_FLOATS;
 /**
  * Floats the shading pass's frame block holds. Matches `FRAME_BLOCK_WGSL`'s `Frame`.
  *
- * Two matrices and fifteen vectors: the camera's, the light's, then the eye, the light's direction
+ * Two matrices and eighteen vectors: the camera's, the light's, then the eye, the light's direction
  * and colour, the sky, the ground, the target's size, the shadow's settings in two, the probe's in
- * two, the medium's four, and the visibility buffer's row.
+ * two, the medium's four, the visibility buffer's row, and the medium's last three after it.
  */
-const FRAME_FLOATS = 92;
+const FRAME_FLOATS = 104;
 /** Where each block starts in it, so the writer and the shader cannot drift apart. */
 const FRAME_LIGHT_VIEW_PROJ = 16;
 const FRAME_EYE = 32;
@@ -145,6 +145,9 @@ const FRAME_FOG_UNDERWATER = 76;
 const FRAME_FOG_HEIGHT = 80;
 const FRAME_FOG_RANGE = 84;
 const FRAME_PITCH = 88;
+const FRAME_FOG_LIMITS = 92;
+const FRAME_FOG_GLOW = 96;
+const FRAME_FOG_GLOW_DIR = 100;
 /**
  * Pixels the internal width is rounded up to.
  *
@@ -2168,6 +2171,20 @@ export class GpuDrivenPass {
         params[FRAME_FOG_RANGE + 1] = fog?.far ?? 0;
         params[FRAME_FOG_RANGE + 2] = fog?.mode ?? MEDIUM_FOG;
         params[FRAME_FOG_RANGE + 3] = fog?.underwaterDensity ?? 0;
+        /* The second layer, the floor, the cutoff and the glow: every one none at zero, as a view
+           written before they existed asks. */
+        params[FRAME_FOG_HEIGHT + 2] = fog?.density2 ?? 0;
+        params[FRAME_FOG_HEIGHT + 3] = fog?.heightFalloff2 ?? 0;
+        params[FRAME_FOG_LIMITS] = fog?.floor ?? 0;
+        params[FRAME_FOG_LIMITS + 1] = fog?.cutoff ?? 0;
+        params[FRAME_FOG_GLOW] = fog?.glowColour?.[0] ?? 0;
+        params[FRAME_FOG_GLOW + 1] = fog?.glowColour?.[1] ?? 0;
+        params[FRAME_FOG_GLOW + 2] = fog?.glowColour?.[2] ?? 0;
+        params[FRAME_FOG_GLOW + 3] = fog?.glowExponent ?? 1;
+        params[FRAME_FOG_GLOW_DIR] = fog?.glowDirection?.[0] ?? 0;
+        params[FRAME_FOG_GLOW_DIR + 1] = fog?.glowDirection?.[1] ?? 1;
+        params[FRAME_FOG_GLOW_DIR + 2] = fog?.glowDirection?.[2] ?? 0;
+        params[FRAME_FOG_GLOW_DIR + 3] = fog?.glowStart ?? 0;
         /* The scene's own decision about whether its grid supplies the ambient, as it is on the
            forward path: `ProbeBakeOptions.irradiance` reaches here as `PassEnvironment.irradiance`. */
         params[FRAME_ENVIRONMENT_MIX] = room !== null && room.irradiance ? 1 : 0;

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

@@ -29,7 +29,7 @@ import type { PipelineCache } from './pipelineCache.ts';
 export declare const LINE_VERT_FIELDS: UniformFields;
 export declare const LINE_VERT_SIZE: 160;
 export declare const LINE_FRAG_FIELDS: UniformFields;
-export declare const LINE_FRAG_SIZE: 112;
+export declare const LINE_FRAG_SIZE: 160;
 /** A polyline batch on the device, behind the surface's opaque handle. */
 export interface GpuLines {
     readonly fromBuffer: GPUBuffer;

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

@@ -0,0 +1,17 @@
+/**
+ * The medium's fields, every uniform `shaders/fog.ts` declares, written into a pass's block by name
+ * from one resolved atmosphere.
+ *
+ * **One writer for every pass that fogs.** Ten passes wrote the same ten fields by hand, so a field
+ * the medium grows was ten places to remember and a pass that missed one read zero: the fourth
+ * point of the rule `AGENTS.md` dates 2026-08-13. A field a pass's shader never reads is compiled
+ * out of its block, so each is written only where the block holds it. An absent field is not an
+ * offset of zero, which is the first field of the block.
+ */
+import type { ResolvedAtmosphere } from '../../atmosphere.ts';
+import type { UniformFields } from './scatterPass.ts';
+import type { UniformRing } from './uniformRing.ts';
+/** Into a block staged as floats, indexed in four-byte words. */
+export declare function writeMediumFields(fields: UniformFields, f: Float32Array, m: ResolvedAtmosphere): void;
+/** Into one slot of a ring, at the fields' byte offsets. */
+export declare function writeMediumSlot(ring: UniformRing, slot: number, fields: UniformFields, m: ResolvedAtmosphere): void;

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

@@ -0,0 +1,74 @@
+/** A field's byte offset in the block, or -1 where the shader compiled it out. */
+function placed(fields, name) {
+    return fields[name]?.offset ?? -1;
+}
+/** Into a block staged as floats, indexed in four-byte words. */
+export function writeMediumFields(fields, f, m) {
+    let at = placed(fields, 'uFogColor');
+    if (at >= 0)
+        f.set(m.fogColor, at / 4);
+    at = placed(fields, 'uFogMedium');
+    if (at >= 0) {
+        f[at / 4] = m.fogDensity;
+        f[at / 4 + 1] = m.fogHeightFalloff;
+        f[at / 4 + 2] = m.fogEyeY;
+        f[at / 4 + 3] = m.underwaterFogDensity;
+    }
+    at = placed(fields, 'uFogRange');
+    if (at >= 0) {
+        f[at / 4] = m.fogNear;
+        f[at / 4 + 1] = m.fogFar;
+        f[at / 4 + 2] = m.fogMode;
+        f[at / 4 + 3] = 0;
+    }
+    at = placed(fields, 'uUnderwaterColor');
+    if (at >= 0)
+        f.set(m.underwaterColor, at / 4);
+    at = placed(fields, 'uUnderwaterFactor');
+    if (at >= 0)
+        f[at / 4] = m.underwaterFactor;
+    at = placed(fields, 'uFogLayer2');
+    if (at >= 0)
+        f.set(m.fogLayer2, at / 4);
+    at = placed(fields, 'uFogGlow');
+    if (at >= 0)
+        f.set(m.fogGlow, at / 4);
+    at = placed(fields, 'uFogGlowDir');
+    if (at >= 0)
+        f.set(m.fogGlowDir, at / 4);
+}
+/** Into one slot of a ring, at the fields' byte offsets. */
+export function writeMediumSlot(ring, slot, fields, m) {
+    let at = placed(fields, 'uFogColor');
+    if (at >= 0)
+        ring.writeFloats(slot, at, m.fogColor);
+    at = placed(fields, 'uFogMedium');
+    if (at >= 0) {
+        ring.writeFloat(slot, at, m.fogDensity);
+        ring.writeFloat(slot, at + 4, m.fogHeightFalloff);
+        ring.writeFloat(slot, at + 8, m.fogEyeY);
+        ring.writeFloat(slot, at + 12, m.underwaterFogDensity);
+    }
+    at = placed(fields, 'uFogRange');
+    if (at >= 0) {
+        ring.writeFloat(slot, at, m.fogNear);
+        ring.writeFloat(slot, at + 4, m.fogFar);
+        ring.writeFloat(slot, at + 8, m.fogMode);
+        ring.writeFloat(slot, at + 12, 0);
+    }
+    at = placed(fields, 'uUnderwaterColor');
+    if (at >= 0)
+        ring.writeFloats(slot, at, m.underwaterColor);
+    at = placed(fields, 'uUnderwaterFactor');
+    if (at >= 0)
+        ring.writeFloat(slot, at, m.underwaterFactor);
+    at = placed(fields, 'uFogLayer2');
+    if (at >= 0)
+        ring.writeFloats(slot, at, m.fogLayer2);
+    at = placed(fields, 'uFogGlow');
+    if (at >= 0)
+        ring.writeFloats(slot, at, m.fogGlow);
+    at = placed(fields, 'uFogGlowDir');
+    if (at >= 0)
+        ring.writeFloats(slot, at, m.fogGlowDir);
+}

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

@@ -15,9 +15,9 @@ export declare const PLUME_VERT_SIZE: 112;
 export declare const PLUME_FRAG_FIELDS: UniformFields;
 export declare const PLUME_FRAG_SIZE: number;
 /** Each material's own block, so a change to one and not the others is caught rather than assumed. */
-export declare const FIRE_FRAG_SIZE: 128;
-export declare const SMOKE_FRAG_SIZE: 128;
-export declare const ARCANE_FRAG_SIZE: 144;
+export declare const FIRE_FRAG_SIZE: 176;
+export declare const SMOKE_FRAG_SIZE: 176;
+export declare const ARCANE_FRAG_SIZE: 192;
 export declare function plumeVertexLayouts(): GPUVertexBufferLayout[];
 /** Plume geometry on the device, behind the surface's opaque handle. */
 export interface GpuPlumes {

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

@@ -26,7 +26,7 @@ import type { PipelineCache } from './pipelineCache.ts';
  * float target the generated shaders can sample as an ordinary texture.
  */
 export declare const RUSH_FRAG_FIELDS: UniformFields;
-export declare const RUSH_FRAG_SIZE: 288;
+export declare const RUSH_FRAG_SIZE: 320;
 declare const RUSH_UNIFORMS: 1;
 declare const RUSH_TEXTURES: {
     readonly uScene: {
@@ -75,7 +75,7 @@ export declare const AO_FRAG_SIZE: 96;
 export declare const AO_BLUR_FIELDS: UniformFields;
 export declare const AO_BLUR_SIZE: 48;
 export declare const MEDIUM_FRAG_FIELDS: UniformFields;
-export declare const MEDIUM_FRAG_SIZE: 304;
+export declare const MEDIUM_FRAG_SIZE: 2400;
 export declare const MEDIUM_UPSAMPLE_FIELDS: UniformFields;
 export declare const MEDIUM_UPSAMPLE_SIZE: 48;
 export declare const BLOOM_PREFILTER_FIELDS: UniformFields;
@@ -369,6 +369,11 @@ export declare const MEDIUM_TEXTURES: {
         readonly sampler: 35;
         readonly type: "sampler2DArray";
     };
+    readonly uPointShadows: {
+        readonly texture: 36;
+        readonly sampler: 37;
+        readonly type: "sampler2DArray";
+    };
 };
 export declare const MEDIUM_UPSAMPLE_UNIFORMS: 1;
 export declare const MEDIUM_UPSAMPLE_TEXTURES: {

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

@@ -35,6 +35,7 @@ import type { SurfaceMaterial, SurfaceTextureOptions } from '../../surfaceTextur
 import type { RenderBackend } from '../api.ts';
 import { type DisplayRange } from '../../displayRange.ts';
 import { type FilmicCurve } from '../../filmicCurve.ts';
+import type { LocalExposureOptions } from '../../shaders/localExposure.ts';
 import { type ColourGradeLut } from '../../colourGrade.ts';
 import type { CausticSheet } from '../../causticsRenderer.ts';
 import { type GpuCaustics } from './causticsPass.ts';
@@ -45,6 +46,7 @@ import type { DeviceParticles, ParticleInstances } from '../../particlePool.ts';
 import type { PlumeOptions, PlumePlacement } from '../../plumeRenderer.ts';
 import type { InstanceData } from '../../instancedMesh.ts';
 import { type RenderQuality } from '../../renderQuality.ts';
+import type { GlobalMediumSettings } from '../../globalMedium.ts';
 import type { MeshData } from '../../mesh.ts';
 import type { ShadowCasters } from '../../shadowCasters.ts';
 import { type GpuMesh } from './buffers.ts';
@@ -724,6 +726,9 @@ export declare class WebGPURenderer implements RendererApi {
     private readonly mediumInvProjection;
     /** This frame's medium. Off until a caller says otherwise. See `setGlobalMedium`. */
     private mediumOptions;
+    /** The lamps the medium is lit by, and the lit stage's lamps they come from, refilled a frame. */
+    private readonly mediumLamps;
+    private readonly mediumLights;
     /**
      * The temporal resolve: its block, its ping-pong pair, and the jitter state.
      *
@@ -1412,6 +1417,10 @@ export declare class WebGPURenderer implements RendererApi {
     setSurfaceReflectivity(amount: number): void;
     /** How bright the environment the surfaces drawn next reflect is. See `renderer.ts`. */
     setEnvironmentGain(gain: number): void;
+    /** The environment brought to the light where a surface stands. See `renderer.ts`. */
+    setEnvironmentMixing(weight: number, roughnessLow?: number, roughnessHigh?: number): void;
+    /** `uEnvironmentMixing` as it stands; none until a draw asks. See `setEnvironmentMixing`. */
+    private readonly environmentMixing;
     /**
      * 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
@@ -3980,8 +3989,9 @@ export declare class WebGPURenderer implements RendererApi {
     /** Eye adaptation: how far, this frame's time step, and the pass once asked for. */
     private autoExposure;
     private autoExposureDt;
-    /** How far each region is brought toward the frame. See `setLocalExposure`. */
+    /** Whether regions move, and how, as `resolveLocalExposure` packs it. See `setLocalExposure`. */
     private localExposure;
+    private readonly localExposureShape;
     private exposurePass;
     /**
      * How strongly the lens darkens the frame's corners, held until changed: 0 is none, 0.5 is about
@@ -4039,7 +4049,7 @@ export declare class WebGPURenderer implements RendererApi {
      * version is that `density` is extinction per metre, 0 is a real off that allocates nothing and
      * draws nothing, and the three optional arguments are held until changed.
      */
-    setGlobalMedium(density: number, albedo?: number, anisotropy?: number, maxDistance?: number): void;
+    setGlobalMedium(density: number | GlobalMediumSettings, albedo?: number | Vec3, anisotropy?: number, maxDistance?: number): void;
     /** How much speed blur the frame should resolve with, 0 to 1. */
     setSpeedRush(strength: number): void;
     /**
@@ -4083,7 +4093,7 @@ export declare class WebGPURenderer implements RendererApi {
      * the same setter over the same state, sharing eye adaptation's pass, which is built the first
      * time either is asked for.
      */
-    setLocalExposure(strength: number): void;
+    setLocalExposure(setting: number | LocalExposureOptions): void;
     /** The exposure pass, built once; the composite's group holds placeholders until it exists. */
     private ensureExposurePass;
     /**