@driftengine/core 4.8.1 → 4.8.3

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

@@ -87,13 +87,18 @@ export declare const DEPTH_CUTOUT_VERT_FIELDS: {
         readonly size: 8;
         readonly type: "vec2";
     };
-    readonly uAlphaCutout: {
+    readonly uUvOffset: {
         readonly offset: 168;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+    readonly uAlphaCutout: {
+        readonly offset: 176;
         readonly size: 4;
         readonly type: "float";
     };
 };
-export declare const DEPTH_CUTOUT_VERT_SIZE: 176;
+export declare const DEPTH_CUTOUT_VERT_SIZE: 192;
 export declare const DEPTH_INSTANCED_CUTOUT_VERT_FIELDS: {
     readonly uLightViewProj: {
         readonly offset: 0;
@@ -105,8 +110,13 @@ export declare const DEPTH_INSTANCED_CUTOUT_VERT_FIELDS: {
         readonly size: 8;
         readonly type: "vec2";
     };
-    readonly uAlphaCutout: {
+    readonly uUvOffset: {
         readonly offset: 72;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+    readonly uAlphaCutout: {
+        readonly offset: 80;
         readonly size: 4;
         readonly type: "float";
     };

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

@@ -12,9 +12,10 @@ export const DEPTH_VERT_FIELDS = DEPTH_BINDINGS.DEPTH_VERT.fields;
 export const DEPTH_VERT_SIZE = DEPTH_BINDINGS.DEPTH_VERT.uniformSize;
 export const DEPTH_FRAG_SIZE = DEPTH_BINDINGS.DEPTH_FRAG.uniformSize;
 /*
- * The cutout variants' vertex blocks. The rigid one is the plain block with `uUvScale` and
- * `uAlphaCutout` after every other field, so a slot written for it is written with the plain
- * offsets plus these two; the instanced one has no model and no wind, so its two sit earlier.
+ * The cutout variants' vertex blocks. The rigid one is the plain block with `uUvScale`,
+ * `uUvOffset` and `uAlphaCutout` after every other field, so a slot written for it is written with
+ * the plain offsets plus these three; the instanced one has no model and no wind, so its three sit
+ * earlier.
  */
 export const DEPTH_CUTOUT_VERT_FIELDS = DEPTH_BINDINGS.DEPTH_CUTOUT_VERT.fields;
 export const DEPTH_CUTOUT_VERT_SIZE = DEPTH_BINDINGS.DEPTH_CUTOUT_VERT.uniformSize;

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

@@ -3,6 +3,7 @@ import { FILM_BINDINGS, FILM_FRAG_WGSL, FILM_VERT_WGSL, } from '../../shaders/ge
 import { vertexBufferLayouts } from './buffers.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_KEEPS } from '../../sceneCoverage.js';
 /**
  * The film pass: a thin wet layer — an oil slick, a puddle — lying over the world.
  *
@@ -85,7 +86,7 @@ export function filmPipeline(cache, device, layout, key, present) {
                     format: cache.format,
                     blend: {
                         color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-                        alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                        alpha: SCENE_ALPHA_KEEPS,
                     },
                 },
             ],

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

@@ -86,6 +86,11 @@ export declare const FLAT_VERT_FIELDS: {
         readonly size: 8;
         readonly type: "vec2";
     };
+    readonly uUvOffset: {
+        readonly offset: 152;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
     readonly uModel: {
         readonly offset: 160;
         readonly size: 64;

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

@@ -2,6 +2,7 @@ import { DEPTH_COMPARE, DEPTH_FORMAT, depthOffsetForLayer } from '../../depthCon
 import { FLAT_BINDINGS, FLAT_FRAG_WGSL, FLAT_VERT_WGSL, } from '../../shaders/generated/flat.wgsl.js';
 import { vertexBufferLayouts } from './buffers.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /** The material maps the flat pass reads: `2d-array` colour, filtered, not shadow maps. */
 const SURFACE_MAPS = new Set([
     'uAlbedo',
@@ -115,18 +116,27 @@ export function flatFragmentBindings(variant) {
     return found;
 }
 /**
- * The lit fragment stage's constants, set from the cache: the glass switch, keyed by its **id**.
+ * The lit fragment stage's constants, set from the cache's switches, keyed by each one's **id**.
  *
  * Not by its name, because an override declared with `@id` answers to the id alone — WebGPU's
  * "pipeline-overridable constant identifier string" — and naga writes one on every specialisation
  * constant. Keyed by name, Chrome refused every lit pipeline: *Pipeline overridable constant
- * "GLASS_SHADOWS" not found*, and the frame drew nothing.
+ * "GLASS_SHADOWS" not found*, and the frame drew nothing. Every override the variant declares is
+ * set, so a switch added to the shader and not to the cache is refused here rather than defaulted.
  */
 function flatFragmentConstants(variant, cache) {
-    const id = flatFragmentBindings(variant).overrides?.['GLASS_SHADOWS'];
-    if (id === undefined)
+    const overrides = flatFragmentBindings(variant).overrides;
+    if (overrides?.['GLASS_SHADOWS'] === undefined) {
         throw new Error(`flatPass: variant "${variant}" has no glass switch`);
-    return { [String(id)]: cache.glassShadows ? 1 : 0 };
+    }
+    const constants = {};
+    for (const [name, id] of Object.entries(overrides)) {
+        if (!(name in cache.litSwitches)) {
+            throw new Error(`flatPass: variant "${variant}" declares a switch "${name}" no cache sets`);
+        }
+        constants[String(id)] = cache.litSwitches[name] ? 1 : 0;
+    }
+    return constants;
 }
 /** The depth format both backends compare with. */
 /* Re-exported so the twenty passes that already import it from here do not each learn a new
@@ -391,7 +401,7 @@ instanced = false,
 oit = 'none', 
 /** Culls nothing, for a surface seen from both faces. The key must carry it: `|2s`. */
 doubleSided = false) {
-    return cache.get(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed, depthWrite, depthLayer, instanced, oit, doubleSided));
+    return cache.get(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed, depthWrite, depthLayer, instanced, oit, doubleSided), true);
 }
 /**
  * The same pipeline, compiled off the main thread.
@@ -407,7 +417,7 @@ export function flatPipelineAsync(cache, device, layout, variant, key, present,
 skinned = false, 
 /** Whether this pipeline reads morph deltas. See `FlatVertexOptions`. */
 morphed = false) {
-    return cache.getAsync(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed));
+    return cache.getAsync(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed), true);
 }
 /**
  * The colour target for an order-independent pass, or null where this is an ordinary draw.
@@ -508,7 +518,7 @@ doubleSided = false) {
                                         dstFactor: 'one-minus-src-alpha',
                                         operation: 'add',
                                     },
-                                    alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                                    alpha: SCENE_ALPHA_COVERS,
                                 },
                             }
                             : { format: cache.format }),

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

@@ -3,6 +3,7 @@ import { LINE_BINDINGS, LINE_FRAG_WGSL, LINE_VERT_WGSL, } from '../../shaders/ge
 import { buildSegmentQuads } from '../../segmentQuads.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /**
  * The line pass: a polyline with a real width, four vertices a segment.
  *
@@ -179,7 +180,7 @@ additive = false) {
                                 dstFactor: 'one-minus-src-alpha',
                                 operation: 'add',
                             },
-                            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                            alpha: SCENE_ALPHA_COVERS,
                         },
                 },
             ],

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

@@ -1,6 +1,7 @@
 import { PANEL_BINDINGS, PANEL_FRAG_WGSL, PANEL_VERT_WGSL, } from '../../shaders/generated/panel.wgsl.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /**
  * The panel pass: two triangles in screen space, one colour, one alpha.
  *
@@ -97,7 +98,7 @@ export function panelPipeline(cache, device, layout) {
                     format: cache.format,
                     blend: {
                         color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-                        alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                        alpha: SCENE_ALPHA_COVERS,
                     },
                 },
             ],

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

@@ -4,6 +4,7 @@ import { PARTICLE_BINDINGS } from '../../shaders/generated/particle.wgsl.js';
 import { PARTICLE_BLADES, PARTICLE_INDICES, PARTICLE_VERTS } from '../../shaders/particle.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /**
  * The particle pass: a crossed pair of quads per live particle, rebuilt every frame.
  *
@@ -269,7 +270,7 @@ export function particlePipeline(cache, device, layout, material, blend) {
                                 dstFactor: 'one-minus-src-alpha',
                                 operation: 'add',
                             },
-                            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                            alpha: SCENE_ALPHA_COVERS,
                         },
                 },
             ],

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

@@ -1,3 +1,5 @@
+import { type LitSwitch } from '../../shaders/flat/glassTint.ts';
+export type { LitSwitch };
 /**
  * Render pipelines, built once and looked up by name.
  *
@@ -33,14 +35,27 @@ export declare class PipelineCache {
      */
     readonly sampleCount: number;
     /**
-     * Whether the lit pipelines here read glass in their shadows: `glassShadows` other than `'off'`.
+     * Which of the lit stage's switches the pipelines built now have on: the pipeline-overridable
+     * constants the generated lit shader branches on (`GLASS_SHADOWS` and `litSwitchesGlsl`), which
+     * the device compiles away where they are off. Read by `flatPass` when it describes a pipeline.
      *
-     * **Carried by the cache for the reason the format is**: one value every lit pipeline is built
-     * with, chosen once by the renderer. It is the `GLASS_SHADOWS` override the generated lit shader
-     * branches on (see `FlatShaderOptions.glassShadows`), so off specialises the lookups away rather
-     * than leaving code that returns at its first line and still costs the pass its registers.
+     * **Each is code a scene pays for in every lit pixel's registers whether it uses it or not**, so
+     * each is off until it is used: glass until the renderer is offered a pane, a fixture until one is
+     * loaded, the effects until a material carries a table, DriftLight until a volume is set — and
+     * then on for good, through `enable`. Clustering is the profile's, fixed at construction. Every
+     * scene paid for all of it from 4.5.0 to 4.8.1, and on a phone that was the lit pass: about 30%
+     * of the lit shader's instructions for glass alone, measured on RADV. **What it costs** is the
+     * frames between a feature's first use and its recompiled pipelines, which draw without it.
      */
+    readonly litSwitches: Record<LitSwitch, boolean>;
+    /** Whether glass may ever be switched on here: `glassShadows` other than `'off'`. */
     readonly glassShadows: boolean;
+    /** How to describe each lit pipeline again, so `enable` can rebuild every one. */
+    private readonly litDescribers;
+    /** Bumped by every switch, so a lit build started before one is not kept after it. */
+    private litGeneration;
+    /** The last rebuild, which the next one waits for so they land in the order they were asked. */
+    private litRebuild;
     private readonly device;
     private readonly pipelines;
     /**
@@ -58,7 +73,9 @@ export declare class PipelineCache {
      * wait for readiness rather than discovering it mid-frame.
      */
     private readonly compiling;
-    constructor(device: GPUDevice, format: GPUTextureFormat, sampleCount?: number, glassShadows?: boolean);
+    constructor(device: GPUDevice, format: GPUTextureFormat, sampleCount?: number, glassShadows?: boolean, 
+    /** The profile's `clusteredLights`, which compiles the clustered arm in or leaves it out. */
+    clusteredLights?: boolean);
     /** How many distinct pipelines have been built. Read by tests and diagnostics. */
     get size(): number;
     /**
@@ -69,7 +86,9 @@ export declare class PipelineCache {
      * difference is only *when* the driver does the work, and that difference is the whole bug
      * this exists for.
      */
-    getAsync(key: string, describe: () => GPURenderPipelineDescriptor): Promise<GPURenderPipeline>;
+    getAsync(key: string, describe: () => GPURenderPipelineDescriptor, 
+    /** Whether this is a lit pipeline, which `enable` rebuilds. See `litSwitches`. */
+    lit?: boolean): Promise<GPURenderPipeline>;
     /**
      * Resolve once every pipeline asked for so far has finished compiling.
      *
@@ -90,7 +109,20 @@ export declare class PipelineCache {
      * too**: a nested object with vertex buffer layouts and blend state, constructed to be
      * thrown away on every hit. Passing a function means a hit costs one `Map` lookup.
      */
-    get(key: string, describe: () => GPURenderPipelineDescriptor): GPURenderPipeline;
+    get(key: string, describe: () => GPURenderPipelineDescriptor, 
+    /** Whether this is a lit pipeline, which `enable` rebuilds. See `litSwitches`. */
+    lit?: boolean): GPURenderPipeline;
+    /**
+     * Turn one of the lit stage's switches on, for every lit pipeline built from now on and every one
+     * already built. See `litSwitches`.
+     *
+     * **The rebuilt set lands at once**, when every one of them has compiled, so no frame draws some
+     * surfaces with a feature and others without. Until then the pipelines already built go on drawing
+     * as they were. Once only: a switch is not turned off again when the last user of it leaves,
+     * because a second switch would cost a second compile for a saving the first use showed was not
+     * needed. Glass is never turned on where the profile asked for no glass shadows.
+     */
+    enable(feature: LitSwitch): Promise<void>;
     /**
      * Drop every pipeline.
      *

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

@@ -1,3 +1,4 @@
+import { noLitSwitches } from '../../shaders/flat/glassTint.js';
 /**
  * Render pipelines, built once and looked up by name.
  *
@@ -33,14 +34,27 @@ export class PipelineCache {
      */
     sampleCount;
     /**
-     * Whether the lit pipelines here read glass in their shadows: `glassShadows` other than `'off'`.
+     * Which of the lit stage's switches the pipelines built now have on: the pipeline-overridable
+     * constants the generated lit shader branches on (`GLASS_SHADOWS` and `litSwitchesGlsl`), which
+     * the device compiles away where they are off. Read by `flatPass` when it describes a pipeline.
      *
-     * **Carried by the cache for the reason the format is**: one value every lit pipeline is built
-     * with, chosen once by the renderer. It is the `GLASS_SHADOWS` override the generated lit shader
-     * branches on (see `FlatShaderOptions.glassShadows`), so off specialises the lookups away rather
-     * than leaving code that returns at its first line and still costs the pass its registers.
+     * **Each is code a scene pays for in every lit pixel's registers whether it uses it or not**, so
+     * each is off until it is used: glass until the renderer is offered a pane, a fixture until one is
+     * loaded, the effects until a material carries a table, DriftLight until a volume is set — and
+     * then on for good, through `enable`. Clustering is the profile's, fixed at construction. Every
+     * scene paid for all of it from 4.5.0 to 4.8.1, and on a phone that was the lit pass: about 30%
+     * of the lit shader's instructions for glass alone, measured on RADV. **What it costs** is the
+     * frames between a feature's first use and its recompiled pipelines, which draw without it.
      */
+    litSwitches = noLitSwitches();
+    /** Whether glass may ever be switched on here: `glassShadows` other than `'off'`. */
     glassShadows;
+    /** How to describe each lit pipeline again, so `enable` can rebuild every one. */
+    litDescribers = new Map();
+    /** Bumped by every switch, so a lit build started before one is not kept after it. */
+    litGeneration = 0;
+    /** The last rebuild, which the next one waits for so they land in the order they were asked. */
+    litRebuild = Promise.resolve();
     device;
     pipelines = new Map();
     /**
@@ -58,11 +72,14 @@ export class PipelineCache {
      * wait for readiness rather than discovering it mid-frame.
      */
     compiling = new Map();
-    constructor(device, format, sampleCount = 1, glassShadows = true) {
+    constructor(device, format, sampleCount = 1, glassShadows = true, 
+    /** The profile's `clusteredLights`, which compiles the clustered arm in or leaves it out. */
+    clusteredLights = false) {
         this.device = device;
         this.format = format;
         this.sampleCount = sampleCount;
         this.glassShadows = glassShadows;
+        this.litSwitches.CLUSTERED_LIGHTS = clusteredLights;
     }
     /** How many distinct pipelines have been built. Read by tests and diagnostics. */
     get size() {
@@ -76,13 +93,18 @@ export class PipelineCache {
      * difference is only *when* the driver does the work, and that difference is the whole bug
      * this exists for.
      */
-    async getAsync(key, describe) {
+    async getAsync(key, describe, 
+    /** Whether this is a lit pipeline, which `enable` rebuilds. See `litSwitches`. */
+    lit = false) {
+        if (lit)
+            this.litDescribers.set(key, describe);
         const existing = this.pipelines.get(key);
         if (existing !== undefined)
             return existing;
         const inFlight = this.compiling.get(key);
         if (inFlight !== undefined)
             return inFlight;
+        const generation = this.litGeneration;
         /*
          * **Falls back where the async form is missing.** It is part of the standard, but a device
          * can be a test double, a polyfill or an older implementation, and a renderer that throws
@@ -94,7 +116,9 @@ export class PipelineCache {
             ? this.device.createRenderPipelineAsync(describe())
             : Promise.resolve(this.device.createRenderPipeline(describe()));
         const promise = build.then((built) => {
-            this.pipelines.set(key, built);
+            /* A lit pipeline started before a switch is not kept: the switch rebuilds it. */
+            if (!lit || generation === this.litGeneration)
+                this.pipelines.set(key, built);
             this.compiling.delete(key);
             return built;
         });
@@ -129,7 +153,11 @@ export class PipelineCache {
      * too**: a nested object with vertex buffer layouts and blend state, constructed to be
      * thrown away on every hit. Passing a function means a hit costs one `Map` lookup.
      */
-    get(key, describe) {
+    get(key, describe, 
+    /** Whether this is a lit pipeline, which `enable` rebuilds. See `litSwitches`. */
+    lit = false) {
+        if (lit)
+            this.litDescribers.set(key, describe);
         const existing = this.pipelines.get(key);
         if (existing !== undefined)
             return existing;
@@ -137,6 +165,45 @@ export class PipelineCache {
         this.pipelines.set(key, built);
         return built;
     }
+    /**
+     * Turn one of the lit stage's switches on, for every lit pipeline built from now on and every one
+     * already built. See `litSwitches`.
+     *
+     * **The rebuilt set lands at once**, when every one of them has compiled, so no frame draws some
+     * surfaces with a feature and others without. Until then the pipelines already built go on drawing
+     * as they were. Once only: a switch is not turned off again when the last user of it leaves,
+     * because a second switch would cost a second compile for a saving the first use showed was not
+     * needed. Glass is never turned on where the profile asked for no glass shadows.
+     */
+    enable(feature) {
+        if (this.litSwitches[feature])
+            return this.litRebuild;
+        if (feature === 'GLASS_SHADOWS' && !this.glassShadows)
+            return this.litRebuild;
+        this.litSwitches[feature] = true;
+        this.litGeneration += 1;
+        const generation = this.litGeneration;
+        this.litRebuild = this.litRebuild.then(async () => {
+            /* A later switch has its own rebuild, which describes every pipeline with this one on too. */
+            if (generation !== this.litGeneration)
+                return;
+            const rebuilt = [...this.litDescribers].map(([key, describe]) => {
+                const descriptor = describe();
+                const build = typeof this.device.createRenderPipelineAsync === 'function'
+                    ? this.device.createRenderPipelineAsync(descriptor)
+                    : Promise.resolve(this.device.createRenderPipeline(descriptor));
+                return build.then((pipeline) => [key, pipeline]);
+            });
+            const results = await Promise.allSettled(rebuilt);
+            if (generation !== this.litGeneration)
+                return;
+            for (const result of results) {
+                if (result.status === 'fulfilled')
+                    this.pipelines.set(result.value[0], result.value[1]);
+            }
+        });
+        return this.litRebuild;
+    }
     /**
      * Drop every pipeline.
      *

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

@@ -6,6 +6,7 @@ import { FIRE_BINDINGS } from '../../shaders/generated/fire.wgsl.js';
 import { SMOKE_BINDINGS } from '../../shaders/generated/smoke.wgsl.js';
 import { DEPTH_FORMAT } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.js';
 /**
  * The plume pass: crossed quads per plume, displaced and faded in the shaders.
  *
@@ -179,7 +180,7 @@ function blendState(blend) {
         }
         : {
             color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+            alpha: SCENE_ALPHA_COVERS,
         };
 }
 /**

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

@@ -156,8 +156,10 @@ export declare const OIT_COMPOSITE_BLEND: GPUBlendState;
  * exactly the integral — and the composite therefore never samples the colour it is modifying,
  * which is the read both backends are entitled to call undefined.
  *
- * Alpha is `(zero, one)`: the frame's own alpha is not the medium's to spend. The scene target
- * carries it to the canvas, and a medium that wrote there would make a foggy frame translucent.
+ * Alpha is the transmittance again, `share * a`: the scene's alpha is how much of the pixel is
+ * still the opaque surface, which is what the composite lets ambient occlusion darken, and a
+ * medium thick enough to hide a corner hides its occlusion too (`sceneCoverage.ts`). It reaches
+ * no canvas: both are opaque, and the composite writes 1.
  */
 export declare const MEDIUM_TRANSMIT_BLEND: GPUBlendState;
 export declare const DECAL_MULTIPLY_BLEND: GPUBlendState;
@@ -170,6 +172,14 @@ export declare const DECAL_MULTIPLY_BLEND: GPUBlendState;
  * sample the colour it is compositing onto.
  */
 export declare const PREMULTIPLIED_OVER_BLEND: GPUBlendState;
+/**
+ * The same `over` for the resolve that lands a reflection on the scene, keeping the scene's alpha.
+ *
+ * A reflection is a layer of the surface it is seen in, so the surface's share of the pixel is
+ * unchanged (`sceneCoverage.ts`). The trace keeps `PREMULTIPLIED_OVER_BLEND`, because its target is
+ * the reflection's own and its alpha is the coverage this resolve reads.
+ */
+export declare const REFLECTION_OVER_BLEND: GPUBlendState;
 export declare const ADDITIVE_BLEND: GPUBlendState;
 /** A fullscreen pass over one or more inputs, writing to one colour target. */
 export declare function postPipeline(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, format: GPUTextureFormat, blend?: GPUBlendState): GPURenderPipeline;

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

@@ -9,6 +9,7 @@ import { SSRTRACE_BINDINGS as SSR_BINDINGS, SSR_TRACE_FRAG_WGSL, } from '../../s
 import { SSRRESOLVE_BINDINGS as SSR_RESOLVE_BINDINGS, SSR_RESOLVE_FRAG_WGSL, } from '../../shaders/generated/ssrResolve.wgsl.js';
 import { GLOBALMEDIUM_BINDINGS as MEDIUM_BINDINGS, MEDIUM_FRAG_WGSL, MEDIUM_UPSAMPLE_FRAG_WGSL, } from '../../shaders/generated/globalMedium.wgsl.js';
 import { shaderModule } from './shaderModules.js';
+import { SCENE_ALPHA_KEEPS, SCENE_ALPHA_TRANSMITS } from '../../sceneCoverage.js';
 /**
  * The composite: everything that happens to the frame after the world is drawn.
  *
@@ -197,7 +198,7 @@ export function createPostStageLayout(device, uniformBinding, uniformSize, textu
  */
 export const OIT_COMPOSITE_BLEND = {
     color: { srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha', operation: 'add' },
-    alpha: { srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha', operation: 'add' },
+    alpha: SCENE_ALPHA_TRANSMITS,
 };
 /**
  * What a drawn decal does to the pixel under it: `dst * src`.
@@ -215,16 +216,18 @@ export const OIT_COMPOSITE_BLEND = {
  * exactly the integral — and the composite therefore never samples the colour it is modifying,
  * which is the read both backends are entitled to call undefined.
  *
- * Alpha is `(zero, one)`: the frame's own alpha is not the medium's to spend. The scene target
- * carries it to the canvas, and a medium that wrote there would make a foggy frame translucent.
+ * Alpha is the transmittance again, `share * a`: the scene's alpha is how much of the pixel is
+ * still the opaque surface, which is what the composite lets ambient occlusion darken, and a
+ * medium thick enough to hide a corner hides its occlusion too (`sceneCoverage.ts`). It reaches
+ * no canvas: both are opaque, and the composite writes 1.
  */
 export const MEDIUM_TRANSMIT_BLEND = {
     color: { srcFactor: 'one', dstFactor: 'src-alpha', operation: 'add' },
-    alpha: { srcFactor: 'zero', dstFactor: 'one', operation: 'add' },
+    alpha: SCENE_ALPHA_TRANSMITS,
 };
 export const DECAL_MULTIPLY_BLEND = {
     color: { srcFactor: 'zero', dstFactor: 'src', operation: 'add' },
-    alpha: { srcFactor: 'zero', dstFactor: 'src', operation: 'add' },
+    alpha: SCENE_ALPHA_KEEPS,
 };
 /**
  * `over`, against colour a pass has already multiplied by its own coverage.
@@ -238,6 +241,17 @@ export const PREMULTIPLIED_OVER_BLEND = {
     color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
     alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
 };
+/**
+ * The same `over` for the resolve that lands a reflection on the scene, keeping the scene's alpha.
+ *
+ * A reflection is a layer of the surface it is seen in, so the surface's share of the pixel is
+ * unchanged (`sceneCoverage.ts`). The trace keeps `PREMULTIPLIED_OVER_BLEND`, because its target is
+ * the reflection's own and its alpha is the coverage this resolve reads.
+ */
+export const REFLECTION_OVER_BLEND = {
+    color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+    alpha: SCENE_ALPHA_KEEPS,
+};
 export const ADDITIVE_BLEND = {
     color: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },
     alpha: { srcFactor: 'one', dstFactor: 'one', operation: 'add' },