@woosh/meep-engine 3.46.0 → 3.49.0

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

@@ -0,0 +1,63 @@
+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 { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addTexture("input_color", "float")
+    .addUniform("exposure", F32_CONTAINER_STRUCT)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+  @builtin(position) coord : vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    // scene color in linear Rec. 709
+    var color = textureLoad(input_color, vec2i(coord.xy), 0).rgb;
+
+    color *= exposure.value;
+
+    // no tone mapping: 1.0 is SDR white, and what lies above it is shown as far as the display reaches
+
+    // NOTE: no dithering, colorspace is wide
+
+    // output in p3 color space
+    let color_p3 = CRM_FROM_REC2020_TO_P3 * (CRM_FROM_REC709_TO_REC2020 * color);
+
+    // apply gamma. Note that gamma is the same same for "Display P3" and "sRGB"
+    return vec4(sRGBTransferOETF(color_p3), 1.0);
+}
+    `, [
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_CRM_FROM_REC2020_TO_P3,
+        chunk_sRGBTransferOETF,
+    ]
+);
+
+/**
+ * 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 = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Tonemap/HDR/none",
+        resources,
+        body
+    }),
+    targets: [
+        {
+            label: "tone-mapped",
+            format: "rgba16float"
+        }
+    ]
+});

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

@@ -0,0 +1,10 @@
+/**
+ * The HDR output with {@link ShadeToneMappingMode.PBR_NEUTRAL}: Khronos PBR Neutral with the display's peak over the
+ * paper white in place of the specification's 1, written as extended Display P3 where 1.0 is SDR white. Below the
+ * compression start it writes what {@link shader_tonemap_LDR_pbr_neutral} writes.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_HDR_pbr_neutral: ImageShader;
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_tonemap_HDR_pbr_neutral.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_HDR_pbr_neutral.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR_pbr_neutral.js"],"names":[],"mappings":"AAmEA;;;;;;GAMG;AACH,6CAFU,WAAW,CAclB;4BA7EyB,0BAA0B"}

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

@@ -0,0 +1,87 @@
+import { f32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+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_khronos_pbr } from "../shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+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,
+});
+
+const resources = new ShaderResourceSetDescriptor();
+
+// 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()
+    .addTexture("input_color", "float")
+    .addUniform("exposure", F32_CONTAINER_STRUCT)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+  @builtin(position) coord : vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    // scene color in linear Rec. 709
+    var color = textureLoad(input_color, vec2i(coord.xy), 0).rgb;
+
+    // Apply exposure
+    color *= exposure.value;
+
+    // the display's peak in units of SDR white. A display under the paper white gets the SDR form, which is where
+    // the operator is defined.
+    let peak = max(settings.peak_nits / PAPER_WHITE_NITS, 1.0);
+
+    // It takes non-negative input.
+    color = tonemap_khronos_pbr(max(color, vec3<f32>(0.0)), peak);
+
+    // NOTE: no dithering, colorspace is wide
+
+    // output in p3 color space
+    let color_p3 = CRM_FROM_REC2020_TO_P3 * (CRM_FROM_REC709_TO_REC2020 * color);
+
+    // apply gamma. Note that gamma is the same same for "Display P3" and "sRGB"
+    return vec4(sRGBTransferOETF(color_p3), 1.0);
+}
+    `, [
+        chunk_tonemap_khronos_pbr,
+        chunk_PAPER_WHITE_NITS,
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_CRM_FROM_REC2020_TO_P3,
+        chunk_sRGBTransferOETF,
+    ]
+);
+
+/**
+ * The HDR output with {@link ShadeToneMappingMode.PBR_NEUTRAL}: Khronos PBR Neutral with the display's peak over the
+ * paper white in place of the specification's 1, written as extended Display P3 where 1.0 is SDR white. Below the
+ * compression start it writes what {@link shader_tonemap_LDR_pbr_neutral} writes.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_HDR_pbr_neutral = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Tonemap/HDR/pbr_neutral",
+        resources,
+        body
+    }),
+    targets: [
+        {
+            label: "tone-mapped",
+            format: "rgba16float"
+        }
+    ]
+});

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

@@ -1,3 +1,9 @@
+/**
+ * The SDR output with {@link ShadeToneMappingMode.GT7}: exposure, GT7 in its SDR mode, Display P3, the sRGB transfer
+ * curve and an 8-bit dither. {@link shader_tonemap_HDR} is the same operator for an HDR display.
+ *
+ * @type {ImageShader}
+ */
 export const shader_tonemap_LDR: ImageShader;
 import { ImageShader } from "../shader/ImageShader.js";
 //# sourceMappingURL=shader_tonemap_LDR.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_tonemap_LDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_LDR.js"],"names":[],"mappings":"AA+CA,6CAYG;4BAlDyB,0BAA0B"}
