@woosh/meep-engine 3.11.1 → 3.11.3

package/src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js

@@ -0,0 +1,69 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { ATMOSPHERE_RADII_DECLARATION } from "./ATMOSPHERE_RADII_DECLARATION.js";
+
+/**
+ * How far a ray inside the atmosphere may be marched, and whether it ends on the surface.
+ *
+ * The ground and the atmosphere shell are concentric on the planet and the ray is shared, so
+ * one quadratic setup serves both intersections — only the radius term differs. Calling a
+ * general sphere-intersection routine twice instead recomputes the ray-origin offset and all
+ * three dot products for the second sphere, and re-derives a leading coefficient that is 1
+ * for a unit direction.
+ *
+ * `origin_rel` is relative to the planet centre and assumed to be inside the atmosphere and
+ * at or above the surface, which is what makes the shell's far root the exit point.
+ * `ray_direction` must be normalised.
+ *
+ * `ground_distance` is negative when the ray never meets the surface, which includes looking
+ * up from above it: both roots are behind the origin there.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atmosphere_ray_bounds = CodeChunk.from(
+    //language=WGSL
+    `
+struct AtmosphereRayBounds {
+    // as far as a march may go: the surface when the ray meets it, the shell otherwise
+    t_max: f32,
+    // distance to the surface, negative when there is no hit ahead
+    ground_distance: f32,
+    hits_ground: bool,
+}
+
+fn atmosphere_ray_bounds(
+    origin_rel: vec3<f32>,
+    ray_direction: vec3<f32>
+) -> AtmosphereRayBounds {
+
+    // ray_direction is a unit vector, so the leading coefficient is 1 and the factors of two
+    // divide out of both roots
+    let b = dot(origin_rel, ray_direction);
+    let r2 = dot(origin_rel, origin_rel);
+    let b2 = b * b;
+
+    // inside the shell, so its constant term is negative, the discriminant is positive, and
+    // the far root is where the ray leaves
+    let atmosphere_distance = -b + sqrt(max(b2 - (r2 - ATMOSPHERE_TOP_RADIUS_SQUARED), 0.0));
+
+    // the ground is the near root, and only when that root is ahead of us
+    let ground_discriminant = b2 - (r2 - ATMOSPHERE_GROUND_RADIUS_SQUARED);
+    let ground_distance = select(
+        -1.0,
+        -b - sqrt(max(ground_discriminant, 0.0)),
+        ground_discriminant >= 0.0
+    );
+
+    let hits_ground = ground_distance > 0.0;
+
+    var result: AtmosphereRayBounds;
+
+    result.t_max = select(atmosphere_distance, ground_distance, hits_ground);
+    result.ground_distance = ground_distance;
+    result.hits_ground = hits_ground;
+
+    return result;
+}
+    `, [
+        ATMOSPHERE_RADII_DECLARATION,
+    ]
+);

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_contains_aabb3.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether `inner` lies entirely within `outer`. Closed on both sides: touching faces count as
+ * contained, matching {@link chunk_aabb3_intersects_point}'s treatment of the boundary.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_contains_aabb3: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_aabb3_contains_aabb3.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_contains_aabb3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_aabb3_contains_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_contains_aabb3.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,yCAFU,SAAS,CAcZ;0BArBmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_contains_aabb3.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { AABB3_STRUCT } from "./AABB3_STRUCT.js";
+
+/**
+ * Whether `inner` lies entirely within `outer`. Closed on both sides: touching faces count as
+ * contained, matching {@link chunk_aabb3_intersects_point}'s treatment of the boundary.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_contains_aabb3 = CodeChunk.from(
+    //language=WGSL
+    `
+fn aabb3_contains_aabb3(
+    outer: ${AABB3_STRUCT.wgsl_ref},
+    inner: ${AABB3_STRUCT.wgsl_ref}
+) -> bool{
+
+    return all(inner.min >= outer.min) && all(inner.max <= outer.max);
+
+}`, [
+        AABB3_STRUCT.declaration_chunk
+    ]);

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_from_transformed_corners.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bounds of 8 corner points after a point transform.
+ *
+ * The corners are transformed and *then* bounded, so the result is the tight bound of the
+ * transformed hull rather than the transform of a bound — no inflation under rotation. That
+ * distinction is the reason this exists instead of transforming an existing AABB3.
+ *
+ * Written out rather than looped: the corner array stays register-resident this way, and a
+ * dynamically indexed local array is the classic route to a scratch-memory spill in a kernel that
+ * runs once per froxel.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_from_transformed_corners: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_aabb3_from_transformed_corners.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_from_transformed_corners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_aabb3_from_transformed_corners.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_from_transformed_corners.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,mDAFU,SAAS,CA0BZ;0BAxCmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/aabb3/chunk_aabb3_from_transformed_corners.js

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { AABB3_STRUCT } from "./AABB3_STRUCT.js";
+
+/**
+ * Bounds of 8 corner points after a point transform.
+ *
+ * The corners are transformed and *then* bounded, so the result is the tight bound of the
+ * transformed hull rather than the transform of a bound — no inflation under rotation. That
+ * distinction is the reason this exists instead of transforming an existing AABB3.
+ *
+ * Written out rather than looped: the corner array stays register-resident this way, and a
+ * dynamically indexed local array is the classic route to a scratch-memory spill in a kernel that
+ * runs once per froxel.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_aabb3_from_transformed_corners = CodeChunk.from(
+    //language=WGSL
+    `
+fn aabb3_from_transformed_corners(
+    corners: array<vec3<f32>, 8>,
+    transform: mat4x4<f32>
+) -> ${AABB3_STRUCT.wgsl_ref}{
+
+    let p0 = (transform * vec4<f32>(corners[0], 1.0)).xyz;
+    let p1 = (transform * vec4<f32>(corners[1], 1.0)).xyz;
+    let p2 = (transform * vec4<f32>(corners[2], 1.0)).xyz;
+    let p3 = (transform * vec4<f32>(corners[3], 1.0)).xyz;
+    let p4 = (transform * vec4<f32>(corners[4], 1.0)).xyz;
+    let p5 = (transform * vec4<f32>(corners[5], 1.0)).xyz;
+    let p6 = (transform * vec4<f32>(corners[6], 1.0)).xyz;
+    let p7 = (transform * vec4<f32>(corners[7], 1.0)).xyz;
+
+    let lo = min(min(min(p0, p1), min(p2, p3)), min(min(p4, p5), min(p6, p7)));
+    let hi = max(max(max(p0, p1), max(p2, p3)), max(max(p4, p5), max(p6, p7)));
+
+    return ${AABB3_STRUCT.make({ min: "lo", max: "hi" })};
+
+}`, [
+        AABB3_STRUCT.declaration_chunk
+    ]);

package/src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_m4.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Transforms a frustum's 6 planes by a point transform, deriving the plane matrix from it.
+ *
+ * The derivation costs a generic 4x4 inverse. When the caller already holds the inverse of the
+ * transform it is passing — which is the usual shape, since object structs tend to carry both
+ * directions — `transpose(inverse(M)) == transpose(other_direction)` and
+ * {@link chunk_frustum_transform_plane_matrix} should be called directly with that transpose
+ * instead. Nothing is approximated by doing so; it removes a round-trip.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_frustum_transform_m4: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_frustum_transform_m4.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_m4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_frustum_transform_m4.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_m4.js"],"names":[],"mappings":"AAIA,mDA2BC;0BA/ByB,gCAAgC"}
+{"version":3,"file":"chunk_frustum_transform_m4.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_m4.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,yCAFU,SAAS,CAelB;0BA5ByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_m4.js

@@ -1,33 +1,29 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_mat4_inverse } from "../mat4/chunk_mat4_inverse.js";
-import { chunk_plane_normalize } from "../plane/chunk_plane_normalize.js";
+import { chunk_frustum_transform_plane_matrix } from "./chunk_frustum_transform_plane_matrix.js";
 
+/**
+ * Transforms a frustum's 6 planes by a point transform, deriving the plane matrix from it.
+ *
+ * The derivation costs a generic 4x4 inverse. When the caller already holds the inverse of the
+ * transform it is passing — which is the usual shape, since object structs tend to carry both
+ * directions — `transpose(inverse(M)) == transpose(other_direction)` and
+ * {@link chunk_frustum_transform_plane_matrix} should be called directly with that transpose
+ * instead. Nothing is approximated by doing so; it removes a round-trip.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_frustum_transform_m4 = CodeChunk.from(
     //language=WGSL
     `
 fn frustum_transform_m4(frustum: array<vec4<f32>, 6>, transform: mat4x4<f32>) -> array<vec4<f32>, 6> {
-    var result: array<vec4<f32>, 6>;
-
-    // 1. Compute the "Normal Matrix"
-    // The mathematical rule for transforming planes (or normals) is:
+    // The mathematical rule for transforming planes is
     // NewPlane = Transpose(Inverse(Transform)) * OldPlane
     // This automatically handles rotation, translation, AND non-uniform scaling correctly.
-    let normal_matrix = transpose(mat4_inverse(transform));
-
-    for (var i = 0u; i < 6u; i++) {
-        // 2. Transform the plane equation
-        // We treat the plane (a,b,c,d) as a 4D vector.
-        var p = normal_matrix * frustum[i];
-
-        // 3. Re-normalize the plane
-        result[i] = plane_normalize(p);
-    }
-
-    return result;
+    return frustum_transform_plane_matrix(frustum, transpose(mat4_inverse(transform)));
 }
     `, [
         chunk_mat4_inverse,
-        chunk_plane_normalize,
+        chunk_frustum_transform_plane_matrix,
     ]
 )
-

package/src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Transforms a frustum's 6 planes by an already-built plane matrix.
+ *
+ * A plane `p` satisfies `dot(p, x) == 0` for points `x` on it, so if points move by `x' = T x` the
+ * plane must move by `p' = inverse(transpose(T)) p` to describe the same surface. `T` and its
+ * transpose-inverse are therefore *different* matrices, and this function takes the second one
+ * ready-made — {@link chunk_frustum_transform_m4} is the wrapper that derives it from the first.
+ *
+ * The matrix is a full 4x4, not a 3x3 basis: its last row carries the translation, and that is
+ * exactly what produces the transformed plane's distance term. Rotating the normals alone would
+ * leave every plane at its original offset from the origin.
+ *
+ * Callers that already hold the transpose-inverse should use this directly. The common case is
+ * mapping a frustum into an object's local space: points go world -> local through
+ * `inverse(transform)`, so planes go through `transpose(inverse(inverse(transform)))`, which is just
+ * `transpose(transform)` — no inverse to compute at all when the object's forward transform is at
+ * hand.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_frustum_transform_plane_matrix: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_frustum_transform_plane_matrix.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_frustum_transform_plane_matrix.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mDAFU,SAAS,CAsBlB;0BA3CyB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js

@@ -0,0 +1,44 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_plane_normalize } from "../plane/chunk_plane_normalize.js";
+
+/**
+ * Transforms a frustum's 6 planes by an already-built plane matrix.
+ *
+ * A plane `p` satisfies `dot(p, x) == 0` for points `x` on it, so if points move by `x' = T x` the
+ * plane must move by `p' = inverse(transpose(T)) p` to describe the same surface. `T` and its
+ * transpose-inverse are therefore *different* matrices, and this function takes the second one
+ * ready-made — {@link chunk_frustum_transform_m4} is the wrapper that derives it from the first.
+ *
+ * The matrix is a full 4x4, not a 3x3 basis: its last row carries the translation, and that is
+ * exactly what produces the transformed plane's distance term. Rotating the normals alone would
+ * leave every plane at its original offset from the origin.
+ *
+ * Callers that already hold the transpose-inverse should use this directly. The common case is
+ * mapping a frustum into an object's local space: points go world -> local through
+ * `inverse(transform)`, so planes go through `transpose(inverse(inverse(transform)))`, which is just
+ * `transpose(transform)` — no inverse to compute at all when the object's forward transform is at
+ * hand.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_frustum_transform_plane_matrix = CodeChunk.from(
+    //language=WGSL
+    `
+fn frustum_transform_plane_matrix(
+    frustum: array<vec4<f32>, 6>, 
+    plane_matrix: mat4x4<f32>
+) -> array<vec4<f32>, 6> {
+    var result: array<vec4<f32>, 6>;
+
+    for (var i = 0u; i < 6u; i++) {
+        // Re-normalize: the plane's normal picks up the transform's scale, and consumers that
+        // interpolate plane pairs (frustum_sample_point, frustum_slice) weight by normal length.
+        result[i] = plane_normalize(plane_matrix * frustum[i]);
+    }
+
+    return result;
+}
+    `, [
+        chunk_plane_normalize,
+    ]
+)

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_uv_octahedral_unit_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,8CAFU,SAAS,CAmBb;0BA5BoB,gCAAgC"}
+{"version":3,"file":"chunk_uv_octahedral_unit_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8CAFU,SAAS,CAiBb;0BAzBoB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js

@@ -1,5 +1,4 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_sign_not_zero } from "../../math/chunk_sign_not_zero.js";
 
 /**
  *
@@ -24,6 +23,4 @@ fn uv_octahedral_unit_decode( uv: vec2<f32> ) -> vec3<f32>{
 
     return normalize( nor );
 }
-`,[
-    chunk_sign_not_zero
-    ])
+`, [])

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

@@ -23,6 +23,11 @@ export class CodeChunk {
      * @returns {boolean} true iff added, false if already present
      */
     addExtension(extension: WebGPUExtensionType): boolean;
