@woosh/meep-engine 3.61.0 → 3.61.2

package/src/engine/graphics3/decal/DECAL_GPU_RECORD.d.ts

@@ -6,6 +6,12 @@
  * ask, per pixel, whether a world position is inside the cube and where in the decal's texture it
  * lands. Deriving either from the other is a matrix inverse — cheap once on the CPU, and absurd per
  * pixel per decal inside the composite's loop.
+ *
+ * **Shaders read the record as `array<u32>`** and bitcast the float fields. The packed weights are
+ * bit patterns, not floats — a weight of one in a high half reads as a NaN — and neither WGSL nor a
+ * JavaScript `Float32Array` promises to keep a NaN's bits through a float load, so the words are only
+ * ever moved as integers and never read through a float view. The CPU writes them through a
+ * `Uint32Array` over the same memory.
  */
 export const DECAL_GPU_RECORD: WebGPUStruct;
 /**
@@ -44,6 +50,14 @@ export const DECAL_RECORD_OFFSET_EMISSIVE: number;
  * @type {number}
  */
 export const DECAL_RECORD_OFFSET_PARAMS: number;
+/**
+ * @type {number}
+ */
+export const DECAL_RECORD_OFFSET_WEIGHTS: number;
+/**
+ * @type {number}
+ */
+export const DECAL_RECORD_OFFSET_WEIGHT_EMISSIVE: number;
 /**
  * @type {number}
  */

package/src/engine/graphics3/decal/DECAL_GPU_RECORD.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DECAL_GPU_RECORD.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/DECAL_GPU_RECORD.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,4CAsDyB;AAEzB;;GAEG;AACH,sCAFU,MAAM,CAEiD;AAEjE;;GAEG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,oDAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,4CAFU,MAAM,CAEgC;AAEhD;;GAEG;AACH,4CAFU,MAAM,CAEgC;AAEhD;;GAEG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;GAEG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;GAEG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;GAEG;AACH,sCAFU,MAAM,CAE0B;6BAnHb,qDAAqD"}
+{"version":3,"file":"DECAL_GPU_RECORD.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/DECAL_GPU_RECORD.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,4CAkEyB;AAczB;;GAEG;AACH,sCAFU,MAAM,CAEiD;AAEjE;;GAEG;AACH,4CAFU,MAAM,CAEsD;AAEtE;;GAEG;AACH,oDAFU,MAAM,CAEsE;AAEtF;;GAEG;AACH,4CAFU,MAAM,CAEsD;AAEtE;;GAEG;AACH,4CAFU,MAAM,CAEsD;AAEtE;;GAEG;AACH,yCAFU,MAAM,CAEgD;AAEhE;;GAEG;AACH,wCAFU,MAAM,CAE8C;AAE9D;;GAEG;AACH,2CAFU,MAAM,CAEoD;AAEpE;;GAEG;AACH,yCAFU,MAAM,CAEgD;AAEhE;;GAEG;AACH,0CAFU,MAAM,CAEkD;AAElE;;GAEG;AACH,kDAFU,MAAM,CAEkE;AAElF;;GAEG;AACH,sCAFU,MAAM,CAE0C;6BA3J7B,qDAAqD"}

package/src/engine/graphics3/decal/DECAL_GPU_RECORD.js