+{"version":3,"file":"shader_tonemap_LDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_LDR.js"],"names":[],"mappings":"AA2DA;;;;;GAKG;AACH,iCAFU,WAAW,CAclB;4BAjEyB,0BAA0B"}

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

@@ -1,8 +1,11 @@
 import { f32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 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_tonemap_aces } from "../shader/chunk/color/tonemap/chunk_tonemap_aces.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 {
     chunk_dither_color_8bit_triangle_noise
 } from "../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.js";
@@ -28,10 +31,16 @@ fn main(
         
     color *= exposure.value;
     
-    color = tonemap_aces(color);
+    // GT7's SDR mode: the peak is the paper white, so the result tops out at 1.0. The HDR pass keeps the same paper
+    // white, so below the shoulder the two write the same colour.
+    color = tonemap_gt7(color, PAPER_WHITE_NITS, PAPER_WHITE_NITS);
     
-    // conversion to output colorspace
-    color = sRGBTransferOETF(color);
+    // the canvas is configured "display-p3", so output in P3, as the HDR pass does
+    let color_2020 = CRM_FROM_REC709_TO_REC2020 * color;
+    let color_p3 = CRM_FROM_REC2020_TO_P3 * color_2020;
+    
+    // apply gamma. Note that gamma is the same for "Display P3" and "sRGB"
+    color = sRGBTransferOETF(color_p3);
     
     // apply dither to remove color banding
     color += dither_color_8bit_triangle_noise(coord.xy);
@@ -39,12 +48,21 @@ fn main(
     return vec4(color, 1.0);
 }
     `, [
-        chunk_tonemap_aces,
+        chunk_tonemap_gt7,
+        chunk_PAPER_WHITE_NITS,
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_CRM_FROM_REC2020_TO_P3,
         chunk_dither_color_8bit_triangle_noise,
         chunk_sRGBTransferOETF,
     ]
 );
 
+/**
+ * The SDR output with {@link ShadeToneMappingMode.GT7}: exposure, GT7 in its SDR mode, Display P3, the sRGB transfer
+ * curve and an 8-bit dither. {@link shader_tonemap_HDR} is the same operator for an HDR display.
+ *
+ * @type {ImageShader}
+ */
 export const shader_tonemap_LDR = new ImageShader({
     descriptor: ShaderDescriptor.from({
         label: "Tonemap/LDR",

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

@@ -0,0 +1,9 @@
+/**
+ * The SDR output with {@link ShadeToneMappingMode.NONE}: exposure, Display P3, the sRGB transfer curve and an 8-bit
+ * dither, and nothing in between.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_LDR_none: ImageShader;
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_tonemap_LDR_none.d.ts.map

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

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

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

@@ -0,0 +1,68 @@
+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_dither_color_8bit_triangle_noise
+} from "../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addTexture("input_color", "float")
+    .addUniform("exposure", F32_CONTAINER_STRUCT)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+  @builtin(position) coord : vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    var color = textureLoad(input_color, vec2i(coord.xy), 0).rgb;
+
+    color *= exposure.value;
+
+    // no tone mapping: the exposed colour as it is, 1.0 at SDR white. The 8-bit target clips what lies above.
+
+    // the canvas is configured "display-p3"
+    let color_p3 = CRM_FROM_REC2020_TO_P3 * (CRM_FROM_REC709_TO_REC2020 * color);
+
+    color = sRGBTransferOETF(color_p3);
+
+    // apply dither to remove color banding
+    color += dither_color_8bit_triangle_noise(coord.xy);
+
+    return vec4(color, 1.0);
+}
+    `, [
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_CRM_FROM_REC2020_TO_P3,
+        chunk_dither_color_8bit_triangle_noise,
+        chunk_sRGBTransferOETF,
+    ]
+);
+
+/**
+ * The SDR output with {@link ShadeToneMappingMode.NONE}: exposure, Display P3, the sRGB transfer curve and an 8-bit
+ * dither, and nothing in between.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_LDR_none = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Tonemap/LDR/none",
+        resources,
+        body
+    }),
+    targets: [
+        {
+            label: "tone-mapped",
+            format: "rgba8unorm"
+        }
+    ]
+});

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

@@ -0,0 +1,10 @@
+/**
+ * The SDR output with {@link ShadeToneMappingMode.PBR_NEUTRAL}: exposure, the Khronos PBR Neutral specification,
+ * Display P3, the sRGB transfer curve and an 8-bit dither. {@link shader_tonemap_HDR_pbr_neutral} is the same
+ * operator for an HDR display.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_LDR_pbr_neutral: ImageShader;
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_tonemap_LDR_pbr_neutral.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_LDR_pbr_neutral.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_LDR_pbr_neutral.js"],"names":[],"mappings":"AAqDA;;;;;;GAMG;AACH,6CAFU,WAAW,CAclB;4BA/DyB,0BAA0B"}

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

@@ -0,0 +1,73 @@
+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_tonemap_khronos_pbr } from "../shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.js";
+import {
+    chunk_dither_color_8bit_triangle_noise
+} from "../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addTexture("input_color", "float")
+    .addUniform("exposure", F32_CONTAINER_STRUCT)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+  @builtin(position) coord : vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    var color = textureLoad(input_color, vec2i(coord.xy), 0).rgb;
+
+    color *= exposure.value;
+
+    // the specification: its peak is SDR white. It takes non-negative input.
+    color = tonemap_khronos_pbr(max(color, vec3<f32>(0.0)), 1.0);
+
+    // the canvas is configured "display-p3", so output in P3, as the HDR pass does
+    let color_p3 = CRM_FROM_REC2020_TO_P3 * (CRM_FROM_REC709_TO_REC2020 * color);
+
+    // apply gamma. Note that gamma is the same for "Display P3" and "sRGB"
+    color = sRGBTransferOETF(color_p3);
+
+    // apply dither to remove color banding
+    color += dither_color_8bit_triangle_noise(coord.xy);
+
+    return vec4(color, 1.0);
+}
+    `, [
+        chunk_tonemap_khronos_pbr,
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_CRM_FROM_REC2020_TO_P3,
+        chunk_dither_color_8bit_triangle_noise,
+        chunk_sRGBTransferOETF,
+    ]
+);
+
+/**
+ * The SDR output with {@link ShadeToneMappingMode.PBR_NEUTRAL}: exposure, the Khronos PBR Neutral specification,
+ * Display P3, the sRGB transfer curve and an 8-bit dither. {@link shader_tonemap_HDR_pbr_neutral} is the same
+ * operator for an HDR display.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_LDR_pbr_neutral = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Tonemap/LDR/pbr_neutral",
+        resources,
+        body
+    }),
+    targets: [
+        {
+            label: "tone-mapped",
+            format: "rgba8unorm"
+        }
+    ]
+});

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AAwCA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAoFlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA/eY,OAAO,gBAAgB,EAAE,QAAQ"}
+{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AA4DA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAiHlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA9hBY,OAAO,gBAAgB,EAAE,QAAQ"}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.js

@@ -16,6 +16,7 @@ import { geometry_to_meshlets_meshoptimizer } from "./build/meshoptimizer/geomet
 import {
     ENCODED_ATTRIBUTE_DEFAULT_VALUES
 } from "./encoding/ENCODED_ATTRIBUTE_DEFAULT_VALUES.js";
+import { ENCODED_ATTRIBUTE_ORDER } from "./encoding/ENCODED_ATTRIBUTE_ORDER.js";
 import { ENCODED_ATTRIBUTE_SIZES } from "./encoding/ENCODED_ATTRIBUTE_SIZES.js";
 import { ENCODED_ORDERED_ATTRIBUTES } from "./encoding/ENCODED_ORDERED_ATTRIBUTES.js";
 import { MESHLET_ATTRIBUTE_COMPRESSION_FLAGS } from "./encoding/MESHLET_ATTRIBUTE_COMPRESSION_FLAGS.js";
@@ -25,6 +26,7 @@ import { meshlet_can_compress_attribute } from "./meshlet_can_compress_attribute
 import { meshlet_data_index_section_size } from "./meshlet_data_index_section_size.js";
 import { meshlet_encode_attribute } from "./meshlet_encode_attribute.js";
 import { meshlet_get_attribute_offset } from "./meshlet_get_attribute_offset.js";
+import { meshlet_get_attribute_size } from "./meshlet_get_attribute_size.js";
 
 /**
  * @typedef {import("../Geometry.js").Geometry} Geometry
@@ -38,6 +40,24 @@ globalThis.meshlet_debug = DEBUG_ATTRIBUTE_SIZE_TOTALS;
 
 const EMPTY_ARRAY_BUFFER = new ArrayBuffer(0);
 
+const ATTRIBUTE_COUNT = ENCODED_ORDERED_ATTRIBUTES.length;
+
+/**
+ * Per attribute of the meshlet {@link MeshletBatch#compress} is on, in {@link ENCODED_ORDERED_ATTRIBUTES} order:
+ * where it starts in the source, in 4-byte words. Module-level, so compressing allocates nothing for it.
+ * @type {Uint32Array}
+ */
+const ATTRIBUTE_SOURCE_ADDRESS = new Uint32Array(ATTRIBUTE_COUNT);
+
+/**
+ * Alongside {@link ATTRIBUTE_SOURCE_ADDRESS}: 1 where the attribute is still per vertex, may collapse to one shared
+ * slot, and every vertex agrees.
+ * @type {Uint8Array}
+ */
+const ATTRIBUTE_COLLAPSIBLE = new Uint8Array(ATTRIBUTE_COUNT);
+
+const WEIGHTS = ENCODED_ATTRIBUTE_ORDER[StandardAttributes.SkinningWeights];
+
 /**
  * Geometry split into meshlet, optimized for rendering
  */
