@woosh/meep-engine 3.11.0 → 3.11.2

package/src/shade/renderer/volumetrics/shader_volumetrics_build_scattering_lut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_scattering_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_scattering_lut.js"],"names":[],"mappings":"AAqPA,oEAIG;8BAhP2B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_scattering_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_scattering_lut.js"],"names":[],"mappings":"AAgQA,oEAIG;8BA3P2B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_scattering_lut.js

@@ -19,6 +19,7 @@ import { chunk_directional_lights_iteration_mask } from "../shader/chunk/light/i
 import { chunk_get_directional_light_info_by_index } from "../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
 import { chunk_sky_lut_compute_uv } from "../atmosphere/chunk_sky_lut_compute_uv.js";
 import { chunk_calculate_multiscattering } from "./chunk_calculate_multiscattering.js";
+import { chunk_camera_ray_planar_depth_scale } from "./chunk_camera_ray_planar_depth_scale.js";
 import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
 import { SCENE_VOLUMETRICS_METADATA_STRUCT } from "./SCENE_VOLUMETRICS_METADATA_STRUCT.js";
 
@@ -145,6 +146,14 @@ fn main(
     var inScatter = vec3<f32>(0.0);
     var throughput = vec3<f32>(1.0);
 
+    // Every t below is a PLANAR view-space depth off the froxel curve, but the loop uses their
+    // difference as a segment length in Beer's law and walks them along a unit ray to place world
+    // positions. Both want arc length, which is longer by 1/cos(theta). Uncorrected, the optical
+    // path is under-integrated by cos(theta) and fog thins toward the frame edges.
+    //
+    // Constant for the whole column, so this is one reciprocal per invocation rather than per slice.
+    let depth_to_distance = camera_ray_planar_depth_scale(view_ray.direction, camera);
+
     // start at the near plane
     var t_prev = camera_near_far.x;
 
@@ -154,7 +163,7 @@ fn main(
 
     // in-scatter (.rgb) and the TAA-accumulated mono extinction coefficient (.a) now share the
     // volume-lighting texture, so a single sample provides both.
-    let vl_start = far_sample_lighting(camera_near_far.x, uvw_start, view_ray.origin + view_ray.direction * camera_near_far.x, view_ray.direction);
+    let vl_start = far_sample_lighting(camera_near_far.x, uvw_start, view_ray.origin + view_ray.direction * (camera_near_far.x * depth_to_distance), view_ray.direction);
     var light_prev = vl_start.rgb;
     var extinction_prev = vl_start.a;
 
@@ -187,12 +196,13 @@ fn main(
             f32(resolution.z)
         ));
 
-        let dt = max(0.0, t_next - t_prev);
+        // planar depth difference -> arc length along the view ray (C-01b)
+        let dt = max(0.0, t_next - t_prev) * depth_to_distance;
 
         // 2. Fetch "Next" Value (The end of this segment)
         let uvw_next = vec3<f32>(tile_uv, next_index_dithered / f32(resolution.z));
 
-        let world_pos_next = view_ray.origin + view_ray.direction * t_next;
+        let world_pos_next = view_ray.origin + view_ray.direction * (t_next * depth_to_distance);
         let vl_next = far_sample_lighting(t_next, uvw_next, world_pos_next, view_ray.direction);
         let media_extinction = vl_next.a;
         let light_next = vl_next.rgb;
@@ -236,6 +246,7 @@ fn main(
         chunk_cluster_depth_to_z_slice,
         chunk_stbn_sample_vec3,
         chunk_camera_ray_from_uv,
+        chunk_camera_ray_planar_depth_scale,
         chunk_directional_lights_iteration_mask,
         chunk_get_directional_light_info_by_index,
         chunk_sky_lut_compute_uv,

package/src/shade/renderer/volumetrics/shader_volumetrics_build_sun_shadow_volume.d.ts

@@ -0,0 +1,8 @@
+/**
+ * One build shader per cascade, innermost first.
+ *
+ * @type {ComputeShader[]}
+ */
+export const shader_volumetrics_build_sun_shadow_volume: ComputeShader[];
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_build_sun_shadow_volume.d.ts.map

package/src/shade/renderer/volumetrics/shader_volumetrics_build_sun_shadow_volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_build_sun_shadow_volume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_sun_shadow_volume.js"],"names":[],"mappings":"AAuKA;;;;GAIG;AACH,yDAFU,aAAa,EAAE,CAG0E;8BA3KrE,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_sun_shadow_volume.js

@@ -0,0 +1,174 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { chunk_volumetrics_sample_froxel_extinction } from "./chunk_volumetrics_sample_froxel_extinction.js";
+import {
+    VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT,
+    VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION,
+    volumetrics_sun_shadow_sub_steps
+} from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+
+/**
+ * Q-04. Builds one cascade of the sun's optical-depth volume so the lighting pass can read a
+ * froxel's media self-shadowing in one fetch instead of marching 16 steps toward the sun for it.
+ *
+ * The structure is a light-aligned voxel grid holding a prefix sum of extinction along the sun
+ * axis — in the shadow-map taxonomy an opacity shadow map (Kim & Neumann 2001) with enough slices
+ * and hardware trilinear reconstruction that the slice artefacts it is remembered for do not
+ * appear, and exact rather than approximate for the piecewise-constant field a voxel grid is.
+ * Enshrouded (GPC 2024) ships the same thing, cascaded: 3D volumes with their z axis on the primary
+ * light, initialised from the participating media and then integrated by a 2D dispatch per column,
+ * each cascade seeded from the one outside it. Frostbite (SIGGRAPH 2015) cascades its extinction
+ * volume the same way, three clip-map levels of it, for the same reason.
+ *
+ * Fourier Opacity Mapping is the better-known answer and is the wrong one here. It exists because
+ * the medium usually arrives as unordered rasterized particles, where the only thing you can do is
+ * accumulate a fixed-size, order-independent, additively-blendable summary — and it pays for that
+ * with ringing at sharp density transitions. This engine's medium is already a 3D texture with a
+ * defined order along any axis, so the scan is available, exact, and has nothing to ring.
+ *
+ * One shader per cascade rather than one shader taking a cascade index, because the two things that
+ * vary — which cascade's transform to read, and whether there is an outer cascade to start from —
+ * both change the *bindings*, and a variant that declares an outer texture it never samples would
+ * have to be handed one.
+ *
+ * @param {number} index innermost cascade is 0
+ * @returns {ComputeShader}
+ * @see chunk_volumetrics_sun_optical_depth for the read side
+ * @see build_volumetrics_sun_shadow_transform for where each box is placed, and why it is stable
+ */
+function make_shader(index) {
+
+    const seeded = index < VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT - 1;
+
+    const sub_steps = volumetrics_sun_shadow_sub_steps(index);
+
+    const resources = new ShaderResourceSetDescriptor();
+
+    const group = resources.createGroup()
+        .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+        .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+        .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+        .addTexture("tParticipatingMedia1", "float", "3d");
+
+    if (seeded) {
+        group.addTexture("tSunShadowOuter", "float", "3d");
+    }
+
+    group.addStorageTexture("tSunShadowVolume", "rgba16float", "3d", "write-only");
+
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION.join(",")})
+fn main(
+    @builtin(global_invocation_id) column : vec3<u32>
+){
+    let resolution = textureDimensions(tSunShadowVolume);
+
+    if(any(column.xy >= resolution.xy)){
+        // overflow
+        return;
+    }
+
+    // The volume's z axis is the direction light TRAVELS, so this column is one sun ray and slice 0
+    // is its end nearest the sun. Walking it in order turns the per-froxel integral into a running
+    // sum: every voxel's optical depth is its predecessor's plus one slab. That is the whole point
+    // of the pass — the same information the 16-step march produces, in O(voxels) instead of
+    // O(froxels * steps), and produced once rather than once per froxel that happens to lie on the
+    // ray.
+    //
+    // One invocation per column rather than a cooperative scan. The dependency chain is one
+    // cascade's depth long and each link is a texture fetch, so a Hillis-Steele or Blinn-Sengupta
+    // scan would trade this pass's perfectly coherent, register-resident accumulator for log(n)
+    // rounds of shared memory and barriers to speed up something that is already bandwidth-bound.
+    // The aerial pass has the same shape for the same reason.
+    const CASCADE = ${index}u;
+
+    let uvw_to_ws = volumetrics_metadata.sun_shadow_uvw_to_ws[CASCADE];
+
+    // What a voxel must hold is the medium's INTEGRAL across its slab, not the medium's value at
+    // its centre, and one point sample per voxel is not that. A fog volume three units thick
+    // crossed by a 2.3-unit lattice has its entire optical depth resting on one or two samples:
+    // whether they land inside it, on its fade, or just outside swings the answer by the whole
+    // shadow, and the per-frame column jitter under them turns that into a strobe.
+    //
+    // So sample the slab several times and store the storage-resolution result. The sampling rate
+    // and the resolution are separate knobs and only the first one has to beat the medium's
+    // features. The count is per cascade — see volumetrics_sun_shadow_sub_steps — so that every
+    // cascade samples at the same world-space spacing rather than at the same count per voxel.
+    const SUB_STEPS = ${sub_steps}u;
+
+    let sub_step_ws = volumetrics_metadata.sun_shadow_step_ws[CASCADE] / f32(SUB_STEPS);
+
+    let column_uv = vec2<f32>(
+        (f32(column.x) + 0.5) / f32(resolution.x),
+        (f32(column.y) + 0.5) / f32(resolution.y)
+    );
+
+${seeded
+            ? `    // Seeded from the cascade outside this one, at the world position where this column enters
+    // this box. Everything between the sun and that plane has already been integrated out there, at
+    // that cascade's resolution, so the scan here starts from it rather than from zero and an inner
+    // cascade is a refinement of the outer rather than a truncation of the medium. Enshrouded
+    // describes exactly this: "each cascade as an initial shadow value reads the upper cascade".
+    //
+    // The clamp is a statement about the domain rather than a guard that fires: the outer box
+    // contains the whole frustum and this box's entry plane is a face of a box sized from a
+    // sub-frustum of it.
+    let entry_ws = (uvw_to_ws * vec4<f32>(column_uv, 0.0, 1.0)).xyz;
+
+    let outer_uvw = (volumetrics_metadata.sun_shadow_ws_to_uvw[CASCADE + 1u] * vec4<f32>(entry_ws, 1.0)).xyz;
+
+    var optical_depth = textureSampleLevel(tSunShadowOuter, sLinear, saturate(outer_uvw), 0.0).rgb;`
+            : `    // The outermost cascade's box contains the whole frustum, and the medium exists only inside
+    // the frustum, so the slab its scan starts on is empty and zero is the whole of the truth about
+    // what is between it and the sun.
+    var optical_depth = vec3<f32>(0.0);`}
+
+    for(var slice = 0u; slice < resolution.z; slice++){
+
+        let voxel = vec3<u32>(column.xy, slice);
+
+        for(var sub = 0u; sub < SUB_STEPS; sub++){
+
+            // Halfway through the slab, so the value stored at slice k is the integral from the
+            // box's sun-side face to the voxel's CENTRE. Linear interpolation between two stored
+            // values then reproduces the true integral exactly wherever extinction is constant
+            // across the pair. Storing the integral to the far face instead — a right-endpoint sum,
+            // which is what the march this replaces does — biases every reading by half a slab.
+            if(sub == SUB_STEPS / 2u){
+                textureStore(tSunShadowVolume, voxel, vec4<f32>(optical_depth, 0.0));
+            }
+
+            let w = (f32(slice) + (f32(sub) + 0.5) / f32(SUB_STEPS)) / f32(resolution.z);
+
+            let position_ws = (uvw_to_ws * vec4<f32>(column_uv, w, 1.0)).xyz;
+
+            optical_depth += volumetrics_sample_froxel_extinction(position_ws) * sub_step_ws;
+        }
+    }
+}
+    `, [
+            CAMERA_UNIFORM_STRUCT.declaration_chunk,
+            chunk_volumetrics_sample_froxel_extinction,
+        ]
+    );
+
+    return ComputeShader.from({
+        label: `Volumetrics / build sun shadow volume ${index}`,
+        resources,
+        body
+    });
+}
+
+/**
+ * One build shader per cascade, innermost first.
+ *
+ * @type {ComputeShader[]}
+ */
+export const shader_volumetrics_build_sun_shadow_volume =
+    Array.from({ length: VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT }, (_, index) => make_shader(index));

package/src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"volumetrics_position_world_to_froxel_uvw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,uDAFU,SAAS,CA8BlB;0BAnCyB,iCAAiC"}
+{"version":3,"file":"volumetrics_position_world_to_froxel_uvw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,uDAFU,SAAS,CAyClB;0BA/CyB,iCAAiC"}

package/src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js

@@ -1,37 +1,49 @@
-import { chunk_ndc_to_uv } from "../shader/chunk/texture/chunk_ndc_to_uv.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-
-/**
- * NOTE: we don't clamp final slice coordinate, this is intentional, we let the linear texture sampler take care of that.
- * See {@link build_light_cluster_parameters}
- * @type {CodeChunk}
- */
-export const volumetrics_position_world_to_froxel_uvw = CodeChunk.from(
-    //language=WGSL
-    `
-fn volumetrics_position_world_to_froxel_uvw(
-    position_ws: vec3<f32>
-) -> vec3<f32>{
-
-    let position_vs = camera.view_matrix * vec4(position_ws, 1.0);
-    let position_clip = camera.projection_matrix * position_vs;
-    
-    let uv = ndc_to_uv(position_clip.xy / position_clip.w);
- 
-    let view_depth = -position_vs.z;
-    let cluster_parameters = volumetrics_metadata.cluster_parameters;
-    
-    // see 'cluster_depth_to_z_slice' for explanation
-    let slice_position:f32 = log2(fma(view_depth, cluster_parameters.x, cluster_parameters.y)) * cluster_parameters.z;
-    
-    let w = (slice_position + 0.5) / f32(volumetrics_metadata.resolution.z);
-    
-    return vec3(
-        uv,
-        w
-    );
-}
-    `, [
-        chunk_ndc_to_uv,
-    ]
+import { chunk_ndc_to_uv } from "../shader/chunk/texture/chunk_ndc_to_uv.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_froxel_content_offset.js";
+
+/**
+ * NOTE: we don't clamp final slice coordinate, this is intentional, we let the linear texture sampler take care of that.
+ * See {@link build_light_cluster_parameters}
+ * @type {CodeChunk}
+ */
+export const volumetrics_position_world_to_froxel_uvw = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_position_world_to_froxel_uvw(
+    position_ws: vec3<f32>
+) -> vec3<f32>{
+
+    let position_vs = camera.view_matrix * vec4(position_ws, 1.0);
+    let position_clip = camera.projection_matrix * position_vs;
+    
+    let uv = ndc_to_uv(position_clip.xy / position_clip.w);
+ 
+    let view_depth = -position_vs.z;
+
+    // froxel_cluster_parameters, NOT cluster_parameters: this addresses the FROXEL grid, which the
+    // participating-media pass builds on that curve. cluster_parameters is the aerial LUT's. The
+    // two are identical while froxel_far is unset — which is why the mix-up went unnoticed — and
+    // diverge as soon as the grid is packed into a shorter range.
+    let cluster_parameters = volumetrics_metadata.froxel_cluster_parameters;
+
+    // see 'cluster_depth_to_z_slice' for explanation
+    let slice_position:f32 = log2(fma(view_depth, cluster_parameters.x, cluster_parameters.y)) * cluster_parameters.z;
+
+    // A cell-averaged grid: texel k holds the slab [k+j, k+1+j], not the point at slice k, so the
+    // texel-centre convention alone reads about half a froxel too far out. See
+    // chunk_volumetrics_froxel_content_offset for where the ~0.53 comes from.
+    let content_offset = volumetrics_froxel_content_offset(cluster_parameters.z);
+
+    let w = (slice_position + 0.5 - content_offset) / f32(volumetrics_metadata.resolution.z);
+    
+    return vec3(
+        uv,
+        w
+    );
+}
+    `, [
+        chunk_ndc_to_uv,
+        chunk_volumetrics_froxel_content_offset,
+    ]
 )