@@ -1,4 +1,4 @@
-import { mat4x4f, vec4f } from "../../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { mat4x4f, u32, vec2f, vec2u, vec3f, vec4f } from "../../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
 
 /**
@@ -9,6 +9,12 @@ import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.j
  * ask, per pixel, whether a world position is inside the cube and where in the decal's texture it
  * lands. Deriving either from the other is a matrix inverse — cheap once on the CPU, and absurd per
  * pixel per decal inside the composite's loop.
+ *
+ * **Shaders read the record as `array<u32>`** and bitcast the float fields. The packed weights are
+ * bit patterns, not floats — a weight of one in a high half reads as a NaN — and neither WGSL nor a
+ * JavaScript `Float32Array` promises to keep a NaN's bits through a float load, so the words are only
+ * ever moved as integers and never read through a float view. The CPU writes them through a
+ * `Uint32Array` over the same memory.
  */
 export const DECAL_GPU_RECORD = WebGPUStruct.from({
     /**
@@ -47,12 +53,24 @@ export const DECAL_GPU_RECORD = WebGPUStruct.from({
      * `emissive_color.rgb * emissive_intensity`. Zero for every decal that does not emit, which is
      * every decal the game authors today.
      */
-    emissive: vec4f,
+    emissive: vec3f,
+
+    /**
+     * `pack2x16unorm(emissive_weight, 0)`.
+     */
+    weight_emissive: u32,
+
+    /**
+     * roughness, metalness.
+     */
+    params: vec2f,
 
     /**
-     * roughness, metalness, and two spare.
+     * `pack2x16unorm(albedo_weight, normal_weight)`, `pack2x16unorm(roughness_weight, metalness_weight)`:
+     * how much of each channel the decal writes, each scaling the mask's coverage for that channel
+     * alone.
      */
-    params: vec4f,
+    weights: vec2u,
 
     /**
      * The deepest mip level each of the three atlases may be sampled at for this decal — albedo,
@@ -66,6 +84,18 @@ export const DECAL_GPU_RECORD = WebGPUStruct.from({
     lod: vec4f,
 }, "DecalRecord").pack();
 
+/**
+ * Where a field sits, in words. Derived from the struct, because {@link WebGPUStruct#pack} chooses the
+ * order, and an offset written by hand would go on agreeing with the shaders while disagreeing with the
+ * layout the record declares.
+ *
+ * @param {string} name
+ * @returns {number}
+ */
+function word_offset(name) {
+    return DECAL_GPU_RECORD.get(name).offset / 4;
+}
+
 /**
  * @type {number}
  */
@@ -74,44 +104,54 @@ export const DECAL_RECORD_WORD_COUNT = DECAL_GPU_RECORD.size / 4;
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_TRANSFORM = 0;
+export const DECAL_RECORD_OFFSET_TRANSFORM = word_offset("transform");
+
+/**
+ * @type {number}
+ */
+export const DECAL_RECORD_OFFSET_TRANSFORM_INVERSE = word_offset("transform_inverse");
+
+/**
+ * @type {number}
+ */
+export const DECAL_RECORD_OFFSET_UV_ALBEDO = word_offset("uv_albedo");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_TRANSFORM_INVERSE = 16;
+export const DECAL_RECORD_OFFSET_UV_NORMAL = word_offset("uv_normal");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_UV_ALBEDO = 32;
+export const DECAL_RECORD_OFFSET_UV_ORM = word_offset("uv_orm");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_UV_NORMAL = 36;
+export const DECAL_RECORD_OFFSET_COLOR = word_offset("color");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_UV_ORM = 40;
+export const DECAL_RECORD_OFFSET_EMISSIVE = word_offset("emissive");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_COLOR = 44;
+export const DECAL_RECORD_OFFSET_PARAMS = word_offset("params");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_EMISSIVE = 48;
+export const DECAL_RECORD_OFFSET_WEIGHTS = word_offset("weights");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_PARAMS = 52;
+export const DECAL_RECORD_OFFSET_WEIGHT_EMISSIVE = word_offset("weight_emissive");
 
 /**
  * @type {number}
  */
-export const DECAL_RECORD_OFFSET_LOD = 56;
+export const DECAL_RECORD_OFFSET_LOD = word_offset("lod");

package/src/engine/graphics3/decal/chunk_decal_record.d.ts

@@ -1,7 +1,12 @@
 /**
- * Shared WGSL accessors for reading packed decal records (`array<f32>`) from a `decal_data` storage buffer.
+ * Shared WGSL accessors for reading packed decal records from a `decal_data` storage buffer bound as
+ * `array<u32>`. Float fields are bitcast out of their words; packed fields are read as the words
+ * they are (see {@link DECAL_GPU_RECORD}).
  *
  * ```wgsl
+ * fn decal_word(index: u32, field: u32) -> u32
+ * fn decal_vec2(index: u32, field: u32) -> vec2<f32>
+ * fn decal_vec3(index: u32, field: u32) -> vec3<f32>
  * fn decal_vec4(index: u32, field: u32) -> vec4<f32>
  * fn decal_matrix(index: u32, field: u32) -> mat4x4<f32>
  * fn decal_transform(index: u32) -> mat4x4<f32>

package/src/engine/graphics3/decal/chunk_decal_record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_decal_record.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/chunk_decal_record.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,iCAFU,SAAS,CA+BjB;0BA3CwB,sDAAsD"}
+{"version":3,"file":"chunk_decal_record.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/chunk_decal_record.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,iCAFU,SAAS,CA6CjB;0BA9DwB,sDAAsD"}

package/src/engine/graphics3/decal/chunk_decal_record.js

@@ -2,9 +2,14 @@ import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js"
 import { DECAL_RECORD_OFFSET_TRANSFORM, DECAL_RECORD_WORD_COUNT } from "./DECAL_GPU_RECORD.js";
 
 /**
- * Shared WGSL accessors for reading packed decal records (`array<f32>`) from a `decal_data` storage buffer.
+ * Shared WGSL accessors for reading packed decal records from a `decal_data` storage buffer bound as
+ * `array<u32>`. Float fields are bitcast out of their words; packed fields are read as the words
+ * they are (see {@link DECAL_GPU_RECORD}).
  *
  * ```wgsl
+ * fn decal_word(index: u32, field: u32) -> u32
+ * fn decal_vec2(index: u32, field: u32) -> vec2<f32>
+ * fn decal_vec3(index: u32, field: u32) -> vec3<f32>
  * fn decal_vec4(index: u32, field: u32) -> vec4<f32>
  * fn decal_matrix(index: u32, field: u32) -> mat4x4<f32>
  * fn decal_transform(index: u32) -> mat4x4<f32>
@@ -18,22 +23,36 @@ export const chunk_decal_record = CodeChunk.from(
 const DECAL_RECORD_WORD_COUNT : u32 = ${DECAL_RECORD_WORD_COUNT}u;
 const DECAL_RECORD_OFFSET_TRANSFORM : u32 = ${DECAL_RECORD_OFFSET_TRANSFORM}u;
 
+fn decal_word(index: u32, field: u32) -> u32 {
+    return decal_data[index * DECAL_RECORD_WORD_COUNT + field];
+}
+
+fn decal_vec2(index: u32, field: u32) -> vec2<f32> {
+    let base = index * DECAL_RECORD_WORD_COUNT + field;
+
+    return bitcast<vec2<f32>>(vec2<u32>(decal_data[base], decal_data[base + 1u]));
+}
+
+fn decal_vec3(index: u32, field: u32) -> vec3<f32> {
+    let base = index * DECAL_RECORD_WORD_COUNT + field;
+
+    return bitcast<vec3<f32>>(vec3<u32>(decal_data[base], decal_data[base + 1u], decal_data[base + 2u]));
+}
+
 fn decal_vec4(index: u32, field: u32) -> vec4<f32> {
     let base = index * DECAL_RECORD_WORD_COUNT + field;
 
-    return vec4<f32>(
+    return bitcast<vec4<f32>>(vec4<u32>(
         decal_data[base], decal_data[base + 1u], decal_data[base + 2u], decal_data[base + 3u]
-    );
+    ));
 }
 
 fn decal_matrix(index: u32, field: u32) -> mat4x4<f32> {
-    let base = index * DECAL_RECORD_WORD_COUNT + field;
-
     return mat4x4<f32>(
-        vec4<f32>(decal_data[base + 0u],  decal_data[base + 1u],  decal_data[base + 2u],  decal_data[base + 3u]),
-        vec4<f32>(decal_data[base + 4u],  decal_data[base + 5u],  decal_data[base + 6u],  decal_data[base + 7u]),
-        vec4<f32>(decal_data[base + 8u],  decal_data[base + 9u],  decal_data[base + 10u], decal_data[base + 11u]),
-        vec4<f32>(decal_data[base + 12u], decal_data[base + 13u], decal_data[base + 14u], decal_data[base + 15u])
+        decal_vec4(index, field),
+        decal_vec4(index, field + 4u),
+        decal_vec4(index, field + 8u),
+        decal_vec4(index, field + 12u)
     );
 }
 

package/src/engine/graphics3/decal/decal_gpu_records.d.ts

@@ -2,13 +2,14 @@
  * Write one decal into the buffer every decal shader reads.
  *
  * @param {Float32Array} target
+ * @param {Uint32Array} target_words the same memory as `target`, for the fields that are bit patterns
  * @param {number} offset in words, a multiple of the record size
  * @param {Decal} decal
  * @param {Float32Array|number[]} matrix the entity's world transform, column-major
  * @param {{albedo: Rectangle, normal: Rectangle, orm: Rectangle}} uv atlas rectangles
  * @param {{albedo: number, normal: number, orm: number}} max_lod per atlas, from each patch's border
  */
-export function write_decal_record(target: Float32Array, offset: number, decal: Decal, matrix: Float32Array | number[], uv: {
+export function write_decal_record(target: Float32Array, target_words: Uint32Array, offset: number, decal: Decal, matrix: Float32Array | number[], uv: {
     albedo: Rectangle;
     normal: Rectangle;
     orm: Rectangle;

package/src/engine/graphics3/decal/decal_gpu_records.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decal_gpu_records.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/decal_gpu_records.js"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AACH,2CAPW,YAAY,UACZ,MAAM,wBAEN,YAAY,GAAC,MAAM,EAAE,MACrB;IAAC,MAAM,YAAY;IAAC,MAAM,YAAY;IAAC,GAAG,YAAW;CAAC,WACtD;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,QAmDvD;AAED;;;;;;;;;;;;GAYG;AACH,iDAHW,MAAM;IAAC,KAAK,QAAO;CAAC,CAAC,GACnB,MAAM;IAAC,KAAK,QAAO;CAAC,CAAC,CAoBjC"}
+{"version":3,"file":"decal_gpu_records.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/decal_gpu_records.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;GAUG;AACH,2CARW,YAAY,gBACZ,WAAW,UACX,MAAM,wBAEN,YAAY,GAAC,MAAM,EAAE,MACrB;IAAC,MAAM,YAAY;IAAC,MAAM,YAAY;IAAC,GAAG,YAAW;CAAC,WACtD;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,QAsDvD;AAED;;;;;;;;;;;;GAYG;AACH,iDAHW,MAAM;IAAC,KAAK,QAAO;CAAC,CAAC,GACnB,MAAM;IAAC,KAAK,QAAO;CAAC,CAAC,CAoBjC"}

package/src/engine/graphics3/decal/decal_gpu_records.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
 import { array_copy } from "../../../core/collection/array/array_copy.js";
+import { clamp01 } from "../../../core/math/clamp01.js";
 import {
     DECAL_RECORD_OFFSET_COLOR,
     DECAL_RECORD_OFFSET_EMISSIVE,
@@ -10,9 +11,25 @@ import {
     DECAL_RECORD_OFFSET_TRANSFORM_INVERSE,
     DECAL_RECORD_OFFSET_UV_ALBEDO,
     DECAL_RECORD_OFFSET_UV_NORMAL,
-    DECAL_RECORD_OFFSET_UV_ORM
+    DECAL_RECORD_OFFSET_UV_ORM,
+    DECAL_RECORD_OFFSET_WEIGHT_EMISSIVE,
+    DECAL_RECORD_OFFSET_WEIGHTS
 } from "./DECAL_GPU_RECORD.js";
 
+/**
+ * WGSL's `pack2x16unorm`: `low` in bits 0..15, `high` in bits 16..31, each clamped to [0, 1].
+ *
+ * @param {number} low
+ * @param {number} high
+ * @returns {number} u32
+ */
+function pack2x16unorm(low, high) {
+    const x = Math.round(clamp01(low) * 65535);
+    const y = Math.round(clamp01(high) * 65535);
+
+    return ((y << 16) | x) >>> 0;
+}
+
 /**
  * @param {Float32Array} target
  * @param {number} offset in words
@@ -29,14 +46,17 @@ function write_uv(target, offset, uv) {
  * Write one decal into the buffer every decal shader reads.
  *
  * @param {Float32Array} target
+ * @param {Uint32Array} target_words the same memory as `target`, for the fields that are bit patterns
  * @param {number} offset in words, a multiple of the record size
  * @param {Decal} decal
  * @param {Float32Array|number[]} matrix the entity's world transform, column-major
  * @param {{albedo: Rectangle, normal: Rectangle, orm: Rectangle}} uv atlas rectangles
  * @param {{albedo: number, normal: number, orm: number}} max_lod per atlas, from each patch's border
  */
-export function write_decal_record(target, offset, decal, matrix, uv, max_lod) {
+export function write_decal_record(target, target_words, offset, decal, matrix, uv, max_lod) {
     assert.defined(target, 'target');
+    assert.equal(target_words.buffer, target.buffer, 'target_words aliases target');
+    assert.equal(target_words.byteOffset, target.byteOffset, 'target_words.byteOffset === target.byteOffset');
     assert.defined(decal, 'decal');
     assert.defined(matrix, 'matrix');
 
@@ -73,12 +93,13 @@ export function write_decal_record(target, offset, decal, matrix, uv, max_lod) {
     target[offset + DECAL_RECORD_OFFSET_EMISSIVE] = emissive.r * intensity;
     target[offset + DECAL_RECORD_OFFSET_EMISSIVE + 1] = emissive.g * intensity;
     target[offset + DECAL_RECORD_OFFSET_EMISSIVE + 2] = emissive.b * intensity;
-    target[offset + DECAL_RECORD_OFFSET_EMISSIVE + 3] = 0;
 
     target[offset + DECAL_RECORD_OFFSET_PARAMS] = decal.roughness;
     target[offset + DECAL_RECORD_OFFSET_PARAMS + 1] = decal.metalness;
-    target[offset + DECAL_RECORD_OFFSET_PARAMS + 2] = 0;
-    target[offset + DECAL_RECORD_OFFSET_PARAMS + 3] = 0;
+
+    target_words[offset + DECAL_RECORD_OFFSET_WEIGHTS] = pack2x16unorm(decal.albedo_weight, decal.normal_weight);
+    target_words[offset + DECAL_RECORD_OFFSET_WEIGHTS + 1] = pack2x16unorm(decal.roughness_weight, decal.metalness_weight);
+    target_words[offset + DECAL_RECORD_OFFSET_WEIGHT_EMISSIVE] = pack2x16unorm(decal.emissive_weight, 0);
 
     target[offset + DECAL_RECORD_OFFSET_LOD] = max_lod.albedo;
     target[offset + DECAL_RECORD_OFFSET_LOD + 1] = max_lod.normal;

package/src/engine/graphics3/decal/decal_material_samplers.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Opaque white: a mask of one everywhere, and a colour that the tint alone decides.
+ *
+ * @returns {Sampler2D}
+ */
+export function decal_identity_albedo(): Sampler2D;
 /**
  * A flat tangent-space normal: (0, 0, 1) encoded the way a normal map stores it.
  *

package/src/engine/graphics3/decal/decal_material_samplers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decal_material_samplers.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/decal_material_samplers.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,yCAFa,SAAS,CAUrB;AAED;;;;;;;;;;;;;;GAcG;AACH,sCAFa,SAAS,CAWrB;AAED;;;;;;;;;;;;;GAaG;AACH,oCAJW,SAAS,GAAC,IAAI,YACd,SAAS,GAAC,IAAI,GACZ,SAAS,GAAC,IAAI,CAyC1B;0BA3GyB,6CAA6C"}
+{"version":3,"file":"decal_material_samplers.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/decal_material_samplers.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,yCAFa,SAAS,CAQrB;AAED;;;;GAIG;AACH,yCAFa,SAAS,CAUrB;AAED;;;;;;;;;;;;;;GAcG;AACH,sCAFa,SAAS,CAWrB;AAED;;;;;;;;;;;;;GAaG;AACH,oCAJW,SAAS,GAAC,IAAI,YACd,SAAS,GAAC,IAAI,GACZ,SAAS,GAAC,IAAI,CAyC1B;0BAxHyB,6CAA6C"}

package/src/engine/graphics3/decal/decal_material_samplers.js

@@ -12,6 +12,19 @@ import { Sampler2D } from "../../graphics/texture/sampler/Sampler2D.js";
  */
 const IDENTITY_SIZE = 8;
 
+/**
+ * Opaque white: a mask of one everywhere, and a colour that the tint alone decides.
+ *
+ * @returns {Sampler2D}
+ */
+export function decal_identity_albedo() {
+    const sampler = Sampler2D.uint8(4, IDENTITY_SIZE, IDENTITY_SIZE);
+
+    sampler.data.fill(255);
+
+    return sampler;
+}
+
 /**
  * A flat tangent-space normal: (0, 0, 1) encoded the way a normal map stores it.
  *

package/src/engine/graphics3/decal/shader_cluster_assign_decals.js

@@ -53,7 +53,7 @@ resources.createGroup()
     .addUniform("settings", DECAL_CLUSTER_ASSIGNMENT_SETTINGS);
 
 resources.createGroup()
-    .addStorageBuffer("decal_data", WebGPUArray.f32);
+    .addStorageBuffer("decal_data", WebGPUArray.u32);
 
 const CLUSTER_DATA_STRUCT = WebGPUStruct.from({
     offset: atomic_u32,

package/src/engine/graphics3/decal/shader_cull_decals_frustum.js

@@ -34,7 +34,7 @@ resources.createGroup()
     .addUniform("settings", SETTINGS_STRUCT);
 
 resources.createGroup()
-    .addStorageBuffer("decal_data", WebGPUArray.f32);
+    .addStorageBuffer("decal_data", WebGPUArray.u32);
 
 resources.createGroup()
     .addStorageBuffer("output", OUTPUT_STRUCT, true);

package/src/engine/graphics3/decal/shader_decal_composite.d.ts

@@ -9,6 +9,11 @@ export const DECAL_COMPOSITE_SETTINGS: WebGPUStruct;
  * `shader_decal_tile_copy`'s copy of the same tiles, so only the covered part of the screen
  * is read and written twice, rather than all of it once.
  *
+ * **Each channel blends by the decal's mask times that channel's own weight**, so a decal may write
+ * any subset of albedo, normal, roughness, metalness and emission. A channel no decal over a pixel
+ * weights comes back with exactly the bits it had, and a decal skips the atlas samples only its
+ * unweighted channels would read.
+ *
  * The face normal is carried through untouched. A decal changes what a surface looks like, not which
  * way it is turned, and the face normal is what the fade and everything downstream reason about.
  *

package/src/engine/graphics3/decal/shader_decal_composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AAgEA,oDAKG;AAuRH;;;;;;;;;;;;;;GAcG;AACH,qCAFU,eAAe,CActB;6BAzU0B,qDAAqD;gCARlD,sBAAsB"}
+{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AAkEA,oDAKG;AAyTH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qCAFU,eAAe,CActB;6BAlX0B,qDAAqD;gCARlD,sBAAsB"}

package/src/engine/graphics3/decal/shader_decal_composite.js

@@ -59,7 +59,9 @@ import {
     DECAL_RECORD_OFFSET_TRANSFORM_INVERSE,
     DECAL_RECORD_OFFSET_UV_ALBEDO,
     DECAL_RECORD_OFFSET_UV_NORMAL,
-    DECAL_RECORD_OFFSET_UV_ORM
+    DECAL_RECORD_OFFSET_UV_ORM,
+    DECAL_RECORD_OFFSET_WEIGHT_EMISSIVE,
+    DECAL_RECORD_OFFSET_WEIGHTS
 } from "./DECAL_GPU_RECORD.js";
 
 export const DECAL_COMPOSITE_SETTINGS = WebGPUStruct.from({
@@ -91,7 +93,7 @@ resources.createGroup()
     .addTexture("scene_depth");
 
 resources.createGroup()
-    .addStorageBuffer("decal_data", WebGPUArray.f32)
+    .addStorageBuffer("decal_data", WebGPUArray.u32)
     .addStorageBuffer("cluster_lookup", WebGPUArray.from(DECAL_CLUSTER_METADATA))
     .addStorageBuffer("cluster_data", WebGPUArray.u32)
     .addStorageBuffer("decal_tiles", WebGPUArray.u32);
@@ -227,6 +229,9 @@ fn main(
     var normal = shading_normal;
     var emissive = rgbe9995_decode(old_emissive);
 
+    var wrote_normal = false;
+    var wrote_emissive = false;
+
     let uv_bias = view_uv_derivative_bias(view.upscale_ratio);
 
     for (var i = 0u; i < metadata.count; i++) {
@@ -277,50 +282,81 @@ fn main(
         // coverage together and the fade scales both at once
         let source = albedo_sample * tint * fade;
 
+        // the mask: every channel blends by this, scaled by its own weight
         let coverage = source.a;
 
         if (coverage <= 0.0) {
             continue;
         }
 
-        albedo = source.rgb + albedo * (1.0 - coverage);
+        let weights_albedo_normal = unpack2x16unorm(decal_word(decal_index, ${DECAL_RECORD_OFFSET_WEIGHTS}u));
+        let weights_roughness_metalness = unpack2x16unorm(decal_word(decal_index, ${DECAL_RECORD_OFFSET_WEIGHTS + 1}u));
+        let weight_emissive = unpack2x16unorm(decal_word(decal_index, ${DECAL_RECORD_OFFSET_WEIGHT_EMISSIVE}u)).x;
 
-        let orm = textureSampleBarycentric(
-            atlas_orm,
-            atlas_orm_sampler,
-            decal_sampling_info(local_uv, duv_dx, duv_dy, decal_vec4(decal_index, ${DECAL_RECORD_OFFSET_UV_ORM}u), lod.z, atlas_orm_size)
-        );
+        let weight_albedo = weights_albedo_normal.x;
+        let weight_normal = weights_albedo_normal.y;
+        let weight_roughness = weights_roughness_metalness.x;
+        let weight_metalness = weights_roughness_metalness.y;
 
-        let params = decal_vec4(decal_index, ${DECAL_RECORD_OFFSET_PARAMS}u);
+        // premultiplied, so the weight scales the colour and the coverage it replaces alike
+        albedo = source.rgb * weight_albedo + albedo * (1.0 - coverage * weight_albedo);
 
-        // glTF packing, whose R channel is ambient occlusion and is deliberately unused
-        roughness = mix(roughness, orm.g * params.x, coverage);
-        metalness = mix(metalness, orm.b * params.y, coverage);
+        if (weight_roughness > 0.0 || weight_metalness > 0.0 || weight_emissive > 0.0) {
+            let orm = textureSampleBarycentric(
+                atlas_orm,
+                atlas_orm_sampler,
+                decal_sampling_info(local_uv, duv_dx, duv_dy, decal_vec4(decal_index, ${DECAL_RECORD_OFFSET_UV_ORM}u), lod.z, atlas_orm_size)
+            );
 
-        let tangent_normal = textureSampleBarycentric(
-            atlas_normal,
-            atlas_normal_sampler,
-            decal_sampling_info(local_uv, duv_dx, duv_dy, decal_vec4(decal_index, ${DECAL_RECORD_OFFSET_UV_NORMAL}u), lod.y, atlas_normal_size)
-        ).rgb * 2.0 - 1.0;
+            let params = decal_vec2(decal_index, ${DECAL_RECORD_OFFSET_PARAMS}u);
 
-        let decal_normal = normalize(
-            tangent_normal.x * frame.tangent
-            + tangent_normal.y * frame.bitangent
-            + tangent_normal.z * frame.normal
-        );
+            // glTF packing, whose R channel is ambient occlusion and is deliberately unused
+            roughness = mix(roughness, orm.g * params.x, coverage * weight_roughness);
+            metalness = mix(metalness, orm.b * params.y, coverage * weight_metalness);
+
+            if (weight_emissive > 0.0) {
+                let emission = decal_vec3(decal_index, ${DECAL_RECORD_OFFSET_EMISSIVE}u) * orm.a;
+
+                // lerp, not add: a decal is a surface override and occludes whatever was emitting beneath it
+                emissive = mix(emissive, emission, coverage * weight_emissive);
+
+                wrote_emissive = true;
+            }
+        }
+
+        if (weight_normal > 0.0) {
+            let tangent_normal = textureSampleBarycentric(
+                atlas_normal,
+                atlas_normal_sampler,
+                decal_sampling_info(local_uv, duv_dx, duv_dy, decal_vec4(decal_index, ${DECAL_RECORD_OFFSET_UV_NORMAL}u), lod.y, atlas_normal_size)
+            ).rgb * 2.0 - 1.0;
 
-        normal = normalize(mix(normal, decal_normal, coverage));
+            let decal_normal = normalize(
+                tangent_normal.x * frame.tangent
+                + tangent_normal.y * frame.bitangent
+                + tangent_normal.z * frame.normal
+            );
 
-        let emission = decal_vec4(decal_index, ${DECAL_RECORD_OFFSET_EMISSIVE}u).rgb * orm.a;
+            normal = normalize(mix(normal, decal_normal, coverage * weight_normal));
 
-        // lerp, not add: a decal is a surface override and occludes whatever was emitting beneath it
-        emissive = mix(emissive, emission, coverage);
+            wrote_normal = true;
+        }
     }
 
     out.albedo = vec4<f32>(albedo, old_albedo.a);
     out.pbr = vec2<f32>(metalness, roughness);
-    out.normal = vec4<u32>(encode_g_buffer_normal(normal), old_normal.zw);
-    out.emissive = rgbe9995_encode(emissive);
+
+    /*
+     The two encoded channels are re-encoded only when a decal wrote them: decoding and encoding
+     again is not exact, and a channel no decal weights must come back with the bits it had.
+    */
+    if (wrote_normal) {
+        out.normal = vec4<u32>(encode_g_buffer_normal(normal), old_normal.zw);
+    }
+
+    if (wrote_emissive) {
+        out.emissive = rgbe9995_encode(emissive);
+    }
 
     return out;
 }
@@ -356,6 +392,11 @@ fn main(
  * `shader_decal_tile_copy`'s copy of the same tiles, so only the covered part of the screen
  * is read and written twice, rather than all of it once.
  *
+ * **Each channel blends by the decal's mask times that channel's own weight**, so a decal may write
+ * any subset of albedo, normal, roughness, metalness and emission. A channel no decal over a pixel
+ * weights comes back with exactly the bits it had, and a decal skips the atlas samples only its
+ * unweighted channels would read.
+ *
  * The face normal is carried through untouched. A decal changes what a surface looks like, not which
  * way it is turned, and the face normal is what the fade and everything downstream reason about.
  *

package/src/engine/network/sim/SimActionExecutor.d.ts

@@ -224,6 +224,10 @@ export class SimActionExecutor {
     /**
      * Execute an action: capture prior state of affected components, apply, log.
      *
+     * Not re-entrant: calling `execute` or {@link record} from inside `affected_components`,
+     * {@link authorize}, `apply`, `announce` or {@link on_component_written} is illegal (the
+     * executor is passed to actions for `slot_table` / `current_sender_id` reads only).
+     *
      * @param {SimAction} action
      * @param {number} [sender_id] peer that originated this action.
      *   Defaults to {@link SENDER_LOCAL} for locally-originated actions.

package/src/engine/network/sim/SimActionExecutor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SimActionExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SimActionExecutor.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6BAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;GAUG;AACH,8BAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;GAMG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA2EI;;;;;;;;;OASG;IACH,sGATW;QACV,KAAS,yBAAyB;QAClC,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,kBAAsB,8BAA8B;QACpD,UAAc,uBAAuB;QACrC,gBAAoB,CAAC,mBAAmB;KACrC,EAyFH;IAjKD;;;;;;;;;OASG;IACH,gBAFU,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAEP;IAEtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC,GAAG,IAAI,CAEtE;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,sBAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,UAAU,KAAK,IAAI,CAAC,GAAG,IAAI,CAE7C;IAaxB;;OAEG;IACH,8BAAkB;IAElB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,gDAA4C;IAE5C;;;;OAIG;IACH,iCAA4B;IAE5B;;;;;;;;;;;OAWG;IACH,kBAFU,mBAAiB,IAAI,CAES;IA4BxC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEoB;IAGxC;;;;;;;;;;OAUG;IACH,uCAPW,MAAM,GAGJ,OAAO,CA0KnB;IAkCD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAwCC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAqChB;IAED;;;;;;;;OAQG;IACH,sBAJW,UAAU,UACV,MAAM,UACN,MAAM,QAchB;;CACJ;mBA7mBkB,uCAAuC"}
+{"version":3,"file":"SimActionExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SimActionExecutor.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6BAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;GAUG;AACH,8BAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;GAMG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA2EI;;;;;;;;;OASG;IACH,sGATW;QACV,KAAS,yBAAyB;QAClC,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,kBAAsB,8BAA8B;QACpD,UAAc,uBAAuB;QACrC,gBAAoB,CAAC,mBAAmB;KACrC,EAyFH;IAjKD;;;;;;;;;OASG;IACH,gBAFU,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAEP;IAEtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC,GAAG,IAAI,CAEtE;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,sBAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,UAAU,KAAK,IAAI,CAAC,GAAG,IAAI,CAE7C;IAaxB;;OAEG;IACH,8BAAkB;IAElB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,gDAA4C;IAE5C;;;;OAIG;IACH,iCAA4B;IAE5B;;;;;;;;;;;OAWG;IACH,kBAFU,mBAAiB,IAAI,CAES;IA4BxC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEoB;IAGxC;;;;;;;;;;;;;;OAcG;IACH,uCAPW,MAAM,GAGJ,OAAO,CA0KnB;IAkCD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAwCC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAqChB;IAED;;;;;;;;OAQG;IACH,sBAJW,UAAU,UACV,MAAM,UACN,MAAM,QAchB;;CACJ;mBAjnBkB,uCAAuC"}

package/src/engine/network/sim/SimActionExecutor.js

@@ -274,6 +274,10 @@ export class SimActionExecutor {
     /**
      * Execute an action: capture prior state of affected components, apply, log.
      *
+     * Not re-entrant: calling `execute` or {@link record} from inside `affected_components`,
+     * {@link authorize}, `apply`, `announce` or {@link on_component_written} is illegal (the
+     * executor is passed to actions for `slot_table` / `current_sender_id` reads only).
+     *
      * @param {SimAction} action
      * @param {number} [sender_id] peer that originated this action.
      *   Defaults to {@link SENDER_LOCAL} for locally-originated actions.

package/src/generation/foliage/material/foliage_atlas_cutout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foliage_atlas_cutout.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_atlas_cutout.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,mDARW,kBAAkB,WAClB,MAAM,WACN,UAAU,WACV,UAAU,gBACV,MAAM,SACN,MAAM,WACN,MAAM,QAiHhB;AAED;;;;;;;;GAQG;AACH,oDANW,kBAAkB,WAClB,MAAM,SACN,YAAY,SACZ,MAAM,WACN,MAAM,QAkBhB;AAED;;;;;;;;GAQG;AACH,8CAJW,OAAO,gCAAgC,EAAE,iBAAiB,QAC1D,kBAAkB,GAChB,kBAAkB,CAU9B;mCA7K4D,yBAAyB"}
+{"version":3,"file":"foliage_atlas_cutout.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_atlas_cutout.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,mDARW,kBAAkB,WAClB,MAAM,WACN,UAAU,WACV,UAAU,gBACV,MAAM,SACN,MAAM,WACN,MAAM,QAiHhB;AAED;;;;;;;;GAQG;AACH,oDANW,kBAAkB,WAClB,MAAM,SACN,YAAY,SACZ,MAAM,WACN,MAAM,QAkBhB;AAED;;;;;;;;GAQG;AACH,8CAJW,OAAO,gCAAgC,EAAE,iBAAiB,QAC1D,kBAAkB,GAChB,kBAAkB,CAqB9B;mCA3L4D,yBAAyB"}