@@ -175,22 +195,51 @@ export class MeshletBatch {
             const existing_flags = metadata.flags;
             let new_flags = existing_flags;
 
-            for (const attribute_key of ENCODED_ORDERED_ATTRIBUTES) {
+            // Every attribute is surveyed before any is written: whether normals and tangents may collapse
+            // depends on the weights, which come last.
+            let source_address = attribute_section_address;
+
+            for (let i = 0; i < ATTRIBUTE_COUNT; i++) {
+                const attribute_key = ENCODED_ORDERED_ATTRIBUTES[i];
+
+                const compression_flag = MESHLET_ATTRIBUTE_COMPRESSION_FLAGS[attribute_key];
+
+                ATTRIBUTE_SOURCE_ADDRESS[i] = source_address;
+                ATTRIBUTE_COLLAPSIBLE[i] = (
+                    compression_flag !== undefined
+                    && (existing_flags & compression_flag) === 0
+                    && meshlet_can_compress_attribute(source_data, source_address, vertex_count, ENCODED_ATTRIBUTE_SIZES[attribute_key])
+                ) ? 1 : 0;
+
+                source_address += meshlet_get_attribute_size(attribute_key, existing_flags, vertex_count);
+            }
+
+            // Skinning turns each vertex's normal and tangent by that vertex's own joints, and writes the result
+            // into the vertex's own slot; it skips a shared one. Collapsed, a skinned meshlet's normals keep their
+            // bind direction in every pose — a flat cloth sheet, whose bind normals all agree, was lit as if it
+            // never moved. See shader_meshlet_apply_skinning.
+            //
+            // A geometry with no weights is encoded with the all-zero default, and every skinned vertex has a
+            // weight somewhere: weights that differ between vertices, or agree on anything but zero, are a skin.
+            const weights_vary = (existing_flags & MESHLET_ATTRIBUTE_COMPRESSION_FLAGS[StandardAttributes.SkinningWeights]) === 0
+                && ATTRIBUTE_COLLAPSIBLE[WEIGHTS] === 0;
+
+            buffer_source_data.position = ATTRIBUTE_SOURCE_ADDRESS[WEIGHTS] << 2;
+
+            const skinned = weights_vary || buffer_source_data.readUint32() !== 0;
+
+            for (let i = 0; i < ATTRIBUTE_COUNT; i++) {
+                const attribute_key = ENCODED_ORDERED_ATTRIBUTES[i];
 
                 const compression_flag = MESHLET_ATTRIBUTE_COMPRESSION_FLAGS[attribute_key];
 
-                const supports_compression = compression_flag !== undefined;
+                const deformed_by_skin = attribute_key === StandardAttributes.Normal || attribute_key === StandardAttributes.Tangent;
 
-                const source_attribute_offset = attribute_section_address + meshlet_get_attribute_offset(attribute_key, existing_flags, vertex_count);
-                buffer_source_data.position = source_attribute_offset << 2;
+                buffer_source_data.position = ATTRIBUTE_SOURCE_ADDRESS[i] << 2;
 
                 const vertex_size = ENCODED_ATTRIBUTE_SIZES[attribute_key];
 
-                if (
-                    supports_compression
-                    && ((existing_flags & compression_flag) === 0)
-                    && meshlet_can_compress_attribute(source_data, source_attribute_offset, vertex_count, vertex_size)
-                ) {
+                if (ATTRIBUTE_COLLAPSIBLE[i] === 1 && !(skinned && deformed_by_skin)) {
                     // compress
 
                     new_flags |= compression_flag;

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Per-geometry signed distance fields, one {@link DEFAULT_MESH_RESOLUTION}³ `r32float` tile each, in
+ * a {@link GPUTileAtlas3D}.
+ *
+ * **A slot is its geometry's id.** The build shader reads `blas_lookup[slot]` and every reader
+ * addresses a geometry's tile by that id, so slots are claimed in order and never freed: the
+ * atlas's n-th allocation is slot n.
+ *
+ * **No border.** Every reader loads texels with `textureLoad` and clamps the far neighbour of its
+ * trilinear tap to the tile's last texel (`sdf_texture_region_sample_linear_uv`), and the texture
+ * is bound `unfilterable-float`, so no read leaves its tile. A skirt would be dead texels, and the
+ * atlas's skirt is a wrap besides — the far side of a mesh is not the continuation of its near side.
+ */
 export class GPUGeometrySDFManager {
     /**
      *
@@ -5,37 +18,40 @@ export class GPUGeometrySDFManager {
      */
     constructor(device: GPUDevice);
     /**
-     *
-     * @return {GPUTextureContext}
+     * Allocate slots through {@link ensureCapacity} and {@link build_slots}, never on the atlas
+     * directly: a slot handed out of order would no longer be its geometry's id.
+     * @return {GPUTileAtlas3D}
      */
-    get texture(): GPUTextureContext;
+    get atlas(): GPUTileAtlas3D;
     /**
-     *
+     * Individual SDF textures are written here. Replaced when the atlas grows, so take a view after
+     * {@link build_slots}, never across it.
+     * @return {import("../../texture/GPUTextureContext.js").GPUTextureContext}
+     */
+    get texture(): import("../../texture/GPUTextureContext.js").GPUTextureContext;
+    /**
+     * Resolution in SDF texels for a single geometry, which is also the stride between tiles: the
+     * atlas holds them with no border.
      * @return {number}
      */
     get tile_resolution(): number;
-    get atlas_resolution_in_tiles(): number[];
     /**
-     *
-     * @return {number}
+     * Tiles along x, y and z — what `sdf_slot_index_to_texture_offset` takes to place a slot. Read it
+     * after {@link build_slots}: when the atlas widens, x or y changes and every tile moves.
+     * @return {number[]}
      */
-    computeMaxSlotsPerDimension(): number;
+    get atlas_resolution_in_tiles(): number[];
     /**
-     *
+     * Slots the texture holds now.
      * @return {number}
      */
-    computeMaxCapacity(): number;
+    get capacity(): number;
     /**
+     * Claim every slot below `min_capacity`, growing the atlas as it fills.
      *
      * @param {number} min_capacity
      */
     ensureCapacity(min_capacity: number): void;
-    get capacity(): number;
-    /**
-     *
-     * @param {number} capacity in slots
-     */
-    allocate(capacity: number): void;
     destroy(): void;
     /**
      *
@@ -45,14 +61,7 @@ export class GPUGeometrySDFManager {
      */
     build_slots(command_ctx: ShadeGPUCommandContext, slot_indices: number[], geometries: GPUGeometryManager): void;
     /**
-     *
-     * @param {number} slot_index
-     * @return {number[]}
-     */
-    index_to_slot(slot_index: number): number[];
-    /**
-     * Downloads raw data for a given slot
-     * NOTE: this is mainly for debug, because of limitations in WebGPU API slot resolution must be 64 for it to work properly
+     * Downloads raw data for a given slot. Mainly for debugging.
      * @param {number} slot
      * @return {Promise<Float32Array>}
      */
@@ -61,5 +70,6 @@ export class GPUGeometrySDFManager {
 }
 export type ShadeGPUCommandContext = import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type GPUGeometryManager = import("../GPUGeometryManager.js").GPUGeometryManager;
-import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
+export type GPUGeometryBVHManager = import("../bvh/GPUGeometryBVHManager.js").GPUGeometryBVHManager;
+import { GPUTileAtlas3D } from "../../texture/atlas/GPUTileAtlas3D.js";
 //# sourceMappingURL=GPUGeometrySDFManager.d.ts.map

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAwBA;IAoKI;;;OAGG;IACH,+BAqBC;IAhLD;;;OAGG;IACH,iCAEC;IAQD;;;OAGG;IACH,8BAEC;IAQD,0CAEC;IAED;;;OAGG;IACH,+BAFY,MAAM,CAMjB;IAED;;;OAGG;IACH,sBAFY,MAAM,CA6BjB;IAED;;;OAGG;IACH,6BAFW,MAAM,QAoChB;IAED,uBAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QA4BhB;IA6BD,gBAEC;IAGD;;;;;OAKG;IACH,yBAJW,sBAAsB,gBACtB,MAAM,EAAE,cACR,kBAAkB,QAuD5B;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACL,MAAM,EAAE,CAgBnB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACL,QAAQ,YAAY,CAAC,CAiBhC;;CACJ;qCA5TY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,0BAA0B,EAAE,kBAAkB;kCANhC,oCAAoC"}
+{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;GAYG;AACH;IAaI;;;OAGG;IACH,+BAeC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,8EAEC;IAED;;;;OAIG;IACH,8BAEC;IAED;;;;OAIG;IACH,0CASC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAYhB;IAED,gBAEC;IAGD;;;;;OAKG;IACH,yBAJW,sBAAsB,gBACtB,MAAM,EAAE,cACR,kBAAkB,QAyD5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,QAAQ,YAAY,CAAC,CAOhC;;CACJ;qCA3NY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,0BAA0B,EAAE,kBAAkB;oCACrD,OAAO,iCAAiC,EAAE,qBAAqB;+BAP7C,uCAAuC"}