package/src/shade/wgsl/emulator/CPUBitmapData.d.ts

@@ -77,6 +77,16 @@ export class CPUBitmapData {
      * @param {number} [depth]
      */
     static float32(item_size: number, width: number, height?: number, depth?: number): CPUBitmapData;
+    /**
+     * Single-channel f32 bitmap flagged as a `texture_depth_*` binding — see {@link is_depth}.
+     * `textureLoad` on it yields a scalar, the way it does on a device.
+     *
+     * @param {number} width
+     * @param {number} [height]
+     * @param {number} [depth]
+     * @returns {CPUBitmapData}
+     */
+    static depth32(width: number, height?: number, depth?: number): CPUBitmapData;
     /**
      * @param {ArrayLike<number>} data
      * @param {number} item_size
@@ -101,6 +111,21 @@ export class CPUBitmapData {
      * @type {Uint32Array}
      */
     size: Uint32Array;
+    /**
+     * Marks this as backing a `texture_depth_*` binding rather than a `texture_2d<f32>`.
+     *
+     * The two differ in WGSL at the call site, not in storage: `textureLoad` on a depth texture
+     * returns a bare `f32`, while on a colour texture it returns `vec4<f32>`. Shader code written
+     * against a depth texture therefore uses the result as a scalar, and an emulator that always
+     * hands back a vec4 turns every such expression into a silent component-wise broadcast —
+     * arithmetic that neither throws nor resembles what the GPU does.
+     *
+     * Off by default, so nothing that does not opt in changes behaviour. Set it, or use
+     * {@link CPUBitmapData.depth32}, when binding a texture the shader declares as `depth`.
+     *
+     * @type {boolean}
+     */
+    is_depth: boolean;
     /** @returns {number} */
     get width(): number;
     /** @returns {number} */

package/src/shade/wgsl/emulator/CPUBitmapData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CPUBitmapData.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/CPUBitmapData.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA6HI;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,uBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAvLD;;;;;;OAMG;IACH,kBANW,UAAU,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,EAmBhB;IA3CD;;;OAGG;IACH,MAFU,YAAY,kBAAkB,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,EAAE,CAE1H;IAEL;;;OAGG;IACH,WAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IA4BL,wBAAwB;IACxB,oBAAoC;IACpC,wBAAwB;IACxB,qBAAqC;IACrC,wBAAwB;IACxB,oBAAoC;IAEpC;;;;;;OAMG;IACH,gCAIC;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;OASG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM;;oBAEN,MAAM,QAWhB;IAED;;;;;;;;;OASG;IACH,SANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,eACjB,MAAM,QAQhB;CAuFJ"}
+{"version":3,"file":"CPUBitmapData.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/CPUBitmapData.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA6II;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,uBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,WACN,MAAM,UACN,MAAM,GACJ,aAAa,CAQzB;IAxMD;;;;;;OAMG;IACH,kBANW,UAAU,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,EAmBhB;IA3DD;;;OAGG;IACH,MAFU,YAAY,kBAAkB,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,EAAE,CAE1H;IAEL;;;OAGG;IACH,WAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;;;;;;;;;;;OAaG;IACH,UAFU,OAAO,CAEA;IA4BjB,wBAAwB;IACxB,oBAAoC;IACpC,wBAAwB;IACxB,qBAAqC;IACrC,wBAAwB;IACxB,oBAAoC;IAEpC;;;;;;OAMG;IACH,gCAIC;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;OASG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM;;oBAEN,MAAM,QAWhB;IAED;;;;;;;;;OASG;IACH,SANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,eACjB,MAAM,QAQhB;CAwGJ"}

package/src/shade/wgsl/emulator/CPUBitmapData.js

@@ -42,6 +42,22 @@ export class CPUBitmapData {
      */
     size;
 
+    /**
+     * Marks this as backing a `texture_depth_*` binding rather than a `texture_2d<f32>`.
+     *
+     * The two differ in WGSL at the call site, not in storage: `textureLoad` on a depth texture
+     * returns a bare `f32`, while on a colour texture it returns `vec4<f32>`. Shader code written
+     * against a depth texture therefore uses the result as a scalar, and an emulator that always
+     * hands back a vec4 turns every such expression into a silent component-wise broadcast —
+     * arithmetic that neither throws nor resembles what the GPU does.
+     *
+     * Off by default, so nothing that does not opt in changes behaviour. Set it, or use
+     * {@link CPUBitmapData.depth32}, when binding a texture the shader declares as `depth`.
+     *
+     * @type {boolean}
+     */
+    is_depth = false;
+
     /**
      * @param {ArrayLike<number>} data
      * @param {number} item_size
@@ -226,4 +242,21 @@ export class CPUBitmapData {
     static float32(item_size, width, height = 1, depth = 1) {
         return new CPUBitmapData(new Float32Array(item_size * width * height * depth), item_size, width, height, depth);
     }
+
+    /**
+     * Single-channel f32 bitmap flagged as a `texture_depth_*` binding — see {@link is_depth}.
+     * `textureLoad` on it yields a scalar, the way it does on a device.
+     *
+     * @param {number} width
+     * @param {number} [height]
+     * @param {number} [depth]
+     * @returns {CPUBitmapData}
+     */
+    static depth32(width, height = 1, depth = 1) {
+        const result = CPUBitmapData.float32(1, width, height, depth);
+
+        result.is_depth = true;
+
+        return result;
+    }
 }