@woosh/meep-engine 3.46.0 → 3.49.0

package/src/shade/renderer/shader/compiler/ShaderSwitch.d.ts

@@ -0,0 +1,86 @@
+/**
+ * A choice a pipeline makes, when it is created, between implementations of part of its shader: the
+ * directional shadow technique, the indirect lighting mode.
+ *
+ * Made one of two ways, which share everything else:
+ *
+ * ```js
+ * export const ShadowDirectionalTechnique = { Cascades: 0, Virtual: 1 };
+ * export const SHADOW_DIRECTIONAL_TECHNIQUE = ShaderSwitch.enum('shadow directional technique', ShadowDirectionalTechnique);
+ *
+ * export const SOME_FEATURE = ShaderSwitch.bool('some feature');
+ * ```
+ *
+ * A switch's values are its own: the members of its enum, or `false` and `true`. Every switch has the
+ * value `0` — `false` for a bool — unless a {@link ShaderSwitchSet} says otherwise.
+ *
+ * The switch only names the choice. The code each value links is said where a chunk graph makes the
+ * choice, by a {@link CodeChunkChoice}, and one switch can be decided at several such places from the
+ * one value.
+ */
+export class ShaderSwitch {
+    /**
+     * @param {string} label
+     * @param {ReadonlyArray<number|boolean>} values
+     * @param {ReadonlyArray<string>} names
+     * @param {number|boolean} default_value
+     * @returns {ShaderSwitch}
+     */
+    static "__#69@#make"(label: string, values: ReadonlyArray<number | boolean>, names: ReadonlyArray<string>, default_value: number | boolean): ShaderSwitch;
+    /**
+     * A switch over the members of an engine enum: a plain object of names to distinct integers, one of
+     * which is `0` — the value every switch has until a set says otherwise.
+     *
+     * @param {string} label names the switch in errors, pipeline labels and tooling
+     * @param {Object<number>} values the enum, e.g. `ShadeIndirectLightingMode`
+     * @returns {ShaderSwitch}
+     */
+    static enum(label: string, values: any): ShaderSwitch;
+    /**
+     * A switch that is on or off: `false` by default.
+     *
+     * @param {string} label names the switch in errors, pipeline labels and tooling
+     * @returns {ShaderSwitch}
+     */
+    static bool(label: string): ShaderSwitch;
+    /**
+     * @returns {number}
+     */
+    get id(): number;
+    /**
+     * @returns {string}
+     */
+    get label(): string;
+    /**
+     * @returns {ReadonlyArray<number|boolean>}
+     */
+    get values(): readonly (number | boolean)[];
+    /**
+     * What the switch is when a set does not say: `0`, or `false` for a bool.
+     * @returns {number|boolean}
+     */
+    get default_value(): number | boolean;
+    /**
+     * @param {*} value
+     * @returns {number} the value's position in {@link values}, or -1 when it is not one of them
+     */
+    index_of(value: any): number;
+    /**
+     * @param {*} value
+     * @returns {boolean}
+     */
+    is_value(value: any): boolean;
+    /**
+     * @param {number|boolean} value one of the switch's values
+     * @returns {string} its name in the enum, or `false`/`true`
+     */
+    name_of(value: number | boolean): string;
+    toString(): string;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isShaderSwitch: boolean;
+    #private;
+}
+//# sourceMappingURL=ShaderSwitch.d.ts.map

package/src/shade/renderer/shader/compiler/ShaderSwitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderSwitch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/compiler/ShaderSwitch.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA2FI;;;;;;OAMG;IACH,4BANW,MAAM,UACN,cAAc,MAAM,GAAC,OAAO,CAAC,SAC7B,cAAc,MAAM,CAAC,iBACrB,MAAM,GAAC,OAAO,GACZ,YAAY,CAWxB;IAED;;;;;;;OAOG;IACH,mBAJW,MAAM,gBAEJ,YAAY,CAmBxB;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACJ,YAAY,CAMxB;IA1ID;;OAEG;IACH,iBAEC;IAOD;;OAEG;IACH,oBAEC;IAQD;;OAEG;IACH,4CAEC;IAaD;;;OAGG;IACH,sCAEC;IAED;;;OAGG;IACH,sBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,sBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,eAHW,MAAM,GAAC,OAAO,GACZ,MAAM,CAQlB;IAED,mBAEC;IA4DL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC"}

package/src/shade/renderer/shader/compiler/ShaderSwitch.js

@@ -0,0 +1,178 @@
+import { assert } from "../../../../core/assert.js";
+
+let id_counter = 0;
+
+/**
+ * A choice a pipeline makes, when it is created, between implementations of part of its shader: the
+ * directional shadow technique, the indirect lighting mode.
+ *
+ * Made one of two ways, which share everything else:
+ *
+ * ```js
+ * export const ShadowDirectionalTechnique = { Cascades: 0, Virtual: 1 };
+ * export const SHADOW_DIRECTIONAL_TECHNIQUE = ShaderSwitch.enum('shadow directional technique', ShadowDirectionalTechnique);
+ *
+ * export const SOME_FEATURE = ShaderSwitch.bool('some feature');
+ * ```
+ *
+ * A switch's values are its own: the members of its enum, or `false` and `true`. Every switch has the
+ * value `0` — `false` for a bool — unless a {@link ShaderSwitchSet} says otherwise.
+ *
+ * The switch only names the choice. The code each value links is said where a chunk graph makes the
+ * choice, by a {@link CodeChunkChoice}, and one switch can be decided at several such places from the
+ * one value.
+ */
+export class ShaderSwitch {
+    /**
+     * Orders switches inside a {@link ShaderSwitchSet}, so that two sets with the same values are one
+     * set. Not meaningful outside the process.
+     * @type {number}
+     */
+    #id = id_counter++;
+
+    /**
+     * @returns {number}
+     */
+    get id() {
+        return this.#id;
+    }
+
+    /**
+     * @type {string}
+     */
+    #label = '';
+
+    /**
+     * @returns {string}
+     */
+    get label() {
+        return this.#label;
+    }
+
+    /**
+     * Every value the switch takes, in declaration order.
+     * @type {ReadonlyArray<number|boolean>}
+     */
+    #values = [];
+
+    /**
+     * @returns {ReadonlyArray<number|boolean>}
+     */
+    get values() {
+        return this.#values;
+    }
+
+    /**
+     * Parallel to {@link #values}.
+     * @type {ReadonlyArray<string>}
+     */
+    #names = [];
+
+    /**
+     * @type {number|boolean}
+     */
+    #default_value = 0;
+
+    /**
+     * What the switch is when a set does not say: `0`, or `false` for a bool.
+     * @returns {number|boolean}
+     */
+    get default_value() {
+        return this.#default_value;
+    }
+
+    /**
+     * @param {*} value
+     * @returns {number} the value's position in {@link values}, or -1 when it is not one of them
+     */
+    index_of(value) {
+        return this.#values.indexOf(value);
+    }
+
+    /**
+     * @param {*} value
+     * @returns {boolean}
+     */
+    is_value(value) {
+        return this.#values.includes(value);
+    }
+
+    /**
+     * @param {number|boolean} value one of the switch's values
+     * @returns {string} its name in the enum, or `false`/`true`
+     */
+    name_of(value) {
+        const index = this.#values.indexOf(value);
+
+        assert.notEqual(index, -1, `${value} is not a value of shader switch '${this.#label}'`);
+
+        return this.#names[index];
+    }
+
+    toString() {
+        return this.#label;
+    }
+
+    /**
+     * @param {string} label
+     * @param {ReadonlyArray<number|boolean>} values
+     * @param {ReadonlyArray<string>} names
+     * @param {number|boolean} default_value
+     * @returns {ShaderSwitch}
+     */
+    static #make(label, values, names, default_value) {
+        const r = new ShaderSwitch();
+
+        r.#label = label;
+        r.#values = Object.freeze(values);
+        r.#names = Object.freeze(names);
+        r.#default_value = default_value;
+
+        return r;
+    }
+
+    /**
+     * A switch over the members of an engine enum: a plain object of names to distinct integers, one of
+     * which is `0` — the value every switch has until a set says otherwise.
+     *
+     * @param {string} label names the switch in errors, pipeline labels and tooling
+     * @param {Object<number>} values the enum, e.g. `ShadeIndirectLightingMode`
+     * @returns {ShaderSwitch}
+     */
+    static enum(label, values) {
+        assert.isString(label, 'label');
+        assert.isObject(values, 'values');
+
+        const names = Object.keys(values);
+        const list = names.map(name => values[name]);
+
+        assert.greaterThanOrEqual(list.length, 2, `enum of shader switch '${label}' has fewer than 2 members`);
+
+        for (let i = 0; i < list.length; i++) {
+            assert.isInteger(list[i], `${label}.${names[i]}`);
+            assert.equal(list.indexOf(list[i]), i, `${label}.${names[i]} repeats the value ${list[i]}`);
+        }
+
+        assert.ok(list.includes(0), `enum of shader switch '${label}' has no member equal to 0, the value a switch has by default`);
+
+        return ShaderSwitch.#make(label, list, names, 0);
+    }
+
+    /**
+     * A switch that is on or off: `false` by default.
+     *
+     * @param {string} label names the switch in errors, pipeline labels and tooling
+     * @returns {ShaderSwitch}
+     */
+    static bool(label) {
+        assert.isString(label, 'label');
+
+        return ShaderSwitch.#make(label, [false, true], ['false', 'true'], false);
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ShaderSwitch.prototype.isShaderSwitch = true;

package/src/shade/renderer/shader/compiler/ShaderSwitchSet.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Values for some {@link ShaderSwitch}es: what a renderer has decided, or what one pipeline asks for.
+ * A switch the set does not name has its {@link ShaderSwitch#default_value}: `0`, or `false` for a bool.
+ *
+ * Immutable and interned: two sets that give every switch the same value are the same object, so a
+ * set is a cache key by identity, and a frame that looks one up allocates nothing. {@link with} and
+ * {@link restricted_to} hand out the one set for their values, making it only the first time.
+ */
+export class ShaderSwitchSet {
+    /**
+     * Every switch at its default.
+     * @type {ShaderSwitchSet}
+     */
+    static EMPTY: ShaderSwitchSet;
+    /**
+     * @param {ShaderSwitch[]} switches in id order, each once
+     * @param {Array<number|boolean>} values none of them its switch's default
+     * @returns {ShaderSwitchSet}
+     */
+    static "__#70@#intern"(switches: ShaderSwitch[], values: Array<number | boolean>): ShaderSwitchSet;
+    /**
+     * The values as one string, the same for the same values. What interning is keyed by.
+     * @returns {string}
+     */
+    get key(): string;
+    /**
+     * How many switches this set gives a value other than their default.
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * @param {number} index below {@link size}
+     * @returns {ShaderSwitch}
+     */
+    switch_at(index: number): ShaderSwitch;
+    /**
+     * @param {number} index below {@link size}
+     * @returns {number|boolean}
+     */
+    value_at(index: number): number | boolean;
+    /**
+     * @param {ShaderSwitch} shader_switch
+     * @returns {number|boolean} its value here, its default when this set does not name it
+     */
+    get(shader_switch: ShaderSwitch): number | boolean;
+    /**
+     * @param {ShaderSwitch} shader_switch
+     * @param {number|boolean} value one of the switch's values: a member of its enum, or `false`/`true`
+     * @returns {ShaderSwitchSet} the set of this one's values, with `shader_switch` at `value`
+     */
+    with(shader_switch: ShaderSwitch, value: number | boolean): ShaderSwitchSet;
+    /**
+     * @param {ShaderSwitch[]} switches
+     * @returns {ShaderSwitchSet} the set of this one's values for `switches` only: what a shader that
+     * depends on those switches can tell apart
+     */
+    restricted_to(switches: ShaderSwitch[]): ShaderSwitchSet;
+    toString(): string;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isShaderSwitchSet: boolean;
+    #private;
+}
+export type ShaderSwitch = import("./ShaderSwitch.js").ShaderSwitch;
+//# sourceMappingURL=ShaderSwitchSet.d.ts.map

package/src/shade/renderer/shader/compiler/ShaderSwitchSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderSwitchSet.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/compiler/ShaderSwitchSet.js"],"names":[],"mappings":"AAYA;;;;;;;GAOG;AACH;IA0BI;;;OAGG;IACH,cAFU,eAAe,CAEsB;IA0H/C;;;;OAIG;IACH,iCAJW,YAAY,EAAE,UACd,MAAM,MAAM,GAAC,OAAO,CAAC,GACnB,eAAe,CAsB3B;IA/JD;;;OAGG;IACH,kBAEC;IAQD;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,GAAC,OAAO,CAI1B;IAED;;;OAGG;IACH,mBAHW,YAAY,GACV,MAAM,GAAC,OAAO,CAM1B;IAED;;;;OAIG;IACH,oBAJW,YAAY,SACZ,MAAM,GAAC,OAAO,GACZ,eAAe,CA0C3B;IAED;;;;OAIG;IACH,wBAJW,YAAY,EAAE,GACZ,eAAe,CAqB3B;IAED,mBAYC;IA8BL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;2BAnMY,OAAO,mBAAmB,EAAE,YAAY"}

package/src/shade/renderer/shader/compiler/ShaderSwitchSet.js

@@ -0,0 +1,205 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * @typedef {import("./ShaderSwitch.js").ShaderSwitch} ShaderSwitch
+ */
+
+/**
+ * Every set made so far, by {@link ShaderSwitchSet#key}.
+ * @type {Map<string, ShaderSwitchSet>}
+ */
+const interned = new Map();
+
+/**
+ * Values for some {@link ShaderSwitch}es: what a renderer has decided, or what one pipeline asks for.
+ * A switch the set does not name has its {@link ShaderSwitch#default_value}: `0`, or `false` for a bool.
+ *
+ * Immutable and interned: two sets that give every switch the same value are the same object, so a
+ * set is a cache key by identity, and a frame that looks one up allocates nothing. {@link with} and
+ * {@link restricted_to} hand out the one set for their values, making it only the first time.
+ */
+export class ShaderSwitchSet {
+    /**
+     * Switches whose value here is not their default, in {@link ShaderSwitch#id} order.
+     * @type {ShaderSwitch[]}
+     */
+    #switches = [];
+
+    /**
+     * Parallel to {@link #switches}; never the switch's default.
+     * @type {Array<number|boolean>}
+     */
+    #values = [];
+
+    /**
+     * @type {string}
+     */
+    #key = '';
+
+    /**
+     * The values as one string, the same for the same values. What interning is keyed by.
+     * @returns {string}
+     */
+    get key() {
+        return this.#key;
+    }
+
+    /**
+     * Every switch at its default.
+     * @type {ShaderSwitchSet}
+     */
+    static EMPTY = ShaderSwitchSet.#intern([], []);
+
+    /**
+     * How many switches this set gives a value other than their default.
+     * @returns {number}
+     */
+    get size() {
+        return this.#switches.length;
+    }
+
+    /**
+     * @param {number} index below {@link size}
+     * @returns {ShaderSwitch}
+     */
+    switch_at(index) {
+        return this.#switches[index];
+    }
+
+    /**
+     * @param {number} index below {@link size}
+     * @returns {number|boolean}
+     */
+    value_at(index) {
+        return this.#values[index];
+    }
+
+    /**
+     * @param {ShaderSwitch} shader_switch
+     * @returns {number|boolean} its value here, its default when this set does not name it
+     */
+    get(shader_switch) {
+        const index = this.#switches.indexOf(shader_switch);
+
+        return index === -1 ? shader_switch.default_value : this.#values[index];
+    }
+
+    /**
+     * @param {ShaderSwitch} shader_switch
+     * @param {number|boolean} value one of the switch's values: a member of its enum, or `false`/`true`
+     * @returns {ShaderSwitchSet} the set of this one's values, with `shader_switch` at `value`
+     */
+    with(shader_switch, value) {
+        assert.defined(shader_switch, 'shader_switch');
+        assert.equal(shader_switch.isShaderSwitch, true, 'shader_switch.isShaderSwitch !== true');
+        assert.ok(shader_switch.is_value(value), `${value} is not a value of shader switch '${shader_switch.label}'`);
+
+        if (this.get(shader_switch) === value) {
+            return this;
+        }
+
+        const switches = [];
+        const values = [];
+
+        let placed = false;
+
+        for (let i = 0; i < this.#switches.length; i++) {
+            const existing = this.#switches[i];
+
+            if (!placed && existing.id >= shader_switch.id) {
+                placed = true;
+
+                if (value !== shader_switch.default_value) {
+                    switches.push(shader_switch);
+                    values.push(value);
+                }
+
+                if (existing === shader_switch) {
+                    continue;
+                }
+            }
+
+            switches.push(existing);
+            values.push(this.#values[i]);
+        }
+
+        if (!placed && value !== shader_switch.default_value) {
+            switches.push(shader_switch);
+            values.push(value);
+        }
+
+        return ShaderSwitchSet.#intern(switches, values);
+    }
+
+    /**
+     * @param {ShaderSwitch[]} switches
+     * @returns {ShaderSwitchSet} the set of this one's values for `switches` only: what a shader that
+     * depends on those switches can tell apart
+     */
+    restricted_to(switches) {
+        const kept_switches = [];
+        const kept_values = [];
+
+        for (let i = 0; i < this.#switches.length; i++) {
+            const shader_switch = this.#switches[i];
+
+            if (switches.includes(shader_switch)) {
+                kept_switches.push(shader_switch);
+                kept_values.push(this.#values[i]);
+            }
+        }
+
+        if (kept_switches.length === this.#switches.length) {
+            return this;
+        }
+
+        return ShaderSwitchSet.#intern(kept_switches, kept_values);
+    }
+
+    toString() {
+        let s = '';
+
+        for (let i = 0; i < this.#switches.length; i++) {
+            if (i > 0) {
+                s += ', ';
+            }
+
+            s += `${this.#switches[i].label}=${this.#switches[i].name_of(this.#values[i])}`;
+        }
+
+        return s;
+    }
+
+    /**
+     * @param {ShaderSwitch[]} switches in id order, each once
+     * @param {Array<number|boolean>} values none of them its switch's default
+     * @returns {ShaderSwitchSet}
+     */
+    static #intern(switches, values) {
+        let key = '';
+
+        for (let i = 0; i < switches.length; i++) {
+            key += `${switches[i].id}=${switches[i].index_of(values[i])};`;
+        }
+
+        let r = interned.get(key);
+
+        if (r === undefined) {
+            r = new ShaderSwitchSet();
+
+            r.#switches = switches;
+            r.#values = values;
+            r.#key = key;
+
+            interned.set(key, r);
+        }
+
+        return r;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ShaderSwitchSet.prototype.isShaderSwitchSet = true;

package/src/shade/renderer/shadow/contact/CONTACT_SHADOW_WAVE_SIZE.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Threads in one workgroup of the screen-space contact shadow pass, and the pixels one workgroup
+ * walks along a single ray toward the light's position on screen. The threads of a workgroup sit
+ * one pixel apart on that ray, so each thread's samples are its neighbours' depth reads, shared
+ * through workgroup memory rather than read again.
+ *
+ * 64 is Bend Studio's: the only width their released code was tested with. It does not depend on
+ * the subgroup size (on the 4090 it is two 32-wide subgroups), because the sharing goes through
+ * workgroup memory behind a barrier.
+ *
+ * @type {number}
+ */
+export const CONTACT_SHADOW_WAVE_SIZE: number;
+//# sourceMappingURL=CONTACT_SHADOW_WAVE_SIZE.d.ts.map

package/src/shade/renderer/shadow/contact/CONTACT_SHADOW_WAVE_SIZE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CONTACT_SHADOW_WAVE_SIZE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/CONTACT_SHADOW_WAVE_SIZE.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,uCAFU,MAAM,CAE2B"}

package/src/shade/renderer/shadow/contact/CONTACT_SHADOW_WAVE_SIZE.js

@@ -0,0 +1,13 @@
+/**
+ * Threads in one workgroup of the screen-space contact shadow pass, and the pixels one workgroup
+ * walks along a single ray toward the light's position on screen. The threads of a workgroup sit
+ * one pixel apart on that ray, so each thread's samples are its neighbours' depth reads, shared
+ * through workgroup memory rather than read again.
+ *
+ * 64 is Bend Studio's: the only width their released code was tested with. It does not depend on
+ * the subgroup size (on the 4090 it is two 32-wide subgroups), because the sharing goes through
+ * workgroup memory behind a barrier.
+ *
+ * @type {number}
+ */
+export const CONTACT_SHADOW_WAVE_SIZE = 64;

package/src/shade/renderer/shadow/contact/ContactShadowDispatchList.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Most dispatches one light needs: two for each quadrant of the screen around the light's position.
+ * @type {number}
+ */
+export const CONTACT_SHADOW_DISPATCH_LIMIT: number;
+/**
+ * Words per dispatch in {@link ContactShadowDispatchList#dispatches}: workgroup counts x, y, z, then
+ * the wave offset x, y in pixels.
+ * @type {number}
+ */
+export const CONTACT_SHADOW_DISPATCH_STRIDE: number;
+/**
+ * Furthest the light's coordinate may sit from the viewport's centre, in pixels: 2^20, where f32
+ * spacing is 1/8 pixel. See {@link ContactShadowDispatchList#build}.
+ * @type {number}
+ */
+export const CONTACT_SHADOW_LIGHT_DISTANCE_LIMIT: number;
+/**
+ * The compute dispatches that cover a viewport with wavefronts converging on one light's position on
+ * screen, and the light coordinate every one of them is handed.
+ *
+ * A port of Bend Studio's `Bend::BuildDispatchList` (`bend_sss_cpu.h`, Sony Interactive Entertainment,
+ * Apache 2.0). The screen is split into the four quadrants around the light; each is a stack of square
+ * rings of {@link CONTACT_SHADOW_WAVE_SIZE} pixels, and a quadrant whose rectangle is not square is split
+ * along the diagonal through the light into a second dispatch. One to two dispatches when the light is
+ * off screen, up to eight when it is on it.
+ *
+ * Built on the CPU because the counts depend on where the light lands on screen, which is a function
+ * of the camera and the light the CPU already holds; the dispatches are sized by the viewport, not by
+ * any capacity. Rebuilding writes into the same arrays, so a frame allocates nothing.
+ */
+export class ContactShadowDispatchList {
+    /**
+     * What the shader calls `light_coordinate`: the light's position in pixels (x, y), its device depth,
+     * and +1 when it is in front of the camera (the rays march toward it), −1 when it is behind (they
+     * march away from the point it projects to).
+     *
+     * @type {Float32Array}
+     */
+    light_coordinate: Float32Array;
+    /**
+     * {@link CONTACT_SHADOW_DISPATCH_STRIDE} words per dispatch: workgroups x, y, z, wave offset x, y.
+     *
+     * @type {Int32Array}
+     */
+    dispatches: Int32Array;
+    /**
+     * Dispatches in use, from the front of {@link dispatches}.
+     *
+     * @type {number}
+     */
+    count: number;
+    /**
+     * Cover the whole viewport for a light.
+     *
+     * @param {ArrayLike<number>} light_projection the light through the view-projection matrix, before
+     *        the divide: `(position, 1)` for a point light, `(direction toward the light, 0)` for a
+     *        directional one
+     * @param {number} width viewport, in pixels
+     * @param {number} height viewport, in pixels
+     */
+    build(light_projection: ArrayLike<number>, width: number, height: number): void;
+    #private;
+}
+//# sourceMappingURL=ContactShadowDispatchList.d.ts.map

package/src/shade/renderer/shadow/contact/ContactShadowDispatchList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactShadowDispatchList.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/ContactShadowDispatchList.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,kDAFU,MAAM,CAE2C;AAE3D;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;OAMG;IACH,kBAFU,YAAY,CAEiB;IAEvC;;;;OAIG;IACH,YAFU,UAAU,CAEwE;IAE5F;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAkCV;;;;;;;;OAQG;IACH,wBANW,UAAU,MAAM,CAAC,SAGjB,MAAM,UACN,MAAM,QAsJhB;;CACJ"}