+    /**
+     * @param {string} extension a WGSL language extension name, e.g. `immediate_address_space`
+     * @returns {boolean} true iff added, false if already present
+     */
+    addLanguageExtension(extension: string): boolean;
     /**
      *
      * @param {CodeChunk} dependency
@@ -52,11 +57,12 @@ export class CodeChunk {
      */
     coalesceDependencies(): CodeChunk[];
     /**
-     * @returns {{text:string, extensions: string[]}}
+     * @returns {{text:string, extensions: string[], language_extensions: string[]}}
      */
     compile(): {
         text: string;
         extensions: string[];
+        language_extensions: string[];
     };
     toString(): string;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"CodeChunk.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/compiler/CodeChunk.js"],"names":[],"mappings":"AAOA;IAMI;;;OAGG;IACH,cAFU,SAAS,SAAS,CAAC,CAEoB;IAwEjD;;;;;OAKG;IACH,kBAHW,MAAM,iBADN,SAAS,EAAE,GAET,SAAS,CAqBrB;IAzGD,2BAEC;IAcD;;;OAGG;IACH,mBAEC;IAeD;;;;OAIG;IACH,wBAHW,mBAAmB,GACjB,OAAO,CAMnB;IAED;;;;OAIG;IACH,0BAHW,SAAS,GACP,OAAO,CAmBnB;IAqCD;;;;OAIG;IACH,6CAHW,IAAI,SAAS,CAAC,GACZ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,+BAHW,SAAS,GACP,OAAO,CAqBnB;IAED;;;OAGG;IACH,uBAFa,SAAS,EAAE,CAoCvB;IAED;;;OAGG;IACH,wBAFY,SAAS,EAAE,CAgDtB;IAED;;OAEG;IACH;cAFmB,MAAM;oBAAc,MAAM,EAAE;MAoC9C;IAED,mBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFW,SAAS,QAMnB;IAED;;;OAGG;IACH,SAFY,SAAS,CAQpB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAWnB;;CACJ;oCAnVmC,4CAA4C"}
+{"version":3,"file":"CodeChunk.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/compiler/CodeChunk.js"],"names":[],"mappings":"AAOA;IAMI;;;OAGG;IACH,cAFU,SAAS,SAAS,CAAC,CAEoB;IAkGjD;;;;;OAKG;IACH,kBAHW,MAAM,iBADN,SAAS,EAAE,GAET,SAAS,CAqBrB;IAnID,2BAEC;IAcD;;;OAGG;IACH,mBAEC;IAeD;;;;OAIG;IACH,wBAHW,mBAAmB,GACjB,OAAO,CAMnB;IAkBD;;;OAGG;IACH,gCAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,0BAHW,SAAS,GACP,OAAO,CAmBnB;IAqCD;;;;OAIG;IACH,6CAHW,IAAI,SAAS,CAAC,GACZ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,+BAHW,SAAS,GACP,OAAO,CAqBnB;IAED;;;OAGG;IACH,uBAFa,SAAS,EAAE,CAoCvB;IAED;;;OAGG;IACH,wBAFY,SAAS,EAAE,CAgDtB;IAED;;OAEG;IACH;cAFmB,MAAM;oBAAc,MAAM,EAAE;6BAAuB,MAAM,EAAE;MA4C7E;IAED,mBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFW,SAAS,QAOnB;IAED;;;OAGG;IACH,SAFY,SAAS,CAQpB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAWnB;;CACJ;oCAtXmC,4CAA4C"}

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

