@woosh/meep-engine 3.46.0 → 3.49.0

package/src/shade/renderer/animation/GPUAnimationManager.d.ts

@@ -28,6 +28,14 @@
  *     update path.
  */
 export class GPUAnimationManager {
+    /**
+     * Offer the pipelines {@link tick} runs on every frame: the transform hierarchy, which composes
+     * world matrices whether or not anything is animated — see {@link PipelineEnquiry}. The clip,
+     * pose and skinning passes are left to the first frame that has a clip or a skin.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * @param {GPUDevice} device
      * @param {string} label
@@ -518,6 +526,7 @@ export class GPUAnimationManager {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type AnimationCurve = import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve;
 export type GPURecordWriter = import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter;
 export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AAkUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAuQI;;;;OAIG;IACH,sCAHW,MAAM,iBACN,eAAe,EAezB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;;;OAQG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;;OAaG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAKvD;IAED;;;;;;;;;;;;;OAaG;IACH,gCAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;OAMG;IACH,8BAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;;;;OASG;IACH,iBAHW,cAAc,GACZ,MAAM,CAmBlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA4BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,eARW;QACV,IAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAc,CAAC,EAAE,MAAM,CAAC;QACxB,QAAc,EAAE,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,aAAa,EAAE,UAAU,MAAM,CAAC,CAAA;SAAE,CAAC,CAAC;KAC5G,GACS,MAAM,CAiDlB;IA4BD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAWhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAWhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAMhB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAMhB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAMhB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAMhB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,eALW;QACV,MAAY,EAAE,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;KAC1E,GACS,MAAM,CAuBlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBAJW,UAAU,MAAM,CAAC,yBACjB,YAAY,GACV,MAAM,CAyDlB;IAED;;;;;;;;;;;OAWG;IACH,uBAHW,MAAM,WACN,MAAM,QAkBhB;IAED;;;;OAIG;IACH,yBAFW,MAAM,QAkBhB;IAiGD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,oBAHW,kBAAkB,GAChB,MAAM,CA2DlB;IAuWD;;;;;;;;;;;;;;OAcG;IACH,yBAFW,MAAM,QA4BhB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,yBAFW,MAAM,QAmChB;IAyND;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAFW,sBAAsB,QAMhC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,mCAFW,sBAAsB,QAmChC;IAgED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,cALW,sBAAsB,cACtB,MAAM,GACJ,OAAO,CA0CnB;IA8FD,gBAoBC;;CACJ;6BAx4EY,OAAO,mDAAmD,EAAE,cAAc;8BAC1E,OAAO,iDAAiD,EAAE,eAAe;qCACzE,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,6BAA6B,EAAE,eAAe;iCACrD,OAAO,yBAAyB,EAAE,kBAAkB;4BAjDrC,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -7,6 +7,7 @@ import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { GPU_DATABASE_NULL } from "../buffer/table/GPU_DATABASE_NULL.js";
 import { generate_record_writer } from "../buffer/table/serde/generate_record_writer.js";
 import {
+    enquire_scene_update_transform_hierarchy_pipelines,
     graph_scene_update_transform_hierarchy
 } from "../scene/hierarchy/graph_scene_update_transform_hierarchy.js";
 import { graph_import_buffer } from "../shader/graph/graph_import_buffer.js";
@@ -48,6 +49,7 @@ import {
 } from "./skinning/shader_skin_matrix_prep.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} AnimationCurve
  * @typedef {import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter} GPURecordWriter
  * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
@@ -351,6 +353,18 @@ function skin_content_equals(skin, joints, inverse_bind_matrices) {
  */
 export class GPUAnimationManager {
 
+    /**
+     * Offer the pipelines {@link tick} runs on every frame: the transform hierarchy, which composes
+     * world matrices whether or not anything is animated — see {@link PipelineEnquiry}. The clip,
+     * pose and skinning passes are left to the first frame that has a clip or a skin.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquire_scene_update_transform_hierarchy_pipelines(enquiry);
+    }
+
+
     /** @type {GPUDevice} */
     #device;
 

package/src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AAiT1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAIG;8BAtV2B,+BAA+B"}
+{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AAmT1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAIG;8BAxV2B,+BAA+B"}

package/src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js

@@ -96,9 +96,11 @@ resources.createGroup()
 // skinning into a shared slot would race, so the shader skips the
 // write for any attribute where the flag is set — the cloned slot
 // keeps the source's value and lighting on those vertices uses an
-// undeformed direction. For typical character meshes
-// normals/tangents vary per vertex and so don't get the all-equal
-// collapse, so this skip rarely engages in practice.
+// undeformed direction. MeshletBatch#compress never collapses either
+// on a meshlet that carries skin weights, so the skip engages only
+// for a meshlet encoded before it stopped (2026-10-16): until then a
+// flat cloth sheet, every bind normal alike, collapsed and was lit in
+// its bind pose whatever shape it took.
 //
 // SkinningJoints + SkinningWeights are read-only here. They CAN be
 // compressed — a meshlet where every vertex shares the same joint

package/src/shade/renderer/buffer/GPUBufferAllocator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUBufferAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/GPUBufferAllocator.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IAOI;;OAEG;IACH,+BAKC;IAED,8BAEC;IAED,gCAEC;IAED,yBAEC;IAED,2BAWC;IAED,mCAEC;;CAoDJ;sCAlHqC,kCAAkC"}
+{"version":3,"file":"GPUBufferAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/GPUBufferAllocator.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IAOI;;OAEG;IACH,+BAKC;IAED,8BAEC;IAED,gCAEC;IAWD,yBAEC;IAED,2BAWC;IAED,mCAEC;;CAoDJ;sCA3HqC,kCAAkC"}

package/src/shade/renderer/buffer/GPUBufferAllocator.js

@@ -42,6 +42,15 @@ export class GPUBufferAllocator extends TransientResourcePool {
         return buffer_compare(a, b);
     }
 
+    /**
+     * The usage the buffer was made with, kept on its record beside the size the pool keeps: the order
+     * and the match read both, and a `GPUBuffer`'s are native reads.
+     * @param {import("../pool/TransientResourcePool.js").PoolRecord} record
+     */
+    describeRecord(record) {
+        record.usage = record.resource.usage;
+    }
+
     sizeOf(buffer) {
         return buffer.size;
     }

package/src/shade/renderer/buffer/buffer_pool_ops.d.ts

@@ -1,5 +1,5 @@
 /**
- * Total order over `{usage, size}`-bearing specs (a request descriptor or a live GPUBuffer).
+ * Total order over `{usage, size}`-bearing specs: a request descriptor, or a pool record.
  *
  * Sorted by size first (so the binary search lands on the smallest fitting buffer), then by usage
  * *bit-count* (so the narrowest-usage buffer is preferred — wide-usage buffers map to slower driver
@@ -16,29 +16,30 @@ export function compare_memory_spec(a: {
     usage: number;
     size: number;
 }): number;
+/**
+ * A pool record as {@link GPUBufferAllocator} keeps one: the buffer, and its `size` and `usage` as they
+ * were when it entered the pool. Ordering and matching read those, never the buffer, whose `size` and
+ * `usage` are native reads and are visited by the binary search and the scan many times a frame.
+ *
+ * @typedef {import("../pool/TransientResourcePool.js").PoolRecord & {usage: number}} BufferPoolRecord
+ */
 /**
  * Record ordering for the pool's sorted insert.
  *
- * @param {{resource:GPUBuffer}} a
- * @param {{resource:GPUBuffer}} b
+ * @param {BufferPoolRecord} a
+ * @param {BufferPoolRecord} b
  * @returns {number}
  */
-export function buffer_compare(a: {
-    resource: GPUBuffer;
-}, b: {
-    resource: GPUBuffer;
-}): number;
+export function buffer_compare(a: BufferPoolRecord, b: BufferPoolRecord): number;
 /**
  * Approximate first-fit: the smallest pooled buffer with `size >= request` and a usage *superset* of
  * the request, bounded against handing out a much-larger buffer.
  *
- * @param {{resource:GPUBuffer}[]} records sorted under {@link buffer_compare}
+ * @param {BufferPoolRecord[]} records sorted under {@link buffer_compare}
  * @param {{size:number, usage:number}} descriptor
  * @returns {number} index of a satisfying record, or -1
  */
-export function buffer_find(records: {
-    resource: GPUBuffer;
-}[], descriptor: {
+export function buffer_find(records: BufferPoolRecord[], descriptor: {
     size: number;
     usage: number;
 }): number;
@@ -63,4 +64,12 @@ export const ALLOW_LARGER_LIMIT_SCALE: number;
  * @type {number}
  */
 export const ALLOW_LARGER_LIMIT_FIXED: number;
+/**
+ * A pool record as {@link GPUBufferAllocator } keeps one: the buffer, and its `size` and `usage` as they
+ * were when it entered the pool. Ordering and matching read those, never the buffer, whose `size` and
+ * `usage` are native reads and are visited by the binary search and the scan many times a frame.
+ */
+export type BufferPoolRecord = import("../pool/TransientResourcePool.js").PoolRecord & {
+    usage: number;
+};
 //# sourceMappingURL=buffer_pool_ops.d.ts.map

package/src/shade/renderer/buffer/buffer_pool_ops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_pool_ops.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/buffer_pool_ops.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;GAUG;AACH,uCAJW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,KAC3B;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAqBlB;AAED;;;;;;GAMG;AACH,kCAJW;IAAC,QAAQ,YAAU;CAAC,KACpB;IAAC,QAAQ,YAAU;CAAC,GAClB,MAAM,CAIlB;AAWD;;;;;;;GAOG;AACH,qCAJW;IAAC,QAAQ,YAAU;CAAC,EAAE,cACtB;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAmClB;AAED;;;GAGG;AACH,mDAFa,MAAM,CAIlB;AAvHD;;;GAGG;AAEH;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAC1C;;;;GAIG;AACH,uCAFU,MAAM,CAE6B"}
+{"version":3,"file":"buffer_pool_ops.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/buffer_pool_ops.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;GAUG;AACH,uCAJW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,KAC3B;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAqBlB;AAED;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,kCAJW,gBAAgB,KAChB,gBAAgB,GACd,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,qCAJW,gBAAgB,EAAE,cAClB;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAmClB;AAED;;;GAGG;AACH,mDAFa,MAAM,CAIlB;AAtHD;;;GAGG;AAEH;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAC1C;;;;GAIG;AACH,uCAFU,MAAM,CAE6B;;;;;;+BAuChC,OAAO,kCAAkC,EAAE,UAAU,GAAG;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC"}

package/src/shade/renderer/buffer/buffer_pool_ops.js

@@ -20,7 +20,7 @@ export const ALLOW_LARGER_LIMIT_SCALE = 2;
 export const ALLOW_LARGER_LIMIT_FIXED = 1024;
 
 /**
- * Total order over `{usage, size}`-bearing specs (a request descriptor or a live GPUBuffer).
+ * Total order over `{usage, size}`-bearing specs: a request descriptor, or a pool record.
  *
  * Sorted by size first (so the binary search lands on the smallest fitting buffer), then by usage
  * *bit-count* (so the narrowest-usage buffer is preferred — wide-usage buffers map to slower driver
@@ -52,37 +52,36 @@ export function compare_memory_spec(a, b) {
 }
 
 /**
- * Record ordering for the pool's sorted insert.
+ * A pool record as {@link GPUBufferAllocator} keeps one: the buffer, and its `size` and `usage` as they
+ * were when it entered the pool. Ordering and matching read those, never the buffer, whose `size` and
+ * `usage` are native reads and are visited by the binary search and the scan many times a frame.
  *
- * @param {{resource:GPUBuffer}} a
- * @param {{resource:GPUBuffer}} b
- * @returns {number}
+ * @typedef {import("../pool/TransientResourcePool.js").PoolRecord & {usage: number}} BufferPoolRecord
  */
-export function buffer_compare(a, b) {
-    return compare_memory_spec(a.resource, b.resource);
-}
 
 /**
- * @param {{resource:GPUBuffer}} record
- * @param {{size:number}} descriptor
+ * Record ordering for the pool's sorted insert.
+ *
+ * @param {BufferPoolRecord} a
+ * @param {BufferPoolRecord} b
  * @returns {number}
  */
-function compare_descriptor_to_record(descriptor, record) {
-    return compare_memory_spec(descriptor, record.resource);
+export function buffer_compare(a, b) {
+    return compare_memory_spec(a, b);
 }
 
 /**
  * Approximate first-fit: the smallest pooled buffer with `size >= request` and a usage *superset* of
  * the request, bounded against handing out a much-larger buffer.
  *
- * @param {{resource:GPUBuffer}[]} records sorted under {@link buffer_compare}
+ * @param {BufferPoolRecord[]} records sorted under {@link buffer_compare}
  * @param {{size:number, usage:number}} descriptor
  * @returns {number} index of a satisfying record, or -1
  */
 export function buffer_find(records, descriptor) {
     const count = records.length;
 
-    let index = binarySearchHighIndex(records, descriptor, compare_descriptor_to_record);
+    let index = binarySearchHighIndex(records, descriptor, compare_memory_spec);
 
     if (index >= count) {
         return -1;
@@ -93,19 +92,19 @@ export function buffer_find(records, descriptor) {
     }
 
     for (; index < count; index++) {
-        const buffer = records[index].resource;
+        const record = records[index];
 
         if (
-            buffer.size > descriptor.size * ALLOW_LARGER_LIMIT_SCALE
-            && (buffer.size - descriptor.size) > ALLOW_LARGER_LIMIT_FIXED
+            record.size > descriptor.size * ALLOW_LARGER_LIMIT_SCALE
+            && (record.size - descriptor.size) > ALLOW_LARGER_LIMIT_FIXED
         ) {
             // records are sorted by size: everything from here on is too large
             break;
         }
 
         if (
-            (buffer.usage & descriptor.usage) === descriptor.usage
-            && buffer.size >= descriptor.size
+            (record.usage & descriptor.usage) === descriptor.usage
+            && record.size >= descriptor.size
         ) {
             return index;
         }

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts

@@ -9,6 +9,12 @@
  * see "Rendering 'Assassin's Creed Shadows'" GDC 2025 by Nicolas Lopez
  */
 export class GPUDatabase {
+    /**
+     * Offer the pipelines {@link update} uploads records with — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * @param {Object} options
      * @param {GPUDatabaseDefinition} options.definition Immutable schema
@@ -144,6 +150,7 @@ export class GPUDatabase {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type ShadeGPUCommandContext = import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type GPUDatabaseDefinition = import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition;
 import { GPUTypedTable } from "./GPUTypedTable.js";

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AA2CA;;;;;;;;;GASG;AACH;IA6FI;;;;;;OAMG;IACH;QAL0C,UAAU,EAAzC,qBAAqB;QACF,MAAM;QACR,KAAK,GAAtB,MAAM;QACW,uBAAuB,GAAxC,MAAM;OAkJhB;IAlPD;;;OAGG;IACH,YAFU,qBAAqB,CAEpB;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAmDP;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,oBAEC;IA2JD;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;;;;;;;OAWG;IACH,oCAcC;IAED;;;;;OAKG;IACH,gCAEC;IAoPD;;;;;;;;;;;OAWG;IACH,kCAeC;IAED;;;OAGG;IACH,gBAFW,sBAAsB,QA6FhC;IA+OD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBASC;;CACJ;qCAxoCY,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BANzC,oBAAoB;oCALd,0BAA0B"}
+{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IA8FD;;;;;;OAMG;IACH;QAL0C,UAAU,EAAzC,qBAAqB;QACF,MAAM;QACR,KAAK,GAAtB,MAAM;QACW,uBAAuB,GAAxC,MAAM;OAkJhB;IAlPD;;;OAGG;IACH,YAFU,qBAAqB,CAEpB;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAmDP;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,oBAEC;IA2JD;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;;;;;;;OAWG;IACH,oCAcC;IAED;;;;;OAKG;IACH,gCAEC;IAoPD;;;;;;;;;;;OAWG;IACH,kCAeC;IAED;;;OAGG;IACH,gBAFW,sBAAsB,QA6FhC;IA+OD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBASC;;CACJ;8BAppCY,OAAO,6CAA6C,EAAE,eAAe;qCACrE,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BAPzC,oBAAoB;oCALd,0BAA0B"}

package/src/shade/renderer/buffer/table/GPUDatabase.js

@@ -20,6 +20,7 @@ import { PageBufferPool } from "./PageBufferPool.js";
 import { PageSlotAllocator } from "./PageSlotAllocator.js";
 
 /**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
  * @typedef {import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition} GPUDatabaseDefinition
  */
@@ -53,6 +54,17 @@ const UPLOAD_CHUNK_SIZE = 256 * KILOBYTE;
  */
 export class GPUDatabase {
 
+    /**
+     * Offer the pipelines {@link update} uploads records with — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquiry.compute.push(gpu_table_element_upload_shader.pipeline);
+        enquiry.compute.push(gpu_table_partial_upload_shader.pipeline);
+    }
+
+
     /**
      * Immutable schema.
      * @type {GPUDatabaseDefinition}

package/src/shade/renderer/buffer/table/single/GPUSingleTypeTable.d.ts

@@ -3,6 +3,13 @@
  * @see {GPUDatabase}
  */
 export class GPUSingleTypeTable {
+    /**
+     * Offer the pipeline {@link update} uploads records with, one for every table — see
+     * {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      *
      * @param {Object} options
@@ -71,6 +78,7 @@ export class GPUSingleTypeTable {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type ShadeGPUCommandContext = import("../../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type WebGPUType = import("../../../shader/type/WebGPUType.js").WebGPUType;
 //# sourceMappingURL=GPUSingleTypeTable.d.ts.map

package/src/shade/renderer/buffer/table/single/GPUSingleTypeTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSingleTypeTable.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js"],"names":[],"mappings":"AA6EA;;;GAGG;AACH;IA4DI;;;;;;OAMG;IACH;QAJ8B,MAAM;QACL,IAAI,EAAxB,UAAU;QACO,YAAY,GAA7B,MAAM;OAoBhB;IApFD;;;OAGG;IACH,eAHU,UAAU,CAGf;IAEL;;;OAGG;IACH,2BAAM;IAEN;;;OAGG;IACH,sBAA2E;IAE3E;;;OAGG;IACH,kBAAyB;IA6BzB;;;OAGG;IACH,+BAEC;IA6BD;;;OAGG;IACH,WAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAHW,MAAM,kBAyChB;IAgCD;;;;OAIG;IACH,aAHW,MAAM,OAiBhB;IAuCD;;;OAGG;IACH,oBAFW,sBAAsB,QAkDhC;IAED,0BAQC;IAED,gBAEC;;CACJ;qCA7WY,OAAO,8CAA8C,EAAE,sBAAsB;yBAC7E,OAAO,oCAAoC,EAAE,UAAU"}
+{"version":3,"file":"GPUSingleTypeTable.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js"],"names":[],"mappings":"AA8EA;;;GAGG;AACH;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAIzB;IA6DD;;;;;;OAMG;IACH;QAJ8B,MAAM;QACL,IAAI,EAAxB,UAAU;QACO,YAAY,GAA7B,MAAM;OAoBhB;IApFD;;;OAGG;IACH,eAHU,UAAU,CAGf;IAEL;;;OAGG;IACH,2BAAM;IAEN;;;OAGG;IACH,sBAA2E;IAE3E;;;OAGG;IACH,kBAAyB;IA6BzB;;;OAGG;IACH,+BAEC;IA6BD;;;OAGG;IACH,WAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAHW,MAAM,kBAyChB;IAgCD;;;;OAIG;IACH,aAHW,MAAM,OAiBhB;IAuCD;;;OAGG;IACH,oBAFW,sBAAsB,QAkDhC;IAED,0BAQC;IAED,gBAEC;;CACJ;8BAzXY,OAAO,gDAAgD,EAAE,eAAe;qCACxE,OAAO,8CAA8C,EAAE,sBAAsB;yBAC7E,OAAO,oCAAoC,EAAE,UAAU"}

package/src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js

@@ -21,6 +21,7 @@ import { inspect_gpu_buffer_typed } from "../../inspect_gpu_buffer_typed.js";
 import { GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE } from "../GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE.js";
 
 /**
+ * @typedef {import("../../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
  * @typedef {import("../../../shader/type/WebGPUType.js").WebGPUType} WebGPUType
  */
@@ -80,6 +81,17 @@ fn main(@builtin(global_invocation_id) global_id : vec3<u32>){
  * @see {GPUDatabase}
  */
 export class GPUSingleTypeTable {
+
+    /**
+     * Offer the pipeline {@link update} uploads records with, one for every table — see
+     * {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquiry.compute.push(update_shader.pipeline);
+    }
+
     /**
      * @type {WebGPUType}
      * @readonly

package/src/shade/renderer/camera/GPUCameraContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUCameraContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/GPUCameraContext.js"],"names":[],"mappings":"AAgBA;IAyEI;;;;OAIG;IACH,uCAFW,MAAM,EAMhB;IA9ED,iBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,QAFU,cAAc,CAEjB;IAyBP,2CAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;OAGG;IACH,4CAEC;IAED;;;OAGG;IACH,2CAEC;IAaD,0BAMC;IAED;;;;OAIG;IACH,YAHW,gBAAgB,gBAChB,sBAAsB,QAiChC;IAED,mBAQC;IAED,gBAEC;IAED,eAEC;;CA6EJ;qCArOY,OAAO,wCAAwC,EAAE,sBAAsB;qBACvE,OAAO,aAAa,EAAE,MAAM;+BANV,6BAA6B"}
+{"version":3,"file":"GPUCameraContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/GPUCameraContext.js"],"names":[],"mappings":"AAgBA;IAyEI;;;;OAIG;IACH,uCAFW,MAAM,EAMhB;IA9ED,iBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,QAFU,cAAc,CAEjB;IAyBP,2CAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;OAGG;IACH,4CAEC;IAED;;;OAGG;IACH,2CAEC;IAaD,0BAMC;IAED;;;;OAIG;IACH,YAHW,gBAAgB,gBAChB,sBAAsB,QAiChC;IAED,mBAQC;IAED,gBAEC;IAED,eAEC;;CAwFJ;qCAhPY,OAAO,wCAAwC,EAAE,sBAAsB;qBACvE,OAAO,aAAa,EAAE,MAAM;+BANV,6BAA6B"}

package/src/shade/renderer/camera/GPUCameraContext.js

@@ -173,14 +173,25 @@ export class GPUCameraContext {
         const projection_matrix = new Float64Array(16);
         projection_matrix.set(camera.projection_matrix);
 
-        // Signs are chosen so a positive offset shifts rendered content in the +UV direction
-        // (right/down), which is what the temporal consumers (TAA/NSS un-jitter,
-        // chunk_unjitter_uv) assume. The perspective divide negates whatever is added here:
-        // m[11] == -1 makes clip.w = -z_view, so adding c at m[8]/m[9] shifts NDC by -c —
-        // hence "-=" for x (NDC x aligns with UV x) and "+=" for y (NDC y is UV-flipped,
-        // the two negations cancel).
-        projection_matrix[8] -= this.#view_offset[0];
-        projection_matrix[9] += this.#view_offset[1];
+        // The offset is a constant shift in NDC, at every depth: clip.xy += offset * clip.w, a
+        // translation applied after the projection. Folded into the matrix, that adds the offset
+        // times its w row to its x and y rows. A perspective w row is (0, 0, -1, 0), so the shift
+        // lands in the column view z multiplies, off-axis; an orthographic one is (0, 0, 0, 1), so
+        // it lands in the translation column. Adding to column 2 for both would make the
+        // orthographic shift scale with view z.
+        //
+        // A positive offset shifts rendered content in the +UV direction (right/down), which is
+        // what the temporal consumers (TAA/NSS un-jitter, chunk_unjitter_uv) assume: NDC x
+        // aligns with UV x, NDC y is UV-flipped.
+        const offset_x = this.#view_offset[0];
+        const offset_y = -this.#view_offset[1];
+
+        for (let column = 0; column < 16; column += 4) {
+            const w = projection_matrix[column + 3];
+
+            projection_matrix[column] += offset_x * w;
+            projection_matrix[column + 1] += offset_y * w;
+        }
 
         // build view-projection matrix
         const view_projection_matrix = this.#view_projection_matrix;

package/src/shade/renderer/deferred/chunk_read_gBuffer_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_read_gBuffer_material.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_read_gBuffer_material.js"],"names":[],"mappings":"AAQA,oDAqDE;0BAvDwB,iCAAiC"}
+{"version":3,"file":"chunk_read_gBuffer_material.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_read_gBuffer_material.js"],"names":[],"mappings":"AASA,oDAwDE;0BA1DwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_read_gBuffer_material.js

@@ -1,4 +1,5 @@
 import { BSDF_ROUGHNESS_MINIMUM } from "../light/environment/DEFINES.js";
+import { chunk_MIN_DIELECTRICS_F0 } from "../shader/chunk/brdf/chunk_MIN_DIELECTRICS_F0.js";
 import { chunk_rgbe9995_decode } from "../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_decode_g_buffer_metalness } from "../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
 import { chunk_decode_g_buffer_roughness } from "../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
@@ -47,6 +48,8 @@ fn read_gBuffer_material(
 
     material.specularF0 = metalness_to_specular_color(f_metalness, albedo);
     material.specularF90 = 1.0;
+    material.specularF0_dielectric = vec3(MIN_DIELECTRICS_F0);
+    material.specularF0_metal = albedo;
     
     material.emissive = emissive;
     
@@ -55,6 +58,7 @@ fn read_gBuffer_material(
     `, [
         MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
         chunk_metalness_to_specular_color,
+        chunk_MIN_DIELECTRICS_F0,
         chunk_decode_g_buffer_roughness,
         chunk_decode_g_buffer_metalness,
         chunk_rgbe9995_decode

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shade_standard_material_direct.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mDAFU,SAAS,CAuFjB;0BAhHwB,iCAAiC"}
+{"version":3,"file":"chunk_shade_standard_material_direct.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mDAFU,SAAS,CA0FjB;0BAnHwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.js

@@ -3,6 +3,7 @@ import { chunk_light_cluster_metadata_by_position } from "../light/cluster/chunk
 import { chunk_get_point_light_info_by_index } from "../shader/chunk/light/io/chunk_get_point_light_info_by_index.js";
 import { chunk_get_spot_light_info_by_index } from "../shader/chunk/light/io/chunk_get_spot_light_info_by_index.js";
 import { REFLECTED_LIGHT_STRUCT } from "../shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
+import { chunk_re_direct_multiscatter } from "../shader/chunk/material/chunk_re_direct_multiscatter.js";
 import { chunk_re_direct_physical } from "../shader/chunk/material/chunk_re_direct_physical.js";
 import { GEOMETRIC_SHADING_INFO_STRUCT } from "../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
 import { MATERIAL_SHADING_INFO_STRUCT } from "../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
@@ -100,6 +101,8 @@ fn shade_standard_material_direct(
         re_direct_physical(direct_light, geometry, material, &reflected_light);
     }
 
+    re_direct_multiscatter(geometry, material, &reflected_light);
+
     var total_emissive_radiance = vec3(material.emissive);
 
     let outgoing_light = reflected_light.diffuse + reflected_light.specular + total_emissive_radiance;
@@ -111,6 +114,7 @@ fn shade_standard_material_direct(
         GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
         MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
         chunk_re_direct_physical,
+        chunk_re_direct_multiscatter,
         chunk_light_cluster_metadata_by_position,
         chunk_light_cluster_counts,
         chunk_get_point_light_info_by_index,

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shade_standard_material_direct_restir.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;GAWG;AACH,0DAFU,SAAS,CA6BjB;0BA1CwB,iCAAiC"}
+{"version":3,"file":"chunk_shade_standard_material_direct_restir.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,0DAFU,SAAS,CAgCjB;0BA7CwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.js

@@ -1,4 +1,5 @@
 import { REFLECTED_LIGHT_STRUCT } from "../shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
+import { chunk_re_direct_multiscatter } from "../shader/chunk/material/chunk_re_direct_multiscatter.js";
 import { GEOMETRIC_SHADING_INFO_STRUCT } from "../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
 import { MATERIAL_SHADING_INFO_STRUCT } from "../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
@@ -30,6 +31,8 @@ fn shade_standard_material_direct(
 
     shade_directional_lights(material, geometry, &reflected_light);
 
+    re_direct_multiscatter(geometry, material, &reflected_light);
+
     // ReSTIR-resolved point + spot direct lighting (already visibility-tested).
     let restir_radiance = textureLoad(tRestirRadiance, vec2<u32>(coord), 0).rgb;
 
@@ -42,5 +45,6 @@ fn shade_standard_material_direct(
         GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
         MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
         chunk_shade_directional_lights,
+        chunk_re_direct_multiscatter,
     ]
 );

package/src/shade/renderer/deferred/shader_deferred_main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_deferred_main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_deferred_main.js"],"names":[],"mappings":"AAkJA;;;GAGG;AACH,mCAFU,WAAW,CAMlB;AAEH;;;;GAIG;AACH,0CAFU,WAAW,CAMlB;4BAxJyB,0BAA0B"}
+{"version":3,"file":"shader_deferred_main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_deferred_main.js"],"names":[],"mappings":"AAqJA;;;GAGG;AACH,mCAFU,WAAW,CAMlB;AAEH;;;;GAIG;AACH,0CAFU,WAAW,CAMlB;4BA3JyB,0BAA0B"}

package/src/shade/renderer/deferred/shader_deferred_main.js

@@ -51,6 +51,9 @@ function build_deferred_main_shader({ label, shading_chunk, with_restir }) {
 
     gbuffer_group.addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE);
 
+    // the split-sum LUT, for the direct specular's multiple-scattering compensation
+    gbuffer_group.addTexture("tSplitSum", "float");
+
     resources.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
 
     resources.createGroup()

package/src/shade/renderer/deferred/shader_tonemap_HDR.d.ts

@@ -1,3 +1,9 @@
+/**
+ * The HDR output with {@link ShadeToneMappingMode.GT7}: GT7 at the display's peak, with the same paper white as
+ * {@link shader_tonemap_LDR}, written as extended Display P3 where 1.0 is SDR white.
+ *
+ * @type {ImageShader}
+ */
 export const shader_tonemap_HDR: ImageShader;
 import { ImageShader } from "../shader/ImageShader.js";
 //# sourceMappingURL=shader_tonemap_HDR.d.ts.map

package/src/shade/renderer/deferred/shader_tonemap_HDR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_tonemap_HDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR.js"],"names":[],"mappings":"AA8DA,6CAYG;4BAlEyB,0BAA0B"}
+{"version":3,"file":"shader_tonemap_HDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR.js"],"names":[],"mappings":"AAkEA;;;;;GAKG;AACH,iCAFU,WAAW,CAclB;4BA3EyB,0BAA0B"}

package/src/shade/renderer/deferred/shader_tonemap_HDR.js

@@ -4,6 +4,7 @@ import { F32_CONTAINER_STRUCT } from "../shader/type/F32_CONTAINER_STRUCT.js";
 import { chunk_CRM_FROM_REC2020_TO_P3 } from "../shader/chunk/color/conversion/chunk_CRM_FROM_REC2020_TO_P3.js";
 import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
 import { chunk_sRGBTransferOETF } from "../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
+import { chunk_PAPER_WHITE_NITS } from "../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
 import { chunk_tonemap_gt7 } from "../shader/chunk/color/tonemap/gt7/chunk_tonemap_gt7.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../shader/ImageShader.js";
@@ -11,13 +12,15 @@ import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSe
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 
 const SETTINGS_STRUCT = WebGPUStruct.from({
+    /**
+     * The display's peak, cd/m². The paper white is not a setting: it is PAPER_WHITE_NITS on both outputs.
+     */
     peak_nits: f32,
-    paper_white_nits: f32,
 });
 
 const resources = new ShaderResourceSetDescriptor();
 
-// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. exposure stays
+// per-pass, four bytes, read-only: immediate data rather than a uniform buffer. exposure stays
 // bound - it is computed on the GPU, so there is no CPU value to write.
 resources.setImmediate("settings", SETTINGS_STRUCT);
 resources.createGroup()
@@ -39,7 +42,7 @@ fn main(
     color *= exposure.value;
     
     // Finally tonemap
-    color = tonemap_gt7(color, settings.peak_nits, settings.paper_white_nits);
+    color = tonemap_gt7(color, settings.peak_nits, PAPER_WHITE_NITS);
     
     // NOTE: no dithering, colorspace is wide
     
@@ -54,12 +57,19 @@ fn main(
 }
     `, [
         chunk_tonemap_gt7,
+        chunk_PAPER_WHITE_NITS,
         chunk_CRM_FROM_REC709_TO_REC2020,
         chunk_CRM_FROM_REC2020_TO_P3,
         chunk_sRGBTransferOETF,
     ]
 );
 
+/**
+ * The HDR output with {@link ShadeToneMappingMode.GT7}: GT7 at the display's peak, with the same paper white as
+ * {@link shader_tonemap_LDR}, written as extended Display P3 where 1.0 is SDR white.
+ *
+ * @type {ImageShader}
+ */
 export const shader_tonemap_HDR = new ImageShader({
     descriptor: ShaderDescriptor.from({
         label: "Tonemap/HDR",

package/src/shade/renderer/deferred/shader_tonemap_HDR_none.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The HDR output with {@link ShadeToneMappingMode.NONE}: exposure and extended Display P3, where 1.0 is SDR white,
+ * and nothing in between.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_HDR_none: ImageShader;
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_tonemap_HDR_none.d.ts.map

package/src/shade/renderer/deferred/shader_tonemap_HDR_none.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_HDR_none.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR_none.js"],"names":[],"mappings":"AA4CA;;;;;GAKG;AACH,sCAFU,WAAW,CAclB;4BAzDyB,0BAA0B"}