@@ -55,6 +55,32 @@ export class CodeChunk {
         return array_push_if_unique(this.#extensions, extension);
     }
 
+    /**
+     * WGSL language extensions this chunk uses, emitted as `requires`.
+     *
+     * A separate channel from {@link #extensions} on purpose. WGSL has two kinds of extension and
+     * they take different directives: an *enable-extension* is a device capability negotiated
+     * through `GPUFeatureName` and written `enable f16;`, while a *language extension* is available
+     * whenever the implementation supports it, is not a `GPUFeatureName` at all, and is written
+     * `requires immediate_address_space;`. Putting a language extension through
+     * {@link addExtension} would fail its {@link WebGPUExtensionType} assert, and if it somehow got
+     * past that it would emit the wrong directive and be looked for in the wrong namespace.
+     *
+     * @see https://www.w3.org/TR/WGSL/#language-extensions
+     * @type {string[]}
+     */
+    #language_extensions = [];
+
+    /**
+     * @param {string} extension a WGSL language extension name, e.g. `immediate_address_space`
+     * @returns {boolean} true iff added, false if already present
+     */
+    addLanguageExtension(extension) {
+        assert.isString(extension, 'extension');
+
+        return array_push_if_unique(this.#language_extensions, extension);
+    }
+
     /**
      *
      * @param {CodeChunk} dependency
@@ -254,7 +280,7 @@ export class CodeChunk {
     }
 
     /**
-     * @returns {{text:string, extensions: string[]}}
+     * @returns {{text:string, extensions: string[], language_extensions: string[]}}
      */
     compile() {
 
@@ -262,6 +288,7 @@ export class CodeChunk {
         queue.push(this);
 
         const extension_hash = {};
+        const language_extension_hash = {};
 
         /**
          *
@@ -279,16 +306,23 @@ export class CodeChunk {
             for (let j = 0; j < ext.length; j++) {
                 extension_hash[ext[j]] = true;
             }
+
+            const lang_ext = chunk.#language_extensions;
+            for (let j = 0; j < lang_ext.length; j++) {
+                language_extension_hash[lang_ext[j]] = true;
+            }
         }
 
         // Enable required extensions
         const extensions = Object.keys(extension_hash).sort();
+        const language_extensions = Object.keys(language_extension_hash).sort();
 
         const text = result_parts.join('\n');
 
         return {
             text,
-            extensions
+            extensions,
+            language_extensions
         };
     }
 
@@ -312,6 +346,7 @@ export class CodeChunk {
         this.#text = other.#text;
         this.#dependencies = other.#dependencies.slice();
         this.#extensions = other.#extensions.slice();
+        this.#language_extensions = other.#language_extensions.slice();
     }
 
     /**

package/src/shade/renderer/shader/graph/compute/compute_binding_read_names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_binding_read_names.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/compute_binding_read_names.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+GAFY,MAAM,EAAE,CAuBnB"}
+{"version":3,"file":"compute_binding_read_names.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/graph/compute/compute_binding_read_names.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+GAFY,MAAM,EAAE,CA6BnB"}

package/src/shade/renderer/shader/graph/compute/compute_binding_read_names.js

@@ -14,6 +14,12 @@ export function compute_binding_read_names(binding_names, shader_resources) {
     const binding_names_read = [];
 
     for (const binding_name of binding_names) {
+        if (shader_resources.isImmediateName(binding_name)) {
+            // immediate data is immutable, so it is always a read
+            binding_names_read.push(binding_name);
+            continue;
+        }
+
         const resource = shader_resources.getResourceByName(binding_name);
 
         if (resource === undefined) {

package/src/shade/renderer/shader/graph/compute/graph_compute_indirect_pass.js

@@ -58,7 +58,7 @@ export function graph_compute_indirect_pass({
 
     command_handle = pass.read(command);
 
-    graph_prepare_pass_input_data(binding_names_read, bindings, pass, pass_data);
+    graph_prepare_pass_input_data(binding_names_read, bindings, pass, pass_data, shader_resources);
 
     return graph_prepare_compute_resources(
         shader_resources,

package/src/shade/renderer/shader/graph/compute/graph_compute_pass.js

@@ -56,7 +56,7 @@ export function graph_compute_pass({
 
     const pass = graph.add(shader_descriptor.label, pass_data, execute);
 
-    graph_prepare_pass_input_data(binding_names_read, bindings, pass, pass_data);
+    graph_prepare_pass_input_data(binding_names_read, bindings, pass, pass_data, shader_resources);
 
     return graph_prepare_compute_resources(
         shader_resources,

package/src/shade/renderer/shader/graph/graph_image_pass.js

@@ -152,7 +152,7 @@ export function graph_image_pass({
     const pass = graph.add(shader_descriptor.label, pass_data, execute);
 
     // parse inputs
-    graph_prepare_pass_input_data(input_names, inputs, pass, pass_data);
+    graph_prepare_pass_input_data(input_names, inputs, pass, pass_data, shader_descriptor.resources);
 
     if (input_depth !== -1) {
         pass_data[DEPTH_TEXTURE_NAME] = pass.read(input_depth);

package/src/shade/renderer/shader/graph/graph_prepare_bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_prepare_bindings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_prepare_bindings.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,yFANW,MAAM,EAAE,oFAmDlB"}
+{"version":3,"file":"graph_prepare_bindings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_prepare_bindings.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,yFANW,MAAM,EAAE,oFA0DlB"}

package/src/shade/renderer/shader/graph/graph_prepare_bindings.js

@@ -27,6 +27,13 @@ export function graph_prepare_bindings(
     for (let i = 0; i < input_name_count; i++) {
         const input_key = input_names[i];
 
+        if (resources_descriptor.isImmediateName(input_key)) {
+            // hand the value on unchanged — ComputeShader/ImageShader serialise it through
+            // ShaderResourceSetDescriptor#writeImmediate, and it never becomes a binding
+            bindings[input_key] = data[input_key];
+            continue;
+        }
+
         const resource_spec = resources_descriptor.getResourceByName(input_key);
 
         if (resource_spec === undefined) {

package/src/shade/renderer/shader/graph/graph_prepare_pass_input_data.d.ts

@@ -4,6 +4,8 @@
  * @param {Object} inputs
  * @param {FrameGraphBuilder} pass
  * @param {Object} pass_data
+ * @param {ShaderResourceSetDescriptor} [shader_resources] when given, its immediate data is carried
+ *        through verbatim instead of being read as a graph resource
  */
-export function graph_prepare_pass_input_data(input_names: string[], inputs: any, pass: FrameGraphBuilder, pass_data: any): void;
+export function graph_prepare_pass_input_data(input_names: string[], inputs: any, pass: FrameGraphBuilder, pass_data: any, shader_resources?: ShaderResourceSetDescriptor): void;
 //# sourceMappingURL=graph_prepare_pass_input_data.d.ts.map

package/src/shade/renderer/shader/graph/graph_prepare_pass_input_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_prepare_pass_input_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_prepare_pass_input_data.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,2DALW,MAAM,EAAE,8DA+BlB"}
+{"version":3,"file":"graph_prepare_pass_input_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_prepare_pass_input_data.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,2DAPW,MAAM,EAAE,8GA0ClB"}

package/src/shade/renderer/shader/graph/graph_prepare_pass_input_data.js

@@ -4,12 +4,15 @@
  * @param {Object} inputs
  * @param {FrameGraphBuilder} pass
  * @param {Object} pass_data
+ * @param {ShaderResourceSetDescriptor} [shader_resources] when given, its immediate data is carried
+ *        through verbatim instead of being read as a graph resource
  */
 export function graph_prepare_pass_input_data(
     input_names,
     inputs,
     pass,
-    pass_data
+    pass_data,
+    shader_resources
 ) {
     const input_count = input_names.length;
     for (let i = 0; i < input_count; i++) {
@@ -17,6 +20,14 @@ export function graph_prepare_pass_input_data(
 
         const input_field_value = inputs[input_key];
 
+        // An immediate is a value, not a resource the graph owns — and a `u32` immediate is a
+        // number, which the branch below would otherwise take for a graph resource id and read as
+        // one. Nothing to declare to the graph, so it passes straight through.
+        if (shader_resources !== undefined && shader_resources.isImmediateName(input_key)) {
+            pass_data[input_key] = input_field_value;
+            continue;
+        }
+
         let pass_input_value;
 
         const input_field_type = typeof input_field_value;

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;OAUG;IACH,8GAVW,mBAAmB,2BA+E7B;IAED;;;;;;;;;;OAUG;IACH,yIAiCC;IAED;;;;;;;OAOG;IACH,0GAcC;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DApL0D,iDAAiD"}
+{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;OAUG;IACH,8GAVW,mBAAmB,2BA+E7B;IAED;;;;;;;;;;OAUG;IACH,yIAkCC;IAED;;;;;;;OAOG;IACH,0GAcC;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DArL0D,iDAAiD"}

package/src/shade/renderer/shader/pass/RenderPassDescriptor.js

@@ -152,6 +152,7 @@ export class RenderPassDescriptor {
         return encoder.constructRenderPass({
             pipeline,
             bindings: this.resources.generateBindings(bindings),
+            immediate: encoder.writeImmediate(this.resources, bindings),
             colorAttachments: gpu_descriptor.colorAttachments,
             depthStencilAttachment: gpu_descriptor.depthStencilAttachment,
         });

package/src/shade/renderer/shader/resource/IMMEDIATE_DATA.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The WGSL language extension the `immediate` address space lives behind.
+ *
+ * Written with `requires`, not `enable` — it is a *language* extension, available whenever the
+ * implementation supports it, and it is not a `GPUFeatureName`.
+ *
+ * @see https://www.w3.org/TR/WGSL/#language_extension-immediate_address_space
+ * @type {string}
+ */
+export const IMMEDIATE_ADDRESS_SPACE_EXTENSION: string;
+/**
+ * The `maxImmediateSize` every conformant WebGPU device reports at minimum — a `maximum`-class limit
+ * whose default is 64 bytes, with no separate compatibility-mode value.
+ *
+ * Declaring more than this would compile on whichever machine happened to offer more and fail
+ * everywhere else, so it is refused where the declaration is written rather than where it breaks.
+ *
+ * @type {number}
+ */
+export const IMMEDIATE_SIZE_FLOOR: number;
+//# sourceMappingURL=IMMEDIATE_DATA.d.ts.map

package/src/shade/renderer/shader/resource/IMMEDIATE_DATA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMMEDIATE_DATA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/IMMEDIATE_DATA.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,gDAFU,MAAM,CAE2D;AAE3E;;;;;;;;GAQG;AACH,mCAFU,MAAM,CAEuB"}

package/src/shade/renderer/shader/resource/IMMEDIATE_DATA.js

@@ -0,0 +1,21 @@
+/**
+ * The WGSL language extension the `immediate` address space lives behind.
+ *
+ * Written with `requires`, not `enable` — it is a *language* extension, available whenever the
+ * implementation supports it, and it is not a `GPUFeatureName`.
+ *
+ * @see https://www.w3.org/TR/WGSL/#language_extension-immediate_address_space
+ * @type {string}
+ */
+export const IMMEDIATE_ADDRESS_SPACE_EXTENSION = 'immediate_address_space';
+
+/**
+ * The `maxImmediateSize` every conformant WebGPU device reports at minimum — a `maximum`-class limit
+ * whose default is 64 bytes, with no separate compatibility-mode value.
+ *
+ * Declaring more than this would compile on whichever machine happened to offer more and fail
+ * everywhere else, so it is refused where the declaration is written rather than where it breaks.
+ *
+ * @type {number}
+ */
+export const IMMEDIATE_SIZE_FLOOR